umt 2.1.2 → 2.2.1

package/module/es5/tests/unit/Math/radToDeg.test.js

@@ -2,48 +2,49 @@
 
 var _radToDeg = require("@/Math/radToDeg");
 describe("radToDeg", function () {
-  // 正常ケース
-  test("radToDeg: Normal Cases", function () {
-    expect((0, _radToDeg.radToDeg)(0)).toBe(0);
-    expect((0, _radToDeg.radToDeg)(Math.PI / 2)).toBe(90);
-    expect((0, _radToDeg.radToDeg)(Math.PI)).toBe(180);
-    expect((0, _radToDeg.radToDeg)(3 * Math.PI / 2)).toBe(270);
-    expect((0, _radToDeg.radToDeg)(2 * Math.PI)).toBe(360);
+  describe("basic conversions", function () {
+    it("should convert common angles correctly", function () {
+      expect((0, _radToDeg.radToDeg)(0)).toBe(0);
+      expect((0, _radToDeg.radToDeg)(Math.PI / 2)).toBe(90);
+      expect((0, _radToDeg.radToDeg)(Math.PI)).toBe(180);
+      expect((0, _radToDeg.radToDeg)(3 * Math.PI / 2)).toBe(270);
+      expect((0, _radToDeg.radToDeg)(2 * Math.PI)).toBe(360);
+    });
   });
-
-  // 負の角度
-  test("radToDeg: Negative Angles", function () {
-    expect((0, _radToDeg.radToDeg)(-Math.PI / 2)).toBe(-90);
-    expect((0, _radToDeg.radToDeg)(-Math.PI)).toBe(-180);
-    expect((0, _radToDeg.radToDeg)(-3 * Math.PI / 2)).toBe(-270);
-    expect((0, _radToDeg.radToDeg)(-2 * Math.PI)).toBe(-360);
+  describe("negative angles", function () {
+    it("should handle negative angles correctly", function () {
+      expect((0, _radToDeg.radToDeg)(-Math.PI / 2)).toBe(-90);
+      expect((0, _radToDeg.radToDeg)(-Math.PI)).toBe(-180);
+      expect((0, _radToDeg.radToDeg)(-3 * Math.PI / 2)).toBe(-270);
+      expect((0, _radToDeg.radToDeg)(-2 * Math.PI)).toBe(-360);
+    });
   });
-
-  // 浮動小数点数の角度
-  test("radToDeg: Floating Point Angles", function () {
-    expect((0, _radToDeg.radToDeg)(Math.PI / 4)).toBeCloseTo(45);
-    expect((0, _radToDeg.radToDeg)(Math.PI * 60.7 / 180)).toBeCloseTo(60.7);
-    expect((0, _radToDeg.radToDeg)(Math.PI * 120.2 / 180)).toBeCloseTo(120.2);
+  describe("floating point angles", function () {
+    it("should handle floating point angles correctly", function () {
+      expect((0, _radToDeg.radToDeg)(Math.PI / 4)).toBeCloseTo(45);
+      expect((0, _radToDeg.radToDeg)(Math.PI * 60.7 / 180)).toBeCloseTo(60.7);
+      expect((0, _radToDeg.radToDeg)(Math.PI * 120.2 / 180)).toBeCloseTo(120.2);
+    });
   });
-
-  // 2π以上の角度
-  test("radToDeg: Angles Greater Than 2π", function () {
-    expect((0, _radToDeg.radToDeg)(5 * Math.PI / 2)).toBeCloseTo(450);
-    expect((0, _radToDeg.radToDeg)(4 * Math.PI)).toBeCloseTo(720);
-    expect((0, _radToDeg.radToDeg)(6 * Math.PI)).toBeCloseTo(1080);
+  describe("angles greater than 2π", function () {
+    it("should handle angles greater than 2π correctly", function () {
+      expect((0, _radToDeg.radToDeg)(5 * Math.PI / 2)).toBeCloseTo(450);
+      expect((0, _radToDeg.radToDeg)(4 * Math.PI)).toBeCloseTo(720);
+      expect((0, _radToDeg.radToDeg)(6 * Math.PI)).toBeCloseTo(1080);
+    });
   });
-
-  // NaNとInfinity
-  test("radToDeg: NaN and Infinity", function () {
-    expect((0, _radToDeg.radToDeg)(NaN)).toBe(NaN);
-    expect((0, _radToDeg.radToDeg)(Infinity)).toBe(Infinity);
-    expect((0, _radToDeg.radToDeg)(-Infinity)).toBe(-Infinity);
+  describe("special values", function () {
+    it("should handle NaN and Infinity correctly", function () {
+      expect((0, _radToDeg.radToDeg)(Number.NaN)).toBe(Number.NaN);
+      expect((0, _radToDeg.radToDeg)(Number.POSITIVE_INFINITY)).toBe(Number.POSITIVE_INFINITY);
+      expect((0, _radToDeg.radToDeg)(Number.NEGATIVE_INFINITY)).toBe(Number.NEGATIVE_INFINITY);
+    });
   });
-
-  // 無効な入力
-  test("radToDeg: Invalid Inputs", function () {
-    expect((0, _radToDeg.radToDeg)("1.57")).toBeCloseTo(89.95);
-    expect((0, _radToDeg.radToDeg)([1.57])).toBeCloseTo(89.95);
-    expect((0, _radToDeg.radToDeg)({})).toBe(NaN);
+  describe("invalid inputs", function () {
+    it("should handle invalid inputs appropriately", function () {
+      expect((0, _radToDeg.radToDeg)("1.57")).toBeCloseTo(89.95);
+      expect((0, _radToDeg.radToDeg)([1.57])).toBeCloseTo(89.95);
+      expect((0, _radToDeg.radToDeg)({})).toBe(Number.NaN);
+    });
   });
 });

package/module/es5/tests/unit/Math/random.test.js

@@ -1,23 +1,61 @@
 "use strict";
 
 var _random = require("@/Math/random");
-describe("random関数のテスト", function () {
-  it("指定された範囲内の乱数を生成する", function () {
-    var min = 1;
-    var max = 10;
-    var result = (0, _random.random)(max, min);
-    expect(result).toBeGreaterThanOrEqual(min);
-    expect(result).toBeLessThanOrEqual(max);
+describe("random function", function () {
+  describe("basic random generation", function () {
+    it("should generate random numbers within specified range", function () {
+      var min = 1;
+      var max = 10;
+      for (var i = 0; i < 100; i++) {
+        var result = (0, _random.random)(max, min);
+        expect(result).toBeGreaterThanOrEqual(min);
+        expect(result).toBeLessThanOrEqual(max);
+        expect(Number.isInteger(result)).toBe(true);
+      }
+    });
+    it("should use 0 as default minimum value", function () {
+      var max = 5;
+      for (var i = 0; i < 100; i++) {
+        var result = (0, _random.random)(max);
+        expect(result).toBeGreaterThanOrEqual(0);
+        expect(result).toBeLessThanOrEqual(max);
+        expect(Number.isInteger(result)).toBe(true);
+      }
+    });
   });
-  it("最小値を指定しない場合は0を含む乱数を生成する", function () {
-    var max = 5;
-    var result = (0, _random.random)(max);
-    expect(result).toBeGreaterThanOrEqual(0);
-    expect(result).toBeLessThanOrEqual(max);
-  });
-  it("最大値と最小値が同じ場合はその値を返す", function () {
-    var value = 7;
-    var result = (0, _random.random)(value, value);
-    expect(result).toBe(value);
+  describe("edge cases", function () {
+    it("should return same value when max equals min", function () {
+      var value = 7;
+      var result = (0, _random.random)(value, value);
+      expect(result).toBe(value);
+    });
+    it("should handle negative numbers", function () {
+      var min = -10;
+      var max = -5;
+      for (var i = 0; i < 100; i++) {
+        var result = (0, _random.random)(max, min);
+        expect(result).toBeGreaterThanOrEqual(min);
+        expect(result).toBeLessThanOrEqual(max);
+        expect(Number.isInteger(result)).toBe(true);
+      }
+    });
+    it("should handle mixed positive and negative range", function () {
+      var min = -5;
+      var max = 5;
+      for (var i = 0; i < 100; i++) {
+        var result = (0, _random.random)(max, min);
+        expect(result).toBeGreaterThanOrEqual(min);
+        expect(result).toBeLessThanOrEqual(max);
+        expect(Number.isInteger(result)).toBe(true);
+      }
+    });
+    it("should handle when min is greater than max", function () {
+      var min = 10;
+      var max = 5;
+      var result = (0, _random.random)(max, min);
+      expect(result).toBeGreaterThanOrEqual(max);
+      expect(result).toBeLessThanOrEqual(min);
+      expect(Number.isInteger(result)).toBe(true);
+    });
   });
 });

package/module/es5/tests/unit/Math/reduce.test.js

@@ -1,14 +1,93 @@
 "use strict";
 
 var _reduce = require("@/Math/reduce");
-test("{reduce}", function () {
-  expect((0, _reduce.reduce)(16, 2)).toMatchObject({
-    x: 8,
-    y: 1,
-    gcd: 2
+describe("reduce function", function () {
+  describe("basic fraction reduction", function () {
+    it("should reduce simple fractions", function () {
+      expect((0, _reduce.reduce)(2, 4)).toEqual({
+        x: 1,
+        y: 2,
+        gcd: 2
+      });
+      expect((0, _reduce.reduce)(3, 6)).toEqual({
+        x: 1,
+        y: 2,
+        gcd: 3
+      });
+      expect((0, _reduce.reduce)(8, 12)).toEqual({
+        x: 2,
+        y: 3,
+        gcd: 4
+      });
+    });
+    it("should handle already reduced fractions", function () {
+      expect((0, _reduce.reduce)(3, 4)).toEqual({
+        x: 3,
+        y: 4,
+        gcd: 1
+      });
+      expect((0, _reduce.reduce)(7, 9)).toEqual({
+        x: 7,
+        y: 9,
+        gcd: 1
+      });
+    });
+    it("should handle fractions with 1", function () {
+      expect((0, _reduce.reduce)(5, 1)).toEqual({
+        x: 5,
+        y: 1,
+        gcd: 1
+      });
+      expect((0, _reduce.reduce)(1, 7)).toEqual({
+        x: 1,
+        y: 7,
+        gcd: 1
+      });
+    });
   });
-  expect((0, _reduce.reduce)(0, 2)).toMatchObject({
-    x: NaN,
-    y: NaN
+  describe("edge cases", function () {
+    it("should handle zero in numerator or denominator", function () {
+      expect((0, _reduce.reduce)(0, 5)).toEqual({
+        x: Number.NaN,
+        y: Number.NaN
+      });
+      expect((0, _reduce.reduce)(5, 0)).toEqual({
+        x: Number.NaN,
+        y: Number.NaN
+      });
+      expect((0, _reduce.reduce)(0, 0)).toEqual({
+        x: Number.NaN,
+        y: Number.NaN
+      });
+    });
+    it("should handle negative numbers", function () {
+      expect((0, _reduce.reduce)(-6, 8)).toEqual({
+        x: -3,
+        y: 4,
+        gcd: 2
+      });
+      expect((0, _reduce.reduce)(6, -8)).toEqual({
+        x: -3,
+        y: 4,
+        gcd: 2
+      });
+      expect((0, _reduce.reduce)(-6, -8)).toEqual({
+        x: 3,
+        y: 4,
+        gcd: 2
+      });
+    });
+    it("should handle larger numbers", function () {
+      expect((0, _reduce.reduce)(1000, 2500)).toEqual({
+        x: 2,
+        y: 5,
+        gcd: 500
+      });
+      expect((0, _reduce.reduce)(24680, 12340)).toEqual({
+        x: 2,
+        y: 1,
+        gcd: 12340
+      });
+    });
   });
 });

package/module/es5/tests/unit/Math/repeatedTrial.test.js

@@ -1,9 +1,39 @@
 "use strict";
 
 var _repeatedTrial = require("@/Math/repeatedTrial");
-test("{repeatedTrial}", function () {
-  expect((0, _repeatedTrial.repeatedTrial)(4, 2, {
-    x: 1,
-    y: 3
-  })).toEqual([8, 27]);
+describe("repeatedTrial", function () {
+  it("should calculate basic probability cases", function () {
+    expect((0, _repeatedTrial.repeatedTrial)(4, 2, {
+      x: 1,
+      y: 3
+    })).toEqual([8, 27]);
+    expect((0, _repeatedTrial.repeatedTrial)(5, 2, {
+      x: 1,
+      y: 2
+    })).toEqual([5, 16]);
+    expect((0, _repeatedTrial.repeatedTrial)(3, 2, {
+      x: 1,
+      y: 2
+    })).toEqual([3, 8]);
+  });
+  it("should handle extreme probability cases", function () {
+    expect((0, _repeatedTrial.repeatedTrial)(3, 3, {
+      x: 2,
+      y: 3
+    })).toEqual([8, 27]);
+    expect((0, _repeatedTrial.repeatedTrial)(4, 4, {
+      x: 1,
+      y: 2
+    })).toEqual([1, 16]);
+  });
+  it("should handle probability with simple fractions", function () {
+    expect((0, _repeatedTrial.repeatedTrial)(2, 1, {
+      x: 1,
+      y: 2
+    })).toEqual([1, 2]);
+    expect((0, _repeatedTrial.repeatedTrial)(3, 2, {
+      x: 1,
+      y: 3
+    })).toEqual([2, 9]);
+  });
 });

package/module/es5/tests/unit/Math/roundOf.test.js

@@ -1,15 +1,40 @@
 "use strict";
 
 var _roundOf = require("@/Math/roundOf");
-test("{roundOf", function () {
-  expect((0, _roundOf.roundOf)(1.111111111111)).toBe(1);
-  expect((0, _roundOf.roundOf)(1.111111111111, 1)).toBe(1.1);
-  expect((0, _roundOf.roundOf)(1.111111111111, 2)).toBe(1.11);
-  expect((0, _roundOf.roundOf)(1.111111111111, 3)).toBe(1.111);
-  expect((0, _roundOf.roundOf)(1.111111111111, 4)).toBe(1.1111);
-  expect((0, _roundOf.roundOf)(1.111111111111, 5)).toBe(1.11111);
-  expect((0, _roundOf.roundOf)(1.111111111111, 6)).toBe(1.111111);
-  expect((0, _roundOf.roundOf)(1.111111111111, 7)).toBe(1.1111111);
-  expect((0, _roundOf.roundOf)(1.111111111111, 8)).toBe(1.11111111);
-  expect((0, _roundOf.roundOf)(1.555555555555, 2)).toBe(1.56);
+describe("roundOf function", function () {
+  describe("basic rounding", function () {
+    it("should round to default precision (0)", function () {
+      expect((0, _roundOf.roundOf)(1.111111111111)).toBe(1);
+      expect((0, _roundOf.roundOf)(1.555555555555)).toBe(2);
+      expect((0, _roundOf.roundOf)(1.499999999999)).toBe(1);
+    });
+    it("should round to specified decimal places", function () {
+      expect((0, _roundOf.roundOf)(1.111111111111, 2)).toBe(1.11);
+      expect((0, _roundOf.roundOf)(1.555555555555, 2)).toBe(1.56);
+      expect((0, _roundOf.roundOf)(1.499999999999, 2)).toBe(1.5);
+    });
+    it("should handle increasing precision", function () {
+      var value = 1.111111111111;
+      expect((0, _roundOf.roundOf)(value, 1)).toBe(1.1);
+      expect((0, _roundOf.roundOf)(value, 2)).toBe(1.11);
+      expect((0, _roundOf.roundOf)(value, 3)).toBe(1.111);
+      expect((0, _roundOf.roundOf)(value, 4)).toBe(1.1111);
+      expect((0, _roundOf.roundOf)(value, 5)).toBe(1.11111);
+    });
+  });
+  describe("edge cases", function () {
+    it("should handle negative numbers", function () {
+      expect((0, _roundOf.roundOf)(-1.234, 2)).toBe(-1.23);
+      expect((0, _roundOf.roundOf)(-1.235, 2)).toBe(-1.24);
+    });
+    it("should handle zero with different precisions", function () {
+      expect((0, _roundOf.roundOf)(0, 0)).toBe(0);
+      expect((0, _roundOf.roundOf)(0, 2)).toBe(0);
+      expect((0, _roundOf.roundOf)(0.0, 4)).toBe(0);
+    });
+    it("should handle negative precision", function () {
+      expect((0, _roundOf.roundOf)(1234.5678, -1)).toBe(1230);
+      expect((0, _roundOf.roundOf)(1234.5678, -2)).toBe(1200);
+    });
+  });
 });

package/module/es5/tests/unit/Math/solveEquation.test.js

@@ -1,24 +1,24 @@
 "use strict";
 
 var _solveEquation = require("@/Math/solveEquation");
-test("{solveEquation", function () {
-  expect((0, _solveEquation.solveEquation)(
-  /*
-  x + y = 4
-  x + 2y = 10
-  */
-  [[1, 1], [1, 2]], [4, 10])).toEqual([-2, 6]);
-  expect((0, _solveEquation.solveEquation)(
-  /*
-  x + 6y = 33
-  x + y = 8
-  */
-  [[1, 6], [1, 1]], [33, 8])).toEqual([3, 5]);
-  expect((0, _solveEquation.solveEquation)(
-  /*
-  5x-4y+6z=8
-  7x-6y+10z=14
-  4x+9y+7z=74
-  */
-  [[5, -4, 6], [7, -6, 10], [4, 9, 7]], [8, 14, 74])).toEqual([2, 5, 3]);
+describe("solveEquation function", function () {
+  it("should solve a 2x2 system of linear equations (case 1)", function () {
+    // System:
+    // x + y = 4
+    // x + 2y = 10
+    expect((0, _solveEquation.solveEquation)([[1, 1], [1, 2]], [4, 10])).toEqual([-2, 6]);
+  });
+  it("should solve a 2x2 system of linear equations (case 2)", function () {
+    // System:
+    // x + 6y = 33
+    // x + y = 8
+    expect((0, _solveEquation.solveEquation)([[1, 6], [1, 1]], [33, 8])).toEqual([3, 5]);
+  });
+  it("should solve a 3x3 system of linear equations", function () {
+    // System:
+    // 5x - 4y + 6z = 8
+    // 7x - 6y + 10z = 14
+    // 4x + 9y + 7z = 74
+    expect((0, _solveEquation.solveEquation)([[5, -4, 6], [7, -6, 10], [4, 9, 7]], [8, 14, 74])).toEqual([2, 5, 3]);
+  });
 });

package/module/es5/tests/unit/Math/standardDeviation.test.js

@@ -1,6 +1,23 @@
 "use strict";
 
 var _standardDeviation = require("@/Math/standardDeviation");
-test("{standardDeviation}", function () {
-  expect((0, _standardDeviation.standardDeviation)([1, 2, 3, 4, 5])).toBe(1.4142135623730951);
+describe("standardDeviation function", function () {
+  it("should calculate standard deviation of sequential integers", function () {
+    expect((0, _standardDeviation.standardDeviation)([1, 2, 3, 4, 5])).toBe(1.4142135623730951);
+    expect((0, _standardDeviation.standardDeviation)([1, 2, 3])).toBe(0.816496580927726);
+  });
+  it("should calculate standard deviation of non-sequential values", function () {
+    expect((0, _standardDeviation.standardDeviation)([10, 12, 23, 23, 16, 23, 21, 16])).toBe(4.898979485566356);
+    expect((0, _standardDeviation.standardDeviation)([5, 10, 15, 20, 25])).toBe(7.0710678118654755);
+  });
+  it("should handle edge cases", function () {
+    // All same values should have standard deviation of 0
+    expect((0, _standardDeviation.standardDeviation)([5, 5, 5, 5])).toBe(0);
+
+    // Single value should have standard deviation of 0
+    expect((0, _standardDeviation.standardDeviation)([42])).toBe(0);
+
+    // Empty array should return 0 (as average function returns 0 for empty arrays)
+    expect((0, _standardDeviation.standardDeviation)([])).toBe(0);
+  });
 });

package/module/es5/tests/unit/Math/subtract.test.js

@@ -7,7 +7,7 @@ function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r)
 function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
 function _arrayWithoutHoles(r) { if (Array.isArray(r)) return _arrayLikeToArray(r); }
 function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
-describe("subtract関数のテスト", function () {
+describe("subtract function", function () {
   test.each([{
     a: [1, 1],
     expected: 0
@@ -26,9 +26,21 @@ describe("subtract関数のテスト", function () {
   }, {
     a: [10, 1, 1, 1],
     expected: 7
-  }])("$a の引き算の結果が $expected", function (_ref) {
+  }])("subtracting $a should result in $expected", function (_ref) {
     var a = _ref.a,
       expected = _ref.expected;
     expect(_subtract.subtract.apply(void 0, _toConsumableArray(a))).toBe(expected);
   });
+  describe("floating point precision", function () {
+    it("should handle floating point precision correctly", function () {
+      // These operations would normally have floating point errors
+      expect((0, _subtract.subtract)(0.3, 0.1)).toBe(0.2);
+      expect((0, _subtract.subtract)(0.7, 0.1)).toBe(0.6);
+      expect((0, _subtract.subtract)(1.0, 0.9)).toBe(0.1);
+    });
+    it("should handle multiple decimal places", function () {
+      expect((0, _subtract.subtract)(0.12345, 0.00001)).toBe(0.12344);
+      expect((0, _subtract.subtract)(1.23456, 0.00001, 0.00002)).toBe(1.23453);
+    });
+  });
 });

package/module/es5/tests/unit/Math/toBaseN.test.js

@@ -1,23 +1,40 @@
 "use strict";
 
 var _toBaseN = require("@/Math/toBaseN");
-test("{toBaseN}", function () {
-  //2進数
-  expect((0, _toBaseN.toBaseN)(1)).toBe("1");
-  expect((0, _toBaseN.toBaseN)(2)).toBe("10");
-  expect((0, _toBaseN.toBaseN)(3)).toBe("11");
-  expect((0, _toBaseN.toBaseN)(4)).toBe("100");
-  expect((0, _toBaseN.toBaseN)(5)).toBe("101");
-  expect((0, _toBaseN.toBaseN)(6)).toBe("110");
-  expect((0, _toBaseN.toBaseN)(112)).toBe("1110000");
-  //4進数
-  expect((0, _toBaseN.toBaseN)(7, 4)).toBe("13");
-  expect((0, _toBaseN.toBaseN)(8, 4)).toBe("20");
-  expect((0, _toBaseN.toBaseN)(9, 4)).toBe("21");
-  expect((0, _toBaseN.toBaseN)(112, 4)).toBe("1300");
-  //8進数
-  expect((0, _toBaseN.toBaseN)(7, 8)).toBe("7");
-  expect((0, _toBaseN.toBaseN)(8, 8)).toBe("10");
-  expect((0, _toBaseN.toBaseN)(9, 8)).toBe("11");
-  expect((0, _toBaseN.toBaseN)(112, 8)).toBe("160");
+describe("toBaseN function", function () {
+  describe("binary (base 2)", function () {
+    it("should convert decimal numbers to binary strings", function () {
+      expect((0, _toBaseN.toBaseN)(1)).toBe("1");
+      expect((0, _toBaseN.toBaseN)(2)).toBe("10");
+      expect((0, _toBaseN.toBaseN)(3)).toBe("11");
+      expect((0, _toBaseN.toBaseN)(4)).toBe("100");
+      expect((0, _toBaseN.toBaseN)(5)).toBe("101");
+      expect((0, _toBaseN.toBaseN)(6)).toBe("110");
+      expect((0, _toBaseN.toBaseN)(112)).toBe("1110000");
+    });
+  });
+  describe("base 4", function () {
+    it("should convert decimal numbers to base 4 strings", function () {
+      expect((0, _toBaseN.toBaseN)(7, 4)).toBe("13");
+      expect((0, _toBaseN.toBaseN)(8, 4)).toBe("20");
+      expect((0, _toBaseN.toBaseN)(9, 4)).toBe("21");
+      expect((0, _toBaseN.toBaseN)(112, 4)).toBe("1300");
+    });
+  });
+  describe("octal (base 8)", function () {
+    it("should convert decimal numbers to octal strings", function () {
+      expect((0, _toBaseN.toBaseN)(7, 8)).toBe("7");
+      expect((0, _toBaseN.toBaseN)(8, 8)).toBe("10");
+      expect((0, _toBaseN.toBaseN)(9, 8)).toBe("11");
+      expect((0, _toBaseN.toBaseN)(112, 8)).toBe("160");
+    });
+  });
+  describe("hexadecimal (base 16)", function () {
+    it("should convert decimal numbers to hexadecimal strings", function () {
+      expect((0, _toBaseN.toBaseN)(10, 16)).toBe("a");
+      expect((0, _toBaseN.toBaseN)(15, 16)).toBe("f");
+      expect((0, _toBaseN.toBaseN)(16, 16)).toBe("10");
+      expect((0, _toBaseN.toBaseN)(255, 16)).toBe("ff");
+    });
+  });
 });

package/module/es5/tests/unit/Math/toCelsius.test.js

@@ -1,6 +1,18 @@
 "use strict";
 
 var _toCelsius = require("@/Math/toCelsius");
-test("{toCelsius}", function () {
-  expect((0, _toCelsius.toCelsius)(32)).toBe(-241.15);
+describe("toCelsius function", function () {
+  it("should convert Kelvin to Celsius", function () {
+    expect((0, _toCelsius.toCelsius)(273.15)).toBe(0);
+    expect((0, _toCelsius.toCelsius)(300)).toBe(26.85);
+    expect((0, _toCelsius.toCelsius)(373.15)).toBe(100);
+    expect((0, _toCelsius.toCelsius)(0)).toBe(-273.15);
+  });
+  it("should handle non-standard temperatures", function () {
+    expect((0, _toCelsius.toCelsius)(32)).toBe(-241.15);
+    expect((0, _toCelsius.toCelsius)(1000)).toBe(726.85);
+  });
+  it("should handle negative Kelvin values (though physically impossible)", function () {
+    expect((0, _toCelsius.toCelsius)(-100)).toBe(-373.15);
+  });
 });

package/module/es5/tests/unit/Math/toKelvin.test.js

@@ -1,6 +1,18 @@
 "use strict";
 
 var _toKelvin = require("@/Math/toKelvin");
-test("{toKelvin}", function () {
-  expect((0, _toKelvin.toKelvin)(0)).toBe(273.15);
+describe("toKelvin function", function () {
+  it("should convert Celsius to Kelvin", function () {
+    expect((0, _toKelvin.toKelvin)(0)).toBe(273.15);
+    expect((0, _toKelvin.toKelvin)(26.85)).toBe(300);
+    expect((0, _toKelvin.toKelvin)(100)).toBe(373.15);
+  });
+  it("should handle negative Celsius values", function () {
+    expect((0, _toKelvin.toKelvin)(-40)).toBe(233.15);
+    expect((0, _toKelvin.toKelvin)(-273.15)).toBe(0);
+  });
+  it("should handle extreme temperatures", function () {
+    expect((0, _toKelvin.toKelvin)(1000)).toBe(1273.15);
+    expect((0, _toKelvin.toKelvin)(-300)).toBe(-26.85); // Below absolute zero (physically impossible)
+  });
 });

package/module/es5/tests/unit/Math/uuidv7.test.js

@@ -1,28 +1,28 @@
 "use strict";
 
 var _uuidv = require("@/Math/uuidv7");
-describe("uuidv7", function () {
-  it("生成されたUUID v7が正しい形式である", function () {
+describe("uuidv7 function", function () {
+  it("should generate UUID v7 with correct format", function () {
     var uuid = (0, _uuidv.uuidv7)();
     var uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
     expect(uuid).toMatch(uuidRegex);
   });
-  it("生成されたUUID v7が一意である", function () {
+  it("should generate unique UUIDs", function () {
     var uuid1 = (0, _uuidv.uuidv7)();
     var uuid2 = (0, _uuidv.uuidv7)();
     expect(uuid1).not.toBe(uuid2);
   });
-  it("生成されたUUID v7のバージョンが7である", function () {
+  it("should have version 7", function () {
     var uuid = (0, _uuidv.uuidv7)();
     var version = uuid.split("-")[2][0];
     expect(version).toBe("7");
   });
-  it("生成されたUUID v7のバリアントが正しい形式である", function () {
+  it("should have correct variant", function () {
     var uuid = (0, _uuidv.uuidv7)();
     var variant = uuid.split("-")[3][0];
     expect(["8", "9", "a", "b"]).toContain(variant);
   });
-  it("衝突しないUUID v7が生成される", function () {
+  it("should generate non-colliding UUIDs", function () {
     var uuids = new Set();
     for (var index = 0; index < 1000; index++) {
       var uuid = (0, _uuidv.uuidv7)();

package/module/es5/tests/unit/Math/valueSwap.test.js

@@ -1,10 +1,28 @@
 "use strict";
 
 var _valueSwap = require("@/Math/valueSwap");
-test("{valueSwap}", function () {
-  expect((0, _valueSwap.valueSwap)(1, 2)).toEqual([1, 2]);
-  expect((0, _valueSwap.valueSwap)(2, 1)).toEqual([1, 2]);
-  expect((0, _valueSwap.valueSwap)(1, 1)).toEqual([1, 1]);
-  expect((0, _valueSwap.valueSwap)(2, 2)).toEqual([2, 2]);
-  expect((0, _valueSwap.valueSwap)(3, 3)).toEqual([3, 3]);
+describe("valueSwap function", function () {
+  it("should keep order when x < y", function () {
+    expect((0, _valueSwap.valueSwap)(1, 2)).toEqual([1, 2]);
+    expect((0, _valueSwap.valueSwap)(-2, -1)).toEqual([-2, -1]);
+    expect((0, _valueSwap.valueSwap)(0.1, 0.2)).toEqual([0.1, 0.2]);
+  });
+  it("should swap order when x > y", function () {
+    expect((0, _valueSwap.valueSwap)(2, 1)).toEqual([1, 2]);
+    expect((0, _valueSwap.valueSwap)(-1, -2)).toEqual([-2, -1]);
+    expect((0, _valueSwap.valueSwap)(0.2, 0.1)).toEqual([0.1, 0.2]);
+  });
+  it("should handle equal numbers", function () {
+    expect((0, _valueSwap.valueSwap)(1, 1)).toEqual([1, 1]);
+    expect((0, _valueSwap.valueSwap)(0, 0)).toEqual([0, 0]);
+    expect((0, _valueSwap.valueSwap)(-1, -1)).toEqual([-1, -1]);
+  });
+  it("should handle decimal numbers", function () {
+    expect((0, _valueSwap.valueSwap)(1.5, 1.2)).toEqual([1.2, 1.5]);
+    expect((0, _valueSwap.valueSwap)(0.5, 1.5)).toEqual([0.5, 1.5]);
+  });
+  it("should handle negative numbers", function () {
+    expect((0, _valueSwap.valueSwap)(-5, 5)).toEqual([-5, 5]);
+    expect((0, _valueSwap.valueSwap)(5, -5)).toEqual([-5, 5]);
+  });
 });