umt 1.9.0 → 2.1.0

package/module/es5/tests/unit/Array/drop.test.js

@@ -0,0 +1,84 @@
+"use strict";
+
+var _drop = require("@/Array/drop");
+var _lodash = _interopRequireDefault(require("lodash"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
+describe("drop関数のテスト", function () {
+  it("配列の先頭からn個の要素を除外する", function () {
+    // umt
+    expect((0, _drop.drop)([1, 2, 3, 4, 5], 2)).toEqual([3, 4, 5]);
+    expect((0, _drop.drop)([1, 2, 3, 4, 5])).toEqual([2, 3, 4, 5]);
+
+    // lodash
+    expect(_lodash["default"].drop([1, 2, 3, 4, 5], 2)).toEqual([3, 4, 5]);
+    expect(_lodash["default"].drop([1, 2, 3, 4, 5])).toEqual([2, 3, 4, 5]);
+  });
+  it("directionが'left'の場合、配列の先頭からn個の要素を除外する", function () {
+    // umt
+    expect((0, _drop.drop)([1, 2, 3, 4, 5], 2, "left")).toEqual([3, 4, 5]);
+
+    // lodash
+    expect(_lodash["default"].drop([1, 2, 3, 4, 5], 2)).toEqual([3, 4, 5]);
+  });
+  it("directionが'right'の場合、配列の末尾からn個の要素を除外する", function () {
+    // umt
+    expect((0, _drop.drop)([1, 2, 3, 4, 5], 2, "right")).toEqual([1, 2, 3]);
+
+    // lodash
+    expect(_lodash["default"].dropRight([1, 2, 3, 4, 5], 2)).toEqual([1, 2, 3]);
+  });
+  it("directionが'between'の場合、配列の中央からn個の要素を除外する", function () {
+    // umt
+    expect((0, _drop.drop)([1, 2, 3, 4, 5], 1, "between")).toEqual([1, 2, 4, 5]);
+    expect((0, _drop.drop)([1, 2, 3, 4, 5, 6], 2, "between")).toEqual([1, 2, 5, 6]);
+  });
+  it("nが配列の長さ以上の場合、空の配列を返す", function () {
+    // umt
+    expect((0, _drop.drop)([1, 2, 3], 4)).toEqual([]);
+    expect((0, _drop.drop)([1, 2, 3], 3)).toEqual([]);
+
+    // lodash
+    expect(_lodash["default"].drop([1, 2, 3], 4)).toEqual([]);
+    expect(_lodash["default"].drop([1, 2, 3], 3)).toEqual([]);
+  });
+  it("nが0の場合、元の配列をそのまま返す", function () {
+    // umt
+    expect((0, _drop.drop)([1, 2, 3], 0)).toEqual([1, 2, 3]);
+    expect((0, _drop.drop)([1, 2, 3], 0, "left")).toEqual([1, 2, 3]);
+    expect((0, _drop.drop)([1, 2, 3], 0, "right")).toEqual([1, 2, 3]);
+    expect((0, _drop.drop)([1, 2, 3], 0, "between")).toEqual([1, 2, 3]);
+
+    // lodash
+    expect(_lodash["default"].drop([1, 2, 3], 0)).toEqual([1, 2, 3]);
+    expect(_lodash["default"].drop([1, 2, 3], 0)).toEqual([1, 2, 3]);
+    expect(_lodash["default"].dropRight([1, 2, 3], 0)).toEqual([1, 2, 3]);
+  });
+  it("nが負の値の場合、元の配列をそのまま返す", function () {
+    // umt
+    expect((0, _drop.drop)([1, 2, 3], -1)).toEqual([1, 2, 3]);
+    expect((0, _drop.drop)([1, 2, 3], -2, "left")).toEqual([1, 2, 3]);
+    expect((0, _drop.drop)([1, 2, 3], -3, "right")).toEqual([1, 2, 3]);
+    expect((0, _drop.drop)([1, 2, 3], -4, "between")).toEqual([1, 2, 3]);
+
+    // lodash
+    expect(_lodash["default"].drop([1, 2, 3], -1)).toEqual([1, 2, 3]);
+    expect(_lodash["default"].drop([1, 2, 3], -2)).toEqual([1, 2, 3]);
+    expect(_lodash["default"].dropRight([1, 2, 3], -3)).toEqual([1, 2, 3]);
+  });
+  it("空の配列が渡された場合、空の配列を返す", function () {
+    // umt
+    expect((0, _drop.drop)([], 1)).toEqual([]);
+    expect((0, _drop.drop)([], 2, "left")).toEqual([]);
+    expect((0, _drop.drop)([], 3, "right")).toEqual([]);
+    expect((0, _drop.drop)([], 4, "between")).toEqual([]);
+
+    // lodash
+    expect(_lodash["default"].drop([], 1)).toEqual([]);
+    expect(_lodash["default"].drop([], 2)).toEqual([]);
+    expect(_lodash["default"].dropRight([], 3)).toEqual([]);
+  });
+  it("directionに無効な値が渡された場合、leftとして扱う", function () {
+    // @ts-ignore
+    expect((0, _drop.drop)([1, 2, 3], 1, "invalid")).toEqual([2, 3]);
+  });
+});

package/module/es5/tests/unit/Array/first.test.d.ts

@@ -0,0 +1 @@
+export {};

package/module/es5/tests/unit/Array/first.test.js

@@ -0,0 +1,28 @@
+"use strict";
+
+var _first = require("@/Array/first");
+describe("first", function () {
+  it("should return the first element of a non-empty array", function () {
+    expect((0, _first.first)([1, 2, 3])).toBe(1);
+    expect((0, _first.first)(["a", "b", "c"])).toBe("a");
+    expect((0, _first.first)([true, false, true])).toBe(true);
+    expect((0, _first.first)([{
+      key: "value"
+    }, {
+      key: "another"
+    }])).toEqual({
+      key: "value"
+    });
+  });
+  it("should return undefined for an empty array", function () {
+    expect((0, _first.first)([])).toBeUndefined();
+  });
+  it("should handle arrays with different types of elements", function () {
+    expect((0, _first.first)([1, "a", true])).toBe(1);
+    expect((0, _first.first)([undefined, null, 0])).toBeUndefined();
+  });
+  it("should handle arrays with only one element", function () {
+    expect((0, _first.first)([42])).toBe(42);
+    expect((0, _first.first)(["single"])).toBe("single");
+  });
+});

package/module/es5/tests/unit/Array/generateNumberArray.test.d.ts

@@ -0,0 +1 @@
+export {};

package/module/es5/tests/unit/Array/generateNumberArray.test.js

@@ -0,0 +1,34 @@
+"use strict";
+
+var _generateNumberArray = require("@/Array/generateNumberArray");
+describe("generateNumberArray", function () {
+  it("指定された長さの配列を生成する", function () {
+    var result = (0, _generateNumberArray.generateNumberArray)(5);
+    expect(result).toEqual([0, 1, 2, 3, 4]);
+  });
+  it("最小値と最大値を指定して配列を生成する", function () {
+    var result = (0, _generateNumberArray.generateNumberArray)(5, 10, 14);
+    expect(result).toEqual([10, 11, 12, 13, 14]);
+  });
+  it("長さが0の場合、空の配列を返す", function () {
+    var result = (0, _generateNumberArray.generateNumberArray)(0);
+    expect(result).toEqual([]);
+  });
+  it("最小値が最大値より大きい場合、エラーを投げる", function () {
+    expect(function () {
+      return (0, _generateNumberArray.generateNumberArray)(5, 10, 5);
+    }).toThrow("min should be less than or equal to max");
+  });
+  it("長さが1の場合、最小値を返す", function () {
+    var result = (0, _generateNumberArray.generateNumberArray)(1, 10, 20);
+    expect(result).toEqual([10]);
+  });
+  it("ランダムな値で配列を生成する", function () {
+    var result = (0, _generateNumberArray.generateNumberArray)(5, 10, 14, true);
+    expect(result).toHaveLength(5);
+    result.forEach(function (item) {
+      expect(item).toBeGreaterThanOrEqual(10);
+      expect(item).toBeLessThanOrEqual(14);
+    });
+  });
+});

package/module/es5/tests/unit/Array/getArraysCommon.test.d.ts

@@ -0,0 +1 @@
+export {};

package/module/es5/tests/unit/Array/getArraysCommon.test.js

@@ -0,0 +1,8 @@
+"use strict";
+
+var _getArraysCommon = require("@/Array/getArraysCommon");
+test("{getArraysCommon}", function () {
+  expect((0, _getArraysCommon.getArraysCommon)([1, 2, 3], [2, 3, 4])).toEqual([2, 3]);
+  expect((0, _getArraysCommon.getArraysCommon)([1, 2, 3], [2, 3, 9], [3, 4, 5])).toEqual([3]);
+  expect((0, _getArraysCommon.getArraysCommon)([1, 2, 3], [2, 3, 9], [3, 4, 5], [3, 4, 5])).toEqual([3]);
+});

package/module/es5/tests/unit/Array/getArraysDiff.test.d.ts

@@ -0,0 +1 @@
+export {};

package/module/es5/tests/unit/Array/getArraysDiff.test.js

@@ -0,0 +1,99 @@
+"use strict";
+
+var _getArraysDiff = require("@/Array/getArraysDiff");
+describe("getArraysDiff関数のテスト", function () {
+  // 通常のケース
+  test("通常の配列", function () {
+    expect((0, _getArraysDiff.getArraysDiff)([1, 2, 3], [2, 3, 4], [3, 4, 5])).toEqual([1, 5]);
+    expect((0, _getArraysDiff.getArraysDiff)([-1, 0, 1], [0, 1, 2], [1, 2, 3])).toEqual([-1, 3]);
+    expect((0, _getArraysDiff.getArraysDiff)([0.1, 0.2, 0.3], [0.2, 0.3, 0.4], [0.3, 0.4, 0.5])).toEqual([0.1, 0.5]);
+    expect((0, _getArraysDiff.getArraysDiff)(["a", "b", "c"], ["b", "c", "d"], ["c", "d", "e"])).toEqual(["a", "e"]);
+    expect((0, _getArraysDiff.getArraysDiff)(["あ", "い", "う"], ["い", "う", "え"], ["う", "え", "お"])).toEqual(["あ", "お"]);
+    expect((0, _getArraysDiff.getArraysDiff)([true, false], [false, true], [true, false])).toEqual([]);
+    expect((0, _getArraysDiff.getArraysDiff)([1, "a", true], [2, "b", false], [3, "c", true])).toEqual([1, "a", 2, "b", false, 3, "c"]);
+  });
+
+  // 空の配列があるケース
+  test("空の配列", function () {
+    expect((0, _getArraysDiff.getArraysDiff)([], [1, 2], [2, 3])).toEqual([1, 3]);
+    expect((0, _getArraysDiff.getArraysDiff)([1, 2], [], [2, 3])).toEqual([1, 3]);
+    expect((0, _getArraysDiff.getArraysDiff)([1, 2], [2, 3], [])).toEqual([1, 3]);
+    expect((0, _getArraysDiff.getArraysDiff)([], [], [1, 2, 3])).toEqual([1, 2, 3]);
+    expect((0, _getArraysDiff.getArraysDiff)(["a", "b"], [], ["b", "c"])).toEqual(["a", "c"]);
+    expect((0, _getArraysDiff.getArraysDiff)([], [true, false], [false, null])).toEqual([true, null]);
+    expect((0, _getArraysDiff.getArraysDiff)([{
+      x: 1
+    }], [], [{
+      z: 3
+    }])).toEqual([{
+      x: 1
+    }, {
+      z: 3
+    }]);
+    expect((0, _getArraysDiff.getArraysDiff)([], [[1, 2]], [[3, 4]])).toEqual([[1, 2], [3, 4]]);
+    expect((0, _getArraysDiff.getArraysDiff)([1, "a", true], [], [3, "c", false])).toEqual([1, "a", true, 3, "c", false]);
+    expect((0, _getArraysDiff.getArraysDiff)([], [], [])).toEqual([]);
+  });
+
+  // 重複要素がないケース
+  test("重複なし", function () {
+    expect((0, _getArraysDiff.getArraysDiff)([1, 2], [3, 4], [5, 6])).toEqual([1, 2, 3, 4, 5, 6]);
+    expect((0, _getArraysDiff.getArraysDiff)(["a", "b"], ["c", "d"], ["e", "f"])).toEqual(["a", "b", "c", "d", "e", "f"]);
+    expect((0, _getArraysDiff.getArraysDiff)([true], [false], [null])).toEqual([true, false, null]);
+    expect((0, _getArraysDiff.getArraysDiff)([{
+      x: 1
+    }], [{
+      y: 2
+    }], [{
+      z: 3
+    }])).toEqual([{
+      x: 1
+    }, {
+      y: 2
+    }, {
+      z: 3
+    }]);
+    expect((0, _getArraysDiff.getArraysDiff)([[1]], [[2]], [[3]])).toEqual([[1], [2], [3]]);
+    expect((0, _getArraysDiff.getArraysDiff)([1, "a"], [2, "b"], [3, "c"])).toEqual([1, "a", 2, "b", 3, "c"]);
+    expect((0, _getArraysDiff.getArraysDiff)([0.1], [0.2], [0.3])).toEqual([0.1, 0.2, 0.3]);
+    expect((0, _getArraysDiff.getArraysDiff)([new Date("2021-01-01")], [new Date("2021-01-02")], [new Date("2021-01-03")])).toEqual([new Date("2021-01-01"), new Date("2021-01-02"), new Date("2021-01-03")]);
+    expect((0, _getArraysDiff.getArraysDiff)([/a/], [/b/], [/c/])).toEqual([/a/, /b/, /c/]);
+  });
+
+  // 全ての配列が同じ要素を持つケース
+  test("全配列で重複", function () {
+    expect((0, _getArraysDiff.getArraysDiff)([1, 2, 3], [1, 2, 3], [1, 2, 3])).toEqual([]);
+    expect((0, _getArraysDiff.getArraysDiff)(["a", "b", "c"], ["a", "b", "c"], ["a", "b", "c"])).toEqual([]);
+    expect((0, _getArraysDiff.getArraysDiff)([true, false], [true, false], [true, false])).toEqual([]);
+    expect((0, _getArraysDiff.getArraysDiff)([1, "a", true], [1, "a", true], [1, "a", true])).toEqual([]);
+    expect((0, _getArraysDiff.getArraysDiff)([0.1, 0.2], [0.1, 0.2], [0.1, 0.2])).toEqual([]);
+  });
+
+  // 全ての配列が同じ要素を持っているが、順序が異なるケース
+  test("全配列で重複(順序異なる)", function () {
+    expect((0, _getArraysDiff.getArraysDiff)([1, 2, 3], [3, 1, 2], [2, 3, 1])).toEqual([]);
+    expect((0, _getArraysDiff.getArraysDiff)(["a", "b", "c"], ["c", "a", "b"], ["b", "c", "a"])).toEqual([]);
+    expect((0, _getArraysDiff.getArraysDiff)([true, false, null], [null, true, false], [false, null, true])).toEqual([]);
+    expect((0, _getArraysDiff.getArraysDiff)([1, "a", true], [true, 1, "a"], ["a", true, 1])).toEqual([]);
+    expect((0, _getArraysDiff.getArraysDiff)([0.1, 0.2, 0.3], [0.3, 0.1, 0.2], [0.2, 0.3, 0.1])).toEqual([]);
+  });
+
+  // 型が異なるケース
+  test("型が異なる", function () {
+    expect((0, _getArraysDiff.getArraysDiff)([1, "a", true], [true, "a"], [1, 2])).toEqual([2]);
+    expect((0, _getArraysDiff.getArraysDiff)([{
+      x: 1
+    }, [1, 2], 3], ["a", true, null], [false, 5, {
+      y: 2
+    }])).toEqual([{
+      x: 1
+    }, [1, 2], 3, "a", true, null, false, 5, {
+      y: 2
+    }]);
+    expect((0, _getArraysDiff.getArraysDiff)([1, "2", true], ["1", 2, false], [true, "1", 2])).toEqual([1, "2", false]);
+    expect((0, _getArraysDiff.getArraysDiff)([0, ""], [false, null], [undefined, NaN])).toEqual([0, "", false, null, undefined, NaN]);
+    expect((0, _getArraysDiff.getArraysDiff)([1n, 2n], [BigInt(1), BigInt(2)], [1, 2])).toEqual([1, 2]);
+    expect((0, _getArraysDiff.getArraysDiff)([new Map()], [new Set()], [new WeakMap()])).toEqual([new Map(), new Set(), new WeakMap()]);
+    expect((0, _getArraysDiff.getArraysDiff)([Symbol.iterator], [Symbol.asyncIterator], [Symbol.toStringTag])).toEqual([Symbol.iterator, Symbol.asyncIterator, Symbol.toStringTag]);
+  });
+});

package/module/es5/tests/unit/Array/groupBy.test.d.ts

@@ -0,0 +1 @@
+export {};

package/module/es5/tests/unit/Array/groupBy.test.js

@@ -0,0 +1,87 @@
+"use strict";
+
+var _groupBy = require("@/Array/groupBy");
+describe("groupBy", function () {
+  it("数値に基づいて奇数と偶数にグループ化する", function () {
+    var array = [1, 2, 3, 4, 5];
+    var result = (0, _groupBy.groupBy)(array, function (num) {
+      return num % 2 === 0 ? "even" : "odd";
+    });
+    expect(result).toEqual({
+      odd: [1, 3, 5],
+      even: [2, 4]
+    });
+  });
+  it("文字列の長さに基づいてグループ化する", function () {
+    var array = ["one", "two", "three", "four", "five"];
+    var result = (0, _groupBy.groupBy)(array, function (str) {
+      return str.length.toString();
+    });
+    expect(result).toEqual({
+      "3": ["one", "two"],
+      "4": ["four", "five"],
+      "5": ["three"]
+    });
+  });
+  it("真偽値に基づいてグループ化する", function () {
+    var array = [true, false, true, false, true];
+    var result = (0, _groupBy.groupBy)(array, function (bool) {
+      return bool.toString();
+    });
+    expect(result).toEqual({
+      "true": [true, true, true],
+      "false": [false, false]
+    });
+  });
+  it("オブジェクトのプロパティに基づいてグループ化する", function () {
+    var array = [{
+      type: "fruit",
+      name: "apple"
+    }, {
+      type: "vegetable",
+      name: "carrot"
+    }, {
+      type: "fruit",
+      name: "banana"
+    }, {
+      type: "vegetable",
+      name: "lettuce"
+    }];
+    var result = (0, _groupBy.groupBy)(array, function (item) {
+      return item.type;
+    });
+    expect(result).toEqual({
+      fruit: [{
+        type: "fruit",
+        name: "apple"
+      }, {
+        type: "fruit",
+        name: "banana"
+      }],
+      vegetable: [{
+        type: "vegetable",
+        name: "carrot"
+      }, {
+        type: "vegetable",
+        name: "lettuce"
+      }]
+    });
+  });
+  it("undefinedを返す関数を渡した場合、すべての要素がundefinedキーにグループ化される", function () {
+    var array = [1, 2, 3, 4, 5];
+    // @ts-ignore
+    var result = (0, _groupBy.groupBy)(array, function () {
+      return undefined;
+    });
+    expect(result).toEqual({
+      undefined: [1, 2, 3, 4, 5]
+    });
+  });
+  it("空の配列を渡した場合、空のオブジェクトが返される", function () {
+    var array = [];
+    var result = (0, _groupBy.groupBy)(array, function (num) {
+      return num % 2 === 0 ? "even" : "odd";
+    });
+    expect(result).toEqual({});
+  });
+});

package/module/es5/tests/unit/Array/insertionSort.test.d.ts

@@ -0,0 +1 @@
+export {};

package/module/es5/tests/unit/Array/insertionSort.test.js

@@ -0,0 +1,37 @@
+"use strict";
+
+var _insertionSort = require("@/Array/insertionSort");
+describe("insertionSort", function () {
+  it("空の配列をソートすると空の配列が返される", function () {
+    expect((0, _insertionSort.insertionSort)([])).toEqual([]);
+  });
+  it("既にソートされた配列はそのまま返される", function () {
+    expect((0, _insertionSort.insertionSort)([1, 2, 3])).toEqual([1, 2, 3]);
+  });
+  it("逆順にソートされた配列を正しくソートする", function () {
+    expect((0, _insertionSort.insertionSort)([3, 2, 1])).toEqual([1, 2, 3]);
+  });
+  it("ランダムな配列を正しくソートする", function () {
+    var array = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5];
+    var sortedArray = [].concat(array).sort(function (a, b) {
+      return a - b;
+    });
+    expect((0, _insertionSort.insertionSort)(array)).toEqual(sortedArray);
+  });
+  it("重複した要素を含む配列を正しくソートする", function () {
+    expect((0, _insertionSort.insertionSort)([2, 3, 3, 1, 2])).toEqual([1, 2, 2, 3, 3]);
+  });
+  it("負の数を含む配列を正しくソートする", function () {
+    expect((0, _insertionSort.insertionSort)([5, -1, 3, 2, 4, -5, 1, -2, 0])).toEqual([-5, -2, -1, 0, 1, 2, 3, 4, 5]);
+  });
+  it("配列を降順にソートする", function () {
+    expect((0, _insertionSort.insertionSort)([1, 2, 3], function (a, b) {
+      return b - a;
+    })).toEqual([3, 2, 1]);
+  });
+  it("部分配列をソートする", function () {
+    expect((0, _insertionSort.insertionSort)([1, 3, 2, 5, 4], function (a, b) {
+      return a - b;
+    }, 1, 3)).toEqual([1, 2, 3, 5, 4]);
+  });
+});

package/module/es5/tests/unit/Array/mergeSort.test.d.ts

@@ -0,0 +1 @@
+export {};

package/module/es5/tests/unit/Array/mergeSort.test.js

@@ -0,0 +1,20 @@
+"use strict";
+
+var _mergeSort = require("@/Array/mergeSort");
+describe("mergeSort", function () {
+  it("空の配列を渡した場合、空の配列を返す", function () {
+    expect((0, _mergeSort.mergeSort)([])).toEqual([]);
+  });
+  it("既にソートされた配列を渡した場合、同じ配列を返す", function () {
+    expect((0, _mergeSort.mergeSort)([1, 2, 3])).toEqual([1, 2, 3]);
+  });
+  it("逆順にソートされた配列を渡した場合、正しくソートされた配列を返す", function () {
+    expect((0, _mergeSort.mergeSort)([3, 2, 1])).toEqual([1, 2, 3]);
+  });
+  it("ランダムな順序の配列を渡した場合、正しくソートされた配列を返す", function () {
+    expect((0, _mergeSort.mergeSort)([2, 3, 1])).toEqual([1, 2, 3]);
+  });
+  it("重複した要素を含む配列を渡した場合、正しくソートされた配列を返す", function () {
+    expect((0, _mergeSort.mergeSort)([2, 3, 3, 1, 2])).toEqual([1, 2, 2, 3, 3]);
+  });
+});

package/module/es5/tests/unit/Array/pop.test.d.ts

@@ -0,0 +1 @@
+export {};

package/module/es5/tests/unit/Array/pop.test.js

@@ -0,0 +1,50 @@
+"use strict";
+
+var _pop = require("@/Array/pop");
+describe("pop", function () {
+  it("should remove and return the last element of the array", function () {
+    var array = [1, 2, 3];
+    var result = (0, _pop.pop)(array);
+    expect(result).toBe(3);
+    expect(array).toEqual([1, 2, 3]);
+  });
+  it("should return undefined for an empty array", function () {
+    var array = [];
+    var result = (0, _pop.pop)(array);
+    expect(result).toBeUndefined();
+  });
+  it("should handle arrays with one element", function () {
+    var array = [42];
+    var result = (0, _pop.pop)(array);
+    expect(result).toBe(42);
+    expect(array).toEqual([42]);
+  });
+  it("should handle arrays with multiple types", function () {
+    var array = [1, "two", true];
+    var result = (0, _pop.pop)(array);
+    expect(result).toBe(true);
+    expect(array).toEqual([1, "two", true]);
+  });
+  it("should handle arrays with nested arrays", function () {
+    var array = [1, [2, 3], 4];
+    var result = (0, _pop.pop)(array);
+    expect(result).toBe(4);
+    expect(array).toEqual([1, [2, 3], 4]);
+  });
+  it("should handle arrays with objects", function () {
+    var array = [{
+      a: 1
+    }, {
+      b: 2
+    }];
+    var result = (0, _pop.pop)(array);
+    expect(result).toEqual({
+      b: 2
+    });
+    expect(array).toEqual([{
+      a: 1
+    }, {
+      b: 2
+    }]);
+  });
+});

package/module/es5/tests/unit/Array/quickSort.test.d.ts

@@ -0,0 +1 @@
+export {};

package/module/es5/tests/unit/Array/quickSort.test.js

@@ -0,0 +1,53 @@
+"use strict";
+
+var _quickSort = require("@/Array/quickSort");
+describe("quickSort", function () {
+  it("空の配列をソートすると空の配列が返される", function () {
+    expect((0, _quickSort.quickSort)([])).toEqual([]);
+  });
+  it("既にソートされた配列はそのまま返される", function () {
+    expect((0, _quickSort.quickSort)([1, 2, 3, 4, 5])).toEqual([1, 2, 3, 4, 5]);
+  });
+  it("逆順にソートされた配列を正しくソートする", function () {
+    expect((0, _quickSort.quickSort)([5, 4, 3, 2, 1])).toEqual([1, 2, 3, 4, 5]);
+  });
+  it("ランダムな配列を正しくソートする", function () {
+    expect((0, _quickSort.quickSort)([3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5])).toEqual([1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9]);
+  });
+  it("重複した要素を含む配列を正しくソートする", function () {
+    expect((0, _quickSort.quickSort)([3, 3, 3, 2, 1, 1, 4, 4, 5])).toEqual([1, 1, 2, 3, 3, 3, 4, 4, 5]);
+  });
+  it("大量の要素を含む配列を正しくソートする", function () {
+    var largeArray = Array.from({
+      length: 10000
+    }, function () {
+      return Math.floor(Math.random() * 10000);
+    });
+    var sortedArray = [].concat(largeArray).sort(function (a, b) {
+      return a - b;
+    });
+    expect((0, _quickSort.quickSort)(largeArray)).toEqual(sortedArray);
+  });
+  it("負の数を含む配列を正しくソートする", function () {
+    expect((0, _quickSort.quickSort)([5, -1, 3, 2, 4, -5, 1, -2, 0])).toEqual([-5, -2, -1, 0, 1, 2, 3, 4, 5]);
+  });
+  it("配列を降順にソートする", function () {
+    expect((0, _quickSort.quickSort)([1, 2, 3, 4, 5], function (a, b) {
+      return b - a;
+    })).toEqual([5, 4, 3, 2, 1]);
+  });
+  it("部分配列をソートする", function () {
+    expect((0, _quickSort.quickSort)([3, 1, 4, 1, 5], undefined, 1, 3)).toEqual([3, 1, 1, 4, 5]);
+  });
+  it("単一要素の配列が変更されずに返される", function () {
+    expect((0, _quickSort.quickSort)([1])).toEqual([1]);
+  });
+  it("compareFunctionが例外を投げる場合", function () {
+    var throwCompare = function throwCompare() {
+      throw new Error("Error during comparison");
+    };
+    expect(function () {
+      return (0, _quickSort.quickSort)([3, 1, 4], throwCompare);
+    }).toThrow("Error during comparison");
+  });
+});

package/module/es5/tests/unit/Array/randomSelect.test.d.ts

@@ -0,0 +1 @@
+export {};

package/module/es5/tests/unit/Array/randomSelect.test.js

@@ -0,0 +1,46 @@
+"use strict";
+
+var _randomSelect = require("@/Array/randomSelect");
+describe("randomSelect", function () {
+  it("指定された数の要素をランダムに選択する", function () {
+    var array = [1, 2, 3, 4, 5];
+    var result = (0, _randomSelect.randomSelect)(array, 2);
+    expect(result).toHaveLength(2);
+    result.forEach(function (item) {
+      expect(array).toContain(item);
+    });
+  });
+  it("選択する要素の数が配列の長さを超える場合、元の配列の長さと同じ数の要素を返す", function () {
+    var array = [1, 2, 3];
+    var result = (0, _randomSelect.randomSelect)(array, 5);
+    expect(result).toHaveLength(3);
+    result.forEach(function (item) {
+      expect(array).toContain(item);
+    });
+  });
+  it("空の配列を渡した場合、空の配列を返す", function () {
+    var result = (0, _randomSelect.randomSelect)([], 3);
+    expect(result).toEqual([]);
+  });
+  it("重複を許す場合、指定された数の要素を返す", function () {
+    var array = [1, 2, 3];
+    var result = (0, _randomSelect.randomSelect)(array, 5, true);
+    expect(result).toHaveLength(5);
+    result.forEach(function (item) {
+      expect(array).toContain(item);
+    });
+  });
+  it("重複を許さない場合、指定された数の要素を返す", function () {
+    var array = [1, 2, 3, 4, 5];
+    var result = (0, _randomSelect.randomSelect)(array, 3, false);
+    expect(result).toHaveLength(3);
+    result.forEach(function (item) {
+      expect(array).toContain(item);
+    });
+  });
+  it("選択する要素の数がマイナスの場合、空の配列を返す", function () {
+    var array = [1, 2, 3, 4, 5];
+    var result = (0, _randomSelect.randomSelect)(array, -1);
+    expect(result).toEqual([]);
+  });
+});

package/module/es5/tests/unit/Array/range.test.d.ts

@@ -0,0 +1 @@
+export {};

package/module/es5/tests/unit/Array/range.test.js

@@ -0,0 +1,21 @@
+"use strict";
+
+var _range = require("@/Array/range");
+describe("range", function () {
+  test("-5から5までの連続した数字の配列を生成する。", function () {
+    var result = (0, _range.range)(-5, 5);
+    expect(result).toEqual([-5, -4, -3, -2, -1, 0, 1, 2, 3, 4]);
+  });
+  test("1から10までの連続した数字の配列を生成する。", function () {
+    var result = (0, _range.range)(1, 10);
+    expect(result).toEqual([1, 2, 3, 4, 5, 6, 7, 8, 9]);
+  });
+  test("空の配列が出力される。", function () {
+    expect((0, _range.range)(0, 0)).toEqual([]);
+    expect((0, _range.range)(5, 5)).toEqual([]);
+  });
+  test("0から5までの連続した数字の配列を生成する。", function () {
+    var result = (0, _range.range)(5);
+    expect(result).toEqual([0, 1, 2, 3, 4]);
+  });
+});

package/module/es5/tests/unit/Array/shuffle.test.d.ts

@@ -0,0 +1 @@
+export {};

package/module/es5/tests/unit/Array/shuffle.test.js

@@ -0,0 +1,37 @@
+"use strict";
+
+var _shuffle = require("@/Array/shuffle");
+describe("shuffle関数のテスト", function () {
+  it("配列の要素がシャッフルされること", function () {
+    var array = [1, 2, 3, 4, 5];
+    var shuffledArray = (0, _shuffle.shuffle)(array);
+    expect(shuffledArray).not.toEqual(array);
+    expect(shuffledArray.sort()).toEqual(array.sort());
+  });
+  it("空の配列がそのまま返されること", function () {
+    var array = [];
+    var shuffledArray = (0, _shuffle.shuffle)(array);
+    expect(shuffledArray).toEqual(array);
+  });
+  it("シャッフルされた配列の長さが元の配列と同じであること", function () {
+    var array = [1, 2, 3, 4, 5];
+    var shuffledArray = (0, _shuffle.shuffle)(array);
+    expect(shuffledArray.length).toBe(array.length);
+  });
+  it("文字列と数値が混在した配列の要素がシャッフルされること", function () {
+    var array = [1, "2", 3, "4", 5];
+    var shuffledArray = (0, _shuffle.shuffle)(array);
+    expect(shuffledArray).not.toEqual(array);
+    expect(shuffledArray.sort()).toEqual(array.sort());
+  });
+  it("長い配列の要素がシャッフルされること", function () {
+    var array = Array.from({
+      length: 1000
+    }, function (_, index) {
+      return index;
+    });
+    var shuffledArray = (0, _shuffle.shuffle)(array);
+    expect(shuffledArray).not.toEqual(array);
+    expect(shuffledArray.sort()).toEqual(array.sort());
+  });
+});

package/module/es5/tests/unit/Array/shuffle2DArray.test.d.ts

@@ -0,0 +1 @@
+export {};