umt 2.1.1 → 2.2.0

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

@@ -3,8 +3,8 @@
 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 () {
+describe("drop function", function () {
+  it("should exclude n elements from the start of the array", 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]);
@@ -13,26 +13,26 @@ describe("drop関数のテスト", function () {
     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 () {
+  it("should exclude n elements from the start when direction is 'left'", 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 () {
+  it("should exclude n elements from the end when direction is 'right'", 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 () {
+  it("should exclude n elements from the middle when direction is 'between'", 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 () {
+  it("should return an empty array when n is greater than or equal to array length", function () {
     // umt
     expect((0, _drop.drop)([1, 2, 3], 4)).toEqual([]);
     expect((0, _drop.drop)([1, 2, 3], 3)).toEqual([]);
@@ -41,7 +41,7 @@ describe("drop関数のテスト", function () {
     expect(_lodash["default"].drop([1, 2, 3], 4)).toEqual([]);
     expect(_lodash["default"].drop([1, 2, 3], 3)).toEqual([]);
   });
-  it("nが0の場合、元の配列をそのまま返す", function () {
+  it("should return the original array when n is 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]);
@@ -53,7 +53,7 @@ describe("drop関数のテスト", function () {
     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 () {
+  it("should return the original array when n is negative", 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]);
@@ -65,7 +65,7 @@ describe("drop関数のテスト", function () {
     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 () {
+  it("should return an empty array when an empty array is passed", function () {
     // umt
     expect((0, _drop.drop)([], 1)).toEqual([]);
     expect((0, _drop.drop)([], 2, "left")).toEqual([]);
@@ -77,7 +77,7 @@ describe("drop関数のテスト", function () {
     expect(_lodash["default"].drop([], 2)).toEqual([]);
     expect(_lodash["default"].dropRight([], 3)).toEqual([]);
   });
-  it("directionに無効な値が渡された場合、leftとして扱う", function () {
+  it("should treat as 'left' when an invalid direction is passed", function () {
     // @ts-ignore
     expect((0, _drop.drop)([1, 2, 3], 1, "invalid")).toEqual([2, 3]);
   });

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

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

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

@@ -0,0 +1,87 @@
+"use strict";
+
+var _dualPivotQuickSort = require("../../../Array/dualPivotQuickSort");
+describe("dualPivotQuickSort", function () {
+  test("should sort an array of numbers in ascending order", function () {
+    var array = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3];
+    expect((0, _dualPivotQuickSort.dualPivotQuickSort)([].concat(array))).toEqual([1, 1, 2, 3, 3, 4, 5, 5, 6, 9]);
+  });
+  test("should sort an array of strings lexicographically", function () {
+    var array = ["banana", "apple", "orange", "grape"];
+    expect((0, _dualPivotQuickSort.dualPivotQuickSort)([].concat(array))).toEqual(["apple", "banana", "grape", "orange"]);
+  });
+  test("should sort in descending order when custom comparison function is provided", function () {
+    var array = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3];
+    var compareFunction = function compareFunction(a, b) {
+      return b - a;
+    };
+    expect((0, _dualPivotQuickSort.dualPivotQuickSort)([].concat(array), compareFunction)).toEqual([9, 6, 5, 5, 4, 3, 3, 2, 1, 1]);
+  });
+  test("should handle empty array", function () {
+    expect((0, _dualPivotQuickSort.dualPivotQuickSort)([])).toEqual([]);
+  });
+  test("should handle array with single element", function () {
+    expect((0, _dualPivotQuickSort.dualPivotQuickSort)([1])).toEqual([1]);
+  });
+  test("should handle array with all identical elements", function () {
+    var array = [2, 2, 2, 2, 2];
+    expect((0, _dualPivotQuickSort.dualPivotQuickSort)([].concat(array))).toEqual([2, 2, 2, 2, 2]);
+  });
+  test("should handle already sorted array", function () {
+    var array = [1, 2, 3, 4, 5];
+    expect((0, _dualPivotQuickSort.dualPivotQuickSort)([].concat(array))).toEqual([1, 2, 3, 4, 5]);
+  });
+  test("should handle reverse sorted array", function () {
+    var array = [5, 4, 3, 2, 1];
+    expect((0, _dualPivotQuickSort.dualPivotQuickSort)([].concat(array))).toEqual([1, 2, 3, 4, 5]);
+  });
+  test("should handle array with negative numbers", function () {
+    var array = [-3, 1, -4, 1, 5, -9, 2, 6, 5, 3];
+    expect((0, _dualPivotQuickSort.dualPivotQuickSort)([].concat(array))).toEqual([-9, -4, -3, 1, 1, 2, 3, 5, 5, 6]);
+  });
+  test("should sort only specified range of array", function () {
+    var array = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3];
+    expect((0, _dualPivotQuickSort.dualPivotQuickSort)([].concat(array), undefined, 2, 6)).toEqual([3, 1, 1, 2, 4, 5, 9, 6, 5, 3]);
+  });
+  test("should handle large arrays efficiently", function () {
+    var size = 1000;
+    var array = Array.from({
+      length: size
+    }, function () {
+      return Math.floor(Math.random() * size);
+    });
+    var sorted = (0, _dualPivotQuickSort.dualPivotQuickSort)([].concat(array));
+    for (var i = 1; i < sorted.length; i++) {
+      expect(sorted[i]).toBeGreaterThanOrEqual(sorted[i - 1]);
+    }
+  });
+  test("should use insertion sort for small arrays when threshold is adjusted", function () {
+    var array = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3];
+    expect((0, _dualPivotQuickSort.dualPivotQuickSort)([].concat(array), undefined, 0, array.length - 1, 5)).toEqual([1, 1, 2, 3, 3, 4, 5, 5, 6, 9]);
+  });
+  test("should sort array of objects using custom comparison", function () {
+    var array = [{
+      id: 3,
+      value: "c"
+    }, {
+      id: 1,
+      value: "a"
+    }, {
+      id: 2,
+      value: "b"
+    }];
+    var compareFunction = function compareFunction(a, b) {
+      return a.id - b.id;
+    };
+    expect((0, _dualPivotQuickSort.dualPivotQuickSort)([].concat(array), compareFunction)).toEqual([{
+      id: 1,
+      value: "a"
+    }, {
+      id: 2,
+      value: "b"
+    }, {
+      id: 3,
+      value: "c"
+    }]);
+  });
+});

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

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

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

@@ -1,8 +1,40 @@
 "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]);
+describe("getArraysCommon", function () {
+  it("should find common elements between arrays", function () {
+    // Test with two arrays
+    expect((0, _getArraysCommon.getArraysCommon)([1, 2, 3], [2, 3, 4])).toEqual([2, 3]);
+
+    // Test with three arrays
+    expect((0, _getArraysCommon.getArraysCommon)([1, 2, 3], [2, 3, 9], [3, 4, 5])).toEqual([3]);
+
+    // Test with four arrays (including duplicates)
+    expect((0, _getArraysCommon.getArraysCommon)([1, 2, 3], [2, 3, 9], [3, 4, 5], [3, 4, 5])).toEqual([3]);
+  });
+  it("should handle empty arrays", function () {
+    expect((0, _getArraysCommon.getArraysCommon)([], [])).toEqual([]);
+    expect((0, _getArraysCommon.getArraysCommon)([1, 2, 3], [])).toEqual([]);
+    expect((0, _getArraysCommon.getArraysCommon)([], [1, 2, 3])).toEqual([]);
+  });
+  it("should handle arrays with no common elements", function () {
+    expect((0, _getArraysCommon.getArraysCommon)([1, 2, 3], [4, 5, 6])).toEqual([]);
+    expect((0, _getArraysCommon.getArraysCommon)([1, 2], [3, 4], [5, 6])).toEqual([]);
+  });
+  it("should handle arrays of strings", function () {
+    expect((0, _getArraysCommon.getArraysCommon)(["a", "b", "c"], ["b", "c", "d"])).toEqual(["b", "c"]);
+    expect((0, _getArraysCommon.getArraysCommon)(["a", "b", "c"], ["b", "c", "d"], ["c", "d", "e"])).toEqual(["c"]);
+  });
+  it("should handle arrays of objects", function () {
+    var obj1 = {
+      id: 1
+    };
+    var obj2 = {
+      id: 2
+    };
+    var obj3 = {
+      id: 3
+    };
+    expect((0, _getArraysCommon.getArraysCommon)([obj1, obj2, obj3], [obj2, obj3], [obj3])).toEqual([obj3]);
+  });
 });

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

@@ -1,9 +1,9 @@
 "use strict";
 
 var _getArraysDiff = require("@/Array/getArraysDiff");
-describe("getArraysDiff関数のテスト", function () {
-  // 通常のケース
-  test("通常の配列", function () {
+describe("getArraysDiff function", function () {
+  // Normal cases
+  test("should handle standard arrays", 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]);
@@ -13,8 +13,8 @@ describe("getArraysDiff関数のテスト", function () {
     expect((0, _getArraysDiff.getArraysDiff)([1, "a", true], [2, "b", false], [3, "c", true])).toEqual([1, "a", 2, "b", false, 3, "c"]);
   });
 
-  // 空の配列があるケース
-  test("空の配列", function () {
+  // Cases with empty arrays
+  test("should handle empty arrays", 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]);
@@ -35,8 +35,8 @@ describe("getArraysDiff関数のテスト", function () {
     expect((0, _getArraysDiff.getArraysDiff)([], [], [])).toEqual([]);
   });
 
-  // 重複要素がないケース
-  test("重複なし", function () {
+  // Cases with no duplicate elements
+  test("should handle arrays with no duplicates", 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]);
@@ -60,8 +60,8 @@ describe("getArraysDiff関数のテスト", function () {
     expect((0, _getArraysDiff.getArraysDiff)([/a/], [/b/], [/c/])).toEqual([/a/, /b/, /c/]);
   });
 
-  // 全ての配列が同じ要素を持つケース
-  test("全配列で重複", function () {
+  // Cases where all arrays have the same elements
+  test("should handle arrays with identical elements", 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([]);
@@ -69,8 +69,8 @@ describe("getArraysDiff関数のテスト", function () {
     expect((0, _getArraysDiff.getArraysDiff)([0.1, 0.2], [0.1, 0.2], [0.1, 0.2])).toEqual([]);
   });
 
-  // 全ての配列が同じ要素を持っているが、順序が異なるケース
-  test("全配列で重複(順序異なる)", function () {
+  // Cases where all arrays have the same elements but in different order
+  test("should handle arrays with identical elements in different order", 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([]);
@@ -78,8 +78,8 @@ describe("getArraysDiff関数のテスト", function () {
     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 () {
+  // Cases with different types
+  test("should handle arrays with different types", function () {
     expect((0, _getArraysDiff.getArraysDiff)([1, "a", true], [true, "a"], [1, 2])).toEqual([2]);
     expect((0, _getArraysDiff.getArraysDiff)([{
       x: 1
@@ -91,7 +91,7 @@ describe("getArraysDiff関数のテスト", function () {
       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)([0, ""], [false, null], [undefined, Number.NaN])).toEqual([0, "", false, null, undefined, Number.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.js

@@ -2,7 +2,7 @@
 
 var _groupBy = require("@/Array/groupBy");
 describe("groupBy", function () {
-  it("数値に基づいて奇数と偶数にグループ化する", function () {
+  it("should group numbers into odd and even", function () {
     var array = [1, 2, 3, 4, 5];
     var result = (0, _groupBy.groupBy)(array, function (num) {
       return num % 2 === 0 ? "even" : "odd";
@@ -12,7 +12,7 @@ describe("groupBy", function () {
       even: [2, 4]
     });
   });
-  it("文字列の長さに基づいてグループ化する", function () {
+  it("should group strings based on their length", function () {
     var array = ["one", "two", "three", "four", "five"];
     var result = (0, _groupBy.groupBy)(array, function (str) {
       return str.length.toString();
@@ -23,7 +23,7 @@ describe("groupBy", function () {
       "5": ["three"]
     });
   });
-  it("真偽値に基づいてグループ化する", function () {
+  it("should group boolean values", function () {
     var array = [true, false, true, false, true];
     var result = (0, _groupBy.groupBy)(array, function (bool) {
       return bool.toString();
@@ -33,7 +33,7 @@ describe("groupBy", function () {
       "false": [false, false]
     });
   });
-  it("オブジェクトのプロパティに基づいてグループ化する", function () {
+  it("should group objects based on their properties", function () {
     var array = [{
       type: "fruit",
       name: "apple"
@@ -67,7 +67,7 @@ describe("groupBy", function () {
       }]
     });
   });
-  it("undefinedを返す関数を渡した場合、すべての要素がundefinedキーにグループ化される", function () {
+  it("should group all elements under undefined key when iterator returns undefined", function () {
     var array = [1, 2, 3, 4, 5];
     // @ts-ignore
     var result = (0, _groupBy.groupBy)(array, function () {
@@ -77,7 +77,7 @@ describe("groupBy", function () {
       undefined: [1, 2, 3, 4, 5]
     });
   });
-  it("空の配列を渡した場合、空のオブジェクトが返される", function () {
+  it("should return an empty object for an empty array", function () {
     var array = [];
     var result = (0, _groupBy.groupBy)(array, function (num) {
       return num % 2 === 0 ? "even" : "odd";

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

@@ -2,34 +2,34 @@
 
 var _insertionSort = require("@/Array/insertionSort");
 describe("insertionSort", function () {
-  it("空の配列をソートすると空の配列が返される", function () {
+  it("should return an empty array when sorting an empty array", function () {
     expect((0, _insertionSort.insertionSort)([])).toEqual([]);
   });
-  it("既にソートされた配列はそのまま返される", function () {
+  it("should return the same array when it's already sorted", function () {
     expect((0, _insertionSort.insertionSort)([1, 2, 3])).toEqual([1, 2, 3]);
   });
-  it("逆順にソートされた配列を正しくソートする", function () {
+  it("should correctly sort a reverse-sorted array", function () {
     expect((0, _insertionSort.insertionSort)([3, 2, 1])).toEqual([1, 2, 3]);
   });
-  it("ランダムな配列を正しくソートする", function () {
+  it("should correctly sort a random array", 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 () {
+  it("should correctly sort an array with duplicate elements", function () {
     expect((0, _insertionSort.insertionSort)([2, 3, 3, 1, 2])).toEqual([1, 2, 2, 3, 3]);
   });
-  it("負の数を含む配列を正しくソートする", function () {
+  it("should correctly sort an array with negative numbers", 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 () {
+  it("should sort array in descending order", function () {
     expect((0, _insertionSort.insertionSort)([1, 2, 3], function (a, b) {
       return b - a;
     })).toEqual([3, 2, 1]);
   });
-  it("部分配列をソートする", function () {
+  it("should sort a portion of the array", 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.js

@@ -2,19 +2,48 @@
 
 var _mergeSort = require("@/Array/mergeSort");
 describe("mergeSort", function () {
-  it("空の配列を渡した場合、空の配列を返す", function () {
+  it("should return an empty array when given an empty array", function () {
     expect((0, _mergeSort.mergeSort)([])).toEqual([]);
   });
-  it("既にソートされた配列を渡した場合、同じ配列を返す", function () {
+  it("should return the same array when it's already sorted", function () {
     expect((0, _mergeSort.mergeSort)([1, 2, 3])).toEqual([1, 2, 3]);
   });
-  it("逆順にソートされた配列を渡した場合、正しくソートされた配列を返す", function () {
+  it("should correctly sort a reverse-sorted array", function () {
     expect((0, _mergeSort.mergeSort)([3, 2, 1])).toEqual([1, 2, 3]);
   });
-  it("ランダムな順序の配列を渡した場合、正しくソートされた配列を返す", function () {
+  it("should correctly sort a randomly ordered array", function () {
     expect((0, _mergeSort.mergeSort)([2, 3, 1])).toEqual([1, 2, 3]);
   });
-  it("重複した要素を含む配列を渡した場合、正しくソートされた配列を返す", function () {
+  it("should correctly sort an array with duplicate elements", function () {
     expect((0, _mergeSort.mergeSort)([2, 3, 3, 1, 2])).toEqual([1, 2, 2, 3, 3]);
   });
+  it("should handle a single-element array", function () {
+    expect((0, _mergeSort.mergeSort)([1])).toEqual([1]);
+  });
+  it("should correctly sort an array with negative numbers", function () {
+    expect((0, _mergeSort.mergeSort)([3, -1, 4, -5, 2, -3])).toEqual([-5, -3, -1, 2, 3, 4]);
+  });
+  it("should sort strings alphabetically", function () {
+    expect((0, _mergeSort.mergeSort)(["banana", "apple", "cherry"])).toEqual(["apple", "banana", "cherry"]);
+  });
+  it("should sort using custom comparison function", function () {
+    // Sort in descending order
+    var descendingCompare = function descendingCompare(a, b) {
+      return b - a;
+    };
+    expect((0, _mergeSort.mergeSort)([1, 3, 2], descendingCompare)).toEqual([3, 2, 1]);
+
+    // Sort strings by length
+    var lengthCompare = function lengthCompare(a, b) {
+      return a.length - b.length;
+    };
+    expect((0, _mergeSort.mergeSort)(["aaa", "a", "aa"], lengthCompare)).toEqual(["a", "aa", "aaa"]);
+  });
+  it("should handle arrays with mixed types when using appropriate compare function", function () {
+    var array = ["10", "2", "1"];
+    var numericCompare = function numericCompare(a, b) {
+      return Number(a) - Number(b);
+    };
+    expect((0, _mergeSort.mergeSort)(array, numericCompare)).toEqual(["1", "2", "10"]);
+  });
 });

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

@@ -2,22 +2,22 @@
 
 var _quickSort = require("@/Array/quickSort");
 describe("quickSort", function () {
-  it("空の配列をソートすると空の配列が返される", function () {
+  it("should return an empty array when sorting an empty array", function () {
     expect((0, _quickSort.quickSort)([])).toEqual([]);
   });
-  it("既にソートされた配列はそのまま返される", function () {
+  it("should return the same array when it's already sorted", function () {
     expect((0, _quickSort.quickSort)([1, 2, 3, 4, 5])).toEqual([1, 2, 3, 4, 5]);
   });
-  it("逆順にソートされた配列を正しくソートする", function () {
+  it("should correctly sort a reverse-sorted array", function () {
     expect((0, _quickSort.quickSort)([5, 4, 3, 2, 1])).toEqual([1, 2, 3, 4, 5]);
   });
-  it("ランダムな配列を正しくソートする", function () {
+  it("should correctly sort a random array", 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 () {
+  it("should correctly sort an array with duplicate elements", 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 () {
+  it("should correctly sort an array with large number of elements", function () {
     var largeArray = Array.from({
       length: 10000
     }, function () {
@@ -28,21 +28,21 @@ describe("quickSort", function () {
     });
     expect((0, _quickSort.quickSort)(largeArray)).toEqual(sortedArray);
   });
-  it("負の数を含む配列を正しくソートする", function () {
+  it("should correctly sort an array with negative numbers", 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 () {
+  it("should sort array in descending order", function () {
     expect((0, _quickSort.quickSort)([1, 2, 3, 4, 5], function (a, b) {
       return b - a;
     })).toEqual([5, 4, 3, 2, 1]);
   });
-  it("部分配列をソートする", function () {
+  it("should sort a portion of the array", function () {
     expect((0, _quickSort.quickSort)([3, 1, 4, 1, 5], undefined, 1, 3)).toEqual([3, 1, 1, 4, 5]);
   });
-  it("単一要素の配列が変更されずに返される", function () {
+  it("should return single-element array unchanged", function () {
     expect((0, _quickSort.quickSort)([1])).toEqual([1]);
   });
-  it("compareFunctionが例外を投げる場合", function () {
+  it("should handle compareFunction throwing an error", function () {
     var throwCompare = function throwCompare() {
       throw new Error("Error during comparison");
     };
@@ -50,4 +50,69 @@ describe("quickSort", function () {
       return (0, _quickSort.quickSort)([3, 1, 4], throwCompare);
     }).toThrow("Error during comparison");
   });
+  describe("median of three cases", function () {
+    it("should handle all elements equal", function () {
+      expect((0, _quickSort.quickSort)([5, 5, 5, 5, 5])).toEqual([5, 5, 5, 5, 5]);
+    });
+    it("should handle three-element arrays in all orders", function () {
+      expect((0, _quickSort.quickSort)([1, 2, 3])).toEqual([1, 2, 3]); // a < b < c
+      expect((0, _quickSort.quickSort)([1, 3, 2])).toEqual([1, 2, 3]); // a < c < b
+      expect((0, _quickSort.quickSort)([2, 1, 3])).toEqual([1, 2, 3]); // b < a < c
+      expect((0, _quickSort.quickSort)([2, 3, 1])).toEqual([1, 2, 3]); // b < c < a
+      expect((0, _quickSort.quickSort)([3, 1, 2])).toEqual([1, 2, 3]); // c < a < b
+      expect((0, _quickSort.quickSort)([3, 2, 1])).toEqual([1, 2, 3]); // c < b < a
+    });
+  });
+  describe("insertion sort threshold cases", function () {
+    it("should handle arrays at threshold size", function () {
+      var arr = Array.from({
+        length: 10
+      }, function (_, i) {
+        return 10 - i;
+      });
+      expect((0, _quickSort.quickSort)(arr)).toEqual([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
+    });
+    it("should handle arrays below threshold size", function () {
+      var arr = Array.from({
+        length: 5
+      }, function (_, i) {
+        return 5 - i;
+      });
+      expect((0, _quickSort.quickSort)(arr)).toEqual([1, 2, 3, 4, 5]);
+    });
+    it("should handle custom threshold", function () {
+      var arr = Array.from({
+        length: 20
+      }, function (_, i) {
+        return 20 - i;
+      });
+      expect((0, _quickSort.quickSort)(arr, undefined, 0, arr.length - 1, 5)).toEqual(Array.from({
+        length: 20
+      }, function (_, i) {
+        return i + 1;
+      }));
+    });
+  });
+  describe("boundary conditions", function () {
+    it("should handle invalid index ranges", function () {
+      // Out of bounds indices should be clamped to valid range
+      expect((0, _quickSort.quickSort)([3, 1, 4, 1, 5], undefined, -1, 10)).toEqual([1, 1, 3, 4, 5]);
+      expect((0, _quickSort.quickSort)([3, 1, 4, 1, 5], undefined, 10, -1)).toEqual([3, 1, 4, 1, 5]);
+
+      // When startIndex > endIndex, array should remain unchanged
+      var arr = [3, 1, 4, 1, 5];
+      expect((0, _quickSort.quickSort)([].concat(arr), undefined, 3, 1)).toEqual(arr);
+
+      // Sorting empty range should not change array
+      expect((0, _quickSort.quickSort)([].concat(arr), undefined, 2, 2)).toEqual(arr);
+    });
+    it("should handle two-element arrays", function () {
+      expect((0, _quickSort.quickSort)([2, 1])).toEqual([1, 2]);
+      expect((0, _quickSort.quickSort)([1, 2])).toEqual([1, 2]);
+    });
+    it("should handle arrays with all same value except one", function () {
+      expect((0, _quickSort.quickSort)([1, 1, 1, 0, 1])).toEqual([0, 1, 1, 1, 1]);
+      expect((0, _quickSort.quickSort)([1, 1, 1, 2, 1])).toEqual([1, 1, 1, 1, 2]);
+    });
+  });
 });