umt 2.1.1 → 2.2.0

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

@@ -2,33 +2,80 @@
 
 var _division = require("@/Math/division");
 describe("division function", function () {
-  // 整数に対するテスト
-  it("should return the correct division for integers", function () {
-    expect((0, _division.division)(10, 2)).toBe(5);
-    expect((0, _division.division)(30, 5)).toBe(6);
+  describe("basic integer division", function () {
+    it("should correctly divide integers", function () {
+      expect((0, _division.division)(10, 2)).toBe(5);
+      expect((0, _division.division)(30, 5)).toBe(6);
+    });
+    it("should handle large number divided by small number", function () {
+      expect((0, _division.division)(1000, 10)).toBe(100);
+      expect((0, _division.division)(10000, 100)).toBe(100);
+    });
+    it("should handle small number divided by large number", function () {
+      expect((0, _division.division)(10, 100)).toBe(0.1);
+      expect((0, _division.division)(1, 1000)).toBe(0.001);
+    });
   });
-
-  // isFloor=true の場合
-  it("should return floored division if isFloor is true", function () {
-    expect((0, _division.division)(7, 2, true)).toBe(3.5);
-    expect((0, _division.division)(3, 5, true)).toBe(0.6);
+  describe("division with remainder", function () {
+    it("should handle division with remainder when isFloor is true", function () {
+      expect((0, _division.division)(7, 2, true)).toBe(3.5);
+      expect((0, _division.division)(3, 5, true)).toBe(0.6);
+    });
+    it("should return quotient and remainder when isFloor is false", function () {
+      expect((0, _division.division)(10, 3, false)).toEqual([3, 1]);
+      expect((0, _division.division)(7, 2, false)).toEqual([3, 1]);
+      expect((0, _division.division)(3, 5, false)).toEqual([0, 3]);
+    });
+    it("should handle large numbers with remainder", function () {
+      expect((0, _division.division)(1000, 3, false)).toEqual([333, 1]);
+      expect((0, _division.division)(10000, 7, false)).toEqual([1428, 4]);
+    });
   });
-
-  // isFloor=false の場合
-  it("should return division and remainder if isFloor is false", function () {
-    expect((0, _division.division)(10, 3, false)).toEqual([3, 1]);
-    expect((0, _division.division)(7, 2, false)).toEqual([3, 1]);
-    expect((0, _division.division)(3, 5, false)).toEqual([0, 3]);
+  describe("decimal numbers", function () {
+    it("should handle decimal numbers with different lengths", function () {
+      expect((0, _division.division)(10.5, 2.1)).toBe(5);
+      expect((0, _division.division)(0.1, 0.2)).toBe(0.5);
+      expect((0, _division.division)(0.001, 0.1)).toBe(0.01);
+      expect((0, _division.division)(0.1, 0.001)).toBe(100);
+      expect((0, _division.division)(0.0001, 0.01)).toBe(0.01);
+    });
+    it("should handle decimal numbers with same length", function () {
+      expect((0, _division.division)(1.1, 2.2)).toBe(0.5);
+      expect((0, _division.division)(0.01, 0.02)).toBe(0.5);
+    });
+    it("should handle complex decimal combinations", function () {
+      expect((0, _division.division)(1.23456, 2.1)).toBeCloseTo(0.587885714);
+      expect((0, _division.division)(0.0001, 0.0003)).toBeCloseTo(0.333333333);
+      expect((0, _division.division)(123.456, 0.789)).toBeCloseTo(156.4715);
+    });
+    it("should handle decimal numbers with remainder", function () {
+      expect((0, _division.division)(1.5, 0.7, false)).toEqual([2, 1]);
+      expect((0, _division.division)(0.123, 0.0456, false)).toEqual([2, 123]);
+    });
   });
-
-  // 小数に対するテスト
-  it("should handle decimals correctly", function () {
-    expect((0, _division.division)(10.5, 2.1)).toBe(5);
-  });
-
-  // 精度チェック
-  it("should handle precision correctly", function () {
-    expect((0, _division.division)(0.1, 0.2)).toBeCloseTo(0.5);
-    expect((0, _division.division)(-0.16, 0.2)).toBeCloseTo(-0.8);
+  describe("edge cases", function () {
+    it("should return NaN for division by zero", function () {
+      expect((0, _division.division)(1, 0)).toBe(Number.NaN);
+      expect((0, _division.division)(-1, 0)).toBe(Number.NaN);
+      expect((0, _division.division)(-1, 0, false)).toEqual([Number.NaN, Number.NaN]);
+      expect((0, _division.division)(0, 0)).toBe(Number.NaN);
+      expect((0, _division.division)(0, 0, false)).toEqual([Number.NaN, Number.NaN]);
+    });
+    it("should handle zero dividend", function () {
+      expect((0, _division.division)(0, 1)).toBe(0);
+      expect((0, _division.division)(0, -1)).toBe(-0);
+      expect((0, _division.division)(0, 2, false)).toEqual([0, 0]);
+      expect((0, _division.division)(0, -2, false)).toEqual([-0, 0]);
+    });
+    it("should handle negative numbers", function () {
+      expect((0, _division.division)(-10, 2)).toBe(-5);
+      expect((0, _division.division)(10, -2)).toBe(-5);
+      expect((0, _division.division)(-10, -2)).toBe(5);
+    });
+    it("should handle negative decimals", function () {
+      expect((0, _division.division)(-0.16, 0.2)).toBe(-0.8);
+      expect((0, _division.division)(0.16, -0.2)).toBe(-0.8);
+      expect((0, _division.division)(-0.16, -0.2)).toBe(0.8);
+    });
   });
 });

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

@@ -2,13 +2,13 @@
 
 var _factorial = require("@/Math/factorial");
 describe("factorial", function () {
-  test("0の階乗は1を返す", function () {
+  test("should return 1 for factorial of 0", function () {
     expect((0, _factorial.factorial)(0)).toBe(1);
   });
-  test("1の階乗は1を返す", function () {
+  test("should return 1 for factorial of 1", function () {
     expect((0, _factorial.factorial)(1)).toBe(1);
   });
-  test("正の整数の階乗を正しく計算する", function () {
+  test("should correctly calculate factorial of positive integers", function () {
     expect((0, _factorial.factorial)(2)).toBe(2);
     expect((0, _factorial.factorial)(3)).toBe(6);
     expect((0, _factorial.factorial)(4)).toBe(24);
@@ -19,7 +19,7 @@ describe("factorial", function () {
     expect((0, _factorial.factorial)(9)).toBe(362880);
     expect((0, _factorial.factorial)(10)).toBe(3628800);
   });
-  test("負の数を渡すと1を返す", function () {
+  test("should return 1 for negative numbers", function () {
     expect((0, _factorial.factorial)(-1)).toBe(1);
     expect((0, _factorial.factorial)(-5)).toBe(1);
   });

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

@@ -1,13 +1,38 @@
 "use strict";
 
 var _factorize = require("@/Math/factorize");
-test("{factorize}", function () {
-  expect((0, _factorize.factorize)(12)).toEqual([2, 2, 3]);
-  expect((0, _factorize.factorize)(14)).toEqual([2, 7]);
-  expect((0, _factorize.factorize)(15)).toEqual([3, 5]);
-  expect((0, _factorize.factorize)(16)).toEqual([2, 2, 2, 2]);
-  expect((0, _factorize.factorize)(17)).toEqual([17]);
-  expect((0, _factorize.factorize)(18)).toEqual([2, 3, 3]);
-  expect((0, _factorize.factorize)(19)).toEqual([19]);
-  expect((0, _factorize.factorize)(20)).toEqual([2, 2, 5]);
+describe("factorize", function () {
+  describe("basic factorization", function () {
+    test("should correctly factorize composite numbers", function () {
+      expect((0, _factorize.factorize)(12)).toEqual([2, 2, 3]);
+      expect((0, _factorize.factorize)(14)).toEqual([2, 7]);
+      expect((0, _factorize.factorize)(15)).toEqual([3, 5]);
+      expect((0, _factorize.factorize)(18)).toEqual([2, 3, 3]);
+      expect((0, _factorize.factorize)(20)).toEqual([2, 2, 5]);
+    });
+    test("should handle powers of the same prime", function () {
+      expect((0, _factorize.factorize)(16)).toEqual([2, 2, 2, 2]);
+      expect((0, _factorize.factorize)(27)).toEqual([3, 3, 3]);
+      expect((0, _factorize.factorize)(32)).toEqual([2, 2, 2, 2, 2]);
+    });
+    test("should handle prime numbers", function () {
+      expect((0, _factorize.factorize)(17)).toEqual([17]);
+      expect((0, _factorize.factorize)(19)).toEqual([19]);
+      expect((0, _factorize.factorize)(23)).toEqual([23]);
+    });
+  });
+  describe("edge cases", function () {
+    test("should handle negative numbers", function () {
+      expect((0, _factorize.factorize)(-12)).toEqual([2, 2, 3]);
+      expect((0, _factorize.factorize)(-15)).toEqual([3, 5]);
+    });
+    test("should handle zero and one", function () {
+      expect((0, _factorize.factorize)(0)).toEqual([]);
+      expect((0, _factorize.factorize)(1)).toEqual([]);
+    });
+    test("should handle large numbers", function () {
+      expect((0, _factorize.factorize)(997)).toEqual([997]); // Large prime
+      expect((0, _factorize.factorize)(1000)).toEqual([2, 2, 2, 5, 5, 5]);
+    });
+  });
 });

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

@@ -2,137 +2,137 @@
 
 var _flexibleNumberConversion = require("@/Math/flexibleNumberConversion");
 describe("flexibleNumberConversion", function () {
-  // 基本的な数値入力
-  describe("基本的な数値入力", function () {
-    test("正の整数をそのまま返す", function () {
+  // Basic numeric input
+  describe("Basic numeric input", function () {
+    test("should return positive integers as-is", function () {
       expect((0, _flexibleNumberConversion.flexibleNumberConversion)(123)).toBe(123);
       expect((0, _flexibleNumberConversion.flexibleNumberConversion)(456)).toBe(456);
       expect((0, _flexibleNumberConversion.flexibleNumberConversion)(789)).toBe(789);
     });
-    test("負の整数をそのまま返す", function () {
+    test("should return negative integers as-is", function () {
       expect((0, _flexibleNumberConversion.flexibleNumberConversion)(-123)).toBe(-123);
       expect((0, _flexibleNumberConversion.flexibleNumberConversion)(-456)).toBe(-456);
       expect((0, _flexibleNumberConversion.flexibleNumberConversion)(-789)).toBe(-789);
     });
-    test("ゼロをそのまま返す", function () {
+    test("should return zero as-is", function () {
       expect((0, _flexibleNumberConversion.flexibleNumberConversion)(0)).toBe(0);
       expect((0, _flexibleNumberConversion.flexibleNumberConversion)(-0)).toBe(-0);
     });
   });
 
-  // 文字列としての数値入力
-  describe("文字列としての数値入力", function () {
-    test("正の整数の文字列を適切に変換する", function () {
+  // String numeric input
+  describe("String numeric input", function () {
+    test("should properly convert positive integer strings", function () {
       expect((0, _flexibleNumberConversion.flexibleNumberConversion)("123")).toBe(123);
       expect((0, _flexibleNumberConversion.flexibleNumberConversion)("456")).toBe(456);
       expect((0, _flexibleNumberConversion.flexibleNumberConversion)("789")).toBe(789);
     });
-    test("負の整数の文字列を適切に変換する", function () {
+    test("should properly convert negative integer strings", function () {
       expect((0, _flexibleNumberConversion.flexibleNumberConversion)("-123")).toBe(-123);
       expect((0, _flexibleNumberConversion.flexibleNumberConversion)("-456")).toBe(-456);
       expect((0, _flexibleNumberConversion.flexibleNumberConversion)("-789")).toBe(-789);
     });
-    test("小数の文字列を適切に変換する", function () {
+    test("should properly convert decimal strings", function () {
       expect((0, _flexibleNumberConversion.flexibleNumberConversion)("3.14")).toBe(3.14);
       expect((0, _flexibleNumberConversion.flexibleNumberConversion)("-2.718")).toBe(-2.718);
       expect((0, _flexibleNumberConversion.flexibleNumberConversion)("0.001")).toBe(0.001);
     });
-    test("指数表記の文字列を正しく解釈する", function () {
+    test("should correctly interpret exponential notation strings", function () {
       expect((0, _flexibleNumberConversion.flexibleNumberConversion)("1e3")).toBe(1000);
       expect((0, _flexibleNumberConversion.flexibleNumberConversion)("-2.5e-3")).toBe(-0.0025);
       expect((0, _flexibleNumberConversion.flexibleNumberConversion)("6.022e23")).toBe(6.022e23);
     });
-    test("特殊な基数表記の文字列を正しく解釈する", function () {
+    test("should correctly interpret special base notation strings", function () {
       expect((0, _flexibleNumberConversion.flexibleNumberConversion)("0x1A")).toBe(26);
       expect((0, _flexibleNumberConversion.flexibleNumberConversion)("0b1011")).toBe(11);
       expect((0, _flexibleNumberConversion.flexibleNumberConversion)("0o77")).toBe(63);
     });
-    test("数値の前後にスペースがある文字列を適切に変換する", function () {
+    test("should properly convert strings with spaces around numbers", function () {
       expect((0, _flexibleNumberConversion.flexibleNumberConversion)(" 123 ")).toBe(123);
       expect((0, _flexibleNumberConversion.flexibleNumberConversion)("   -456")).toBe(-456);
       expect((0, _flexibleNumberConversion.flexibleNumberConversion)("789   ")).toBe(789);
     });
-    test("プラス符号のみの文字列を処理する", function () {
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("+")).toBe(NaN);
+    test("should handle strings with only plus sign", function () {
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("+")).toBe(Number.NaN);
       expect((0, _flexibleNumberConversion.flexibleNumberConversion)("+123")).toBe(123);
       expect((0, _flexibleNumberConversion.flexibleNumberConversion)("+0")).toBe(0);
     });
-    test("無効な指数表記を持つ文字列を処理する", function () {
+    test("should handle strings with invalid exponential notation", function () {
       expect((0, _flexibleNumberConversion.flexibleNumberConversion)("1e")).toBe(1);
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("e10")).toBe(NaN);
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("e10")).toBe(Number.NaN);
       expect((0, _flexibleNumberConversion.flexibleNumberConversion)("2e+")).toBe(2);
     });
-    test("小数点のみの文字列を処理する", function () {
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)(".")).toBe(NaN);
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("-.")).toBe(NaN);
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)(".e1")).toBe(NaN);
+    test("should handle strings with only decimal point", function () {
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)(".")).toBe(Number.NaN);
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("-.")).toBe(Number.NaN);
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)(".e1")).toBe(Number.NaN);
     });
-    test("数値で始まらない文字列を処理する", function () {
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("px42")).toBe(NaN);
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("meter3.14")).toBe(NaN);
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("abc123")).toBe(NaN);
+    test("should handle strings that don't start with a number", function () {
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("px42")).toBe(Number.NaN);
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("meter3.14")).toBe(Number.NaN);
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("abc123")).toBe(Number.NaN);
     });
   });
 
-  // 特殊な数値入力
-  describe("特殊な数値入力", function () {
-    test("Infinityを適切に処理する", function () {
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("Infinity")).toBe(Infinity);
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("-Infinity")).toBe(-Infinity);
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)(Infinity)).toBe(Infinity);
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)(-Infinity)).toBe(-Infinity);
-    });
-    test("NaNの入力を処理する", function () {
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)(NaN)).toBe(NaN);
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("NaN")).toBe(NaN);
-    });
-    test("非常に大きな数値を適切に処理する", function () {
+  // Special numeric input
+  describe("Special numeric input", function () {
+    test("should properly handle Infinity", function () {
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("Infinity")).toBe(Number.POSITIVE_INFINITY);
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("-Infinity")).toBe(Number.NEGATIVE_INFINITY);
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)(Number.POSITIVE_INFINITY)).toBe(Number.POSITIVE_INFINITY);
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)(Number.NEGATIVE_INFINITY)).toBe(Number.NEGATIVE_INFINITY);
+    });
+    test("should handle NaN input", function () {
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)(Number.NaN)).toBe(Number.NaN);
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("NaN")).toBe(Number.NaN);
+    });
+    test("should properly handle very large numbers", function () {
       expect((0, _flexibleNumberConversion.flexibleNumberConversion)(Number.MAX_SAFE_INTEGER)).toBe(Number.MAX_SAFE_INTEGER);
       expect((0, _flexibleNumberConversion.flexibleNumberConversion)("9007199254740991")).toBe(9007199254740991);
       expect((0, _flexibleNumberConversion.flexibleNumberConversion)("1e308")).toBe(1e308);
     });
-    test("非常に小さな数値を適切に処理する", function () {
+    test("should properly handle very small numbers", function () {
       expect((0, _flexibleNumberConversion.flexibleNumberConversion)(Number.MIN_VALUE)).toBe(Number.MIN_VALUE);
       expect((0, _flexibleNumberConversion.flexibleNumberConversion)("5e-324")).toBe(5e-324);
       expect((0, _flexibleNumberConversion.flexibleNumberConversion)("-1e-308")).toBe(-1e-308);
     });
   });
 
-  // 無効または特殊な入力
-  describe("無効または特殊な入力", function () {
-    test("空文字列、null、undefinedを0として扱う", function () {
+  // Invalid or special input
+  describe("Invalid or special input", function () {
+    test("should treat empty string, null, undefined as 0", function () {
       expect((0, _flexibleNumberConversion.flexibleNumberConversion)("")).toBe(0);
       expect((0, _flexibleNumberConversion.flexibleNumberConversion)(null)).toBe(0);
       expect((0, _flexibleNumberConversion.flexibleNumberConversion)(undefined)).toBe(0);
     });
-    test("無効な文字列をNaNとして返す", function () {
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("not a number")).toBe(NaN);
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("abc")).toBe(NaN);
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("abc123")).toBe(NaN);
+    test("should return NaN for invalid strings", function () {
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("not a number")).toBe(Number.NaN);
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("abc")).toBe(Number.NaN);
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("abc123")).toBe(Number.NaN);
     });
-    test("オブジェクトや配列をNaNとして返す", function () {
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)({})).toBe(NaN);
+    test("should return NaN for objects and arrays", function () {
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)({})).toBe(Number.NaN);
       expect((0, _flexibleNumberConversion.flexibleNumberConversion)({
         key: "value"
-      })).toBe(NaN);
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)([])).toBe(NaN);
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)([1, 2, 3])).toBe(NaN);
+      })).toBe(Number.NaN);
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)([])).toBe(Number.NaN);
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)([1, 2, 3])).toBe(Number.NaN);
     });
-    test("関数をNaNとして返す", function () {
+    test("should return NaN for functions", function () {
       var func = function func() {};
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)(func)).toBe(NaN);
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)(function () {})).toBe(NaN);
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)(function () {})).toBe(NaN);
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)(func)).toBe(Number.NaN);
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)(function () {})).toBe(Number.NaN);
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)(function () {})).toBe(Number.NaN);
     });
-    test("特殊文字を含む文字列をNaNとして返す", function () {
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("@123")).toBe(NaN);
-      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("!@#$%")).toBe(NaN);
+    test("should return NaN for strings with special characters", function () {
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("@123")).toBe(Number.NaN);
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("!@#$%")).toBe(Number.NaN);
     });
   });
 
-  // 複雑なケース
-  describe("複雑なケース", function () {
-    test("数値と文字が混在する文字列の先頭を数値として抽出する", function () {
+  // Complex cases
+  describe("Complex cases", function () {
+    test("should extract leading number from strings with mixed numbers and characters", function () {
       expect((0, _flexibleNumberConversion.flexibleNumberConversion)("42px")).toBe(42);
       expect((0, _flexibleNumberConversion.flexibleNumberConversion)("-42px")).toBe(-42);
       expect((0, _flexibleNumberConversion.flexibleNumberConversion)("3.14meters")).toBe(3.14);
@@ -140,18 +140,18 @@ describe("flexibleNumberConversion", function () {
       expect((0, _flexibleNumberConversion.flexibleNumberConversion)("1e10meters")).toBe(1e10);
       expect((0, _flexibleNumberConversion.flexibleNumberConversion)("-1e10meters")).toBe(-1e10);
     });
-    test("内部にスペースが含まれる文字列を適切に処理する", function () {
+    test("should properly handle strings with internal spaces", function () {
       expect((0, _flexibleNumberConversion.flexibleNumberConversion)(" 123 456 ")).toBe(123);
       expect((0, _flexibleNumberConversion.flexibleNumberConversion)(" -456px ")).toBe(-456);
       expect((0, _flexibleNumberConversion.flexibleNumberConversion)("3.14 meters")).toBe(3.14);
       expect((0, _flexibleNumberConversion.flexibleNumberConversion)("1e2 meters")).toBe(100);
     });
-    test("先頭にゼロが付く数値を適切に処理する", function () {
+    test("should properly handle numbers with leading zeros", function () {
       expect((0, _flexibleNumberConversion.flexibleNumberConversion)("0123")).toBe(123);
       expect((0, _flexibleNumberConversion.flexibleNumberConversion)("-0456")).toBe(-456);
       expect((0, _flexibleNumberConversion.flexibleNumberConversion)("000789")).toBe(789);
     });
-    test("先頭にプラス符号が付く数値を適切に処理する", function () {
+    test("should properly handle numbers with leading plus sign", function () {
       expect((0, _flexibleNumberConversion.flexibleNumberConversion)("+123")).toBe(123);
       expect((0, _flexibleNumberConversion.flexibleNumberConversion)("+0")).toBe(0);
       expect((0, _flexibleNumberConversion.flexibleNumberConversion)("+3.14")).toBe(3.14);
@@ -159,35 +159,35 @@ describe("flexibleNumberConversion", function () {
     });
   });
 
-  // パフォーマンスとストレステスト
-  describe("パフォーマンスとストレステスト", function () {
-    test("大量の連続した有効な入力を処理する", function () {
+  // Performance and stress tests
+  describe("Performance and stress tests", function () {
+    test("should handle large sequences of valid inputs", function () {
       for (var i = 0; i < 1000; i++) {
         expect((0, _flexibleNumberConversion.flexibleNumberConversion)(i.toString())).toBe(i);
       }
     });
-    test("大量の連続した無効な入力を処理する", function () {
+    test("should handle large sequences of invalid inputs", function () {
       for (var i = 0; i < 1000; i++) {
-        expect((0, _flexibleNumberConversion.flexibleNumberConversion)("invalid".concat(i))).toBe(NaN);
+        expect((0, _flexibleNumberConversion.flexibleNumberConversion)("invalid".concat(i))).toBe(Number.NaN);
       }
     });
   });
 
-  // 境界値テスト
-  describe("境界値テスト", function () {
-    test("Number.MAX_VALUEを処理する", function () {
+  // Boundary value tests
+  describe("Boundary value tests", function () {
+    test("should handle Number.MAX_VALUE", function () {
       expect((0, _flexibleNumberConversion.flexibleNumberConversion)(Number.MAX_VALUE)).toBe(Number.MAX_VALUE);
       expect((0, _flexibleNumberConversion.flexibleNumberConversion)("1.7976931348623157e+308")).toBe(Number.MAX_VALUE);
     });
-    test("Number.MIN_VALUEを処理する", function () {
+    test("should handle Number.MIN_VALUE", function () {
       expect((0, _flexibleNumberConversion.flexibleNumberConversion)(Number.MIN_VALUE)).toBe(Number.MIN_VALUE);
       expect((0, _flexibleNumberConversion.flexibleNumberConversion)("5e-324")).toBe(Number.MIN_VALUE);
     });
-    test("Number.MAX_SAFE_INTEGERを処理する", function () {
+    test("should handle Number.MAX_SAFE_INTEGER", function () {
       expect((0, _flexibleNumberConversion.flexibleNumberConversion)(Number.MAX_SAFE_INTEGER)).toBe(Number.MAX_SAFE_INTEGER);
       expect((0, _flexibleNumberConversion.flexibleNumberConversion)("9007199254740991")).toBe(Number.MAX_SAFE_INTEGER);
     });
-    test("Number.MIN_SAFE_INTEGERを処理する", function () {
+    test("should handle Number.MIN_SAFE_INTEGER", function () {
       expect((0, _flexibleNumberConversion.flexibleNumberConversion)(Number.MIN_SAFE_INTEGER)).toBe(Number.MIN_SAFE_INTEGER);
       expect((0, _flexibleNumberConversion.flexibleNumberConversion)("-9007199254740991")).toBe(Number.MIN_SAFE_INTEGER);
     });

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

@@ -2,30 +2,30 @@
 
 var _gcd = require("@/Math/gcd");
 describe("gcd function", function () {
-  // 正の整数が２つの場合
+  // Test with two positive integers
   test("two positive integers", function () {
     expect((0, _gcd.gcd)(56, 48)).toBe(8);
   });
 
-  // 正の整数が３つ以上の場合
+  // Test with more than two positive integers
   test("more than two positive integers", function () {
     expect((0, _gcd.gcd)(56, 48, 32)).toBe(8);
     expect((0, _gcd.gcd)(56, 48, 32, 24)).toBe(8);
   });
 
-  // 0が含まれる場合
+  // Test with zero
   test("contains zero", function () {
     expect((0, _gcd.gcd)(56, 0)).toBe(0);
     expect((0, _gcd.gcd)(0, 56)).toBe(0);
   });
 
-  // 1が含まれる場合
+  // Test with one
   test("contains one", function () {
     expect((0, _gcd.gcd)(56, 1)).toBe(1);
     expect((0, _gcd.gcd)(1, 56)).toBe(1);
   });
 
-  // 負の数が含まれる場合
+  // Test with negative numbers
   test("contains negative numbers", function () {
     expect((0, _gcd.gcd)(-56, 48)).toBe(8);
     expect((0, _gcd.gcd)(56, -48)).toBe(8);

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

@@ -1,8 +1,44 @@
 "use strict";
 
 var _getDecimalLength = require("@/Math/getDecimalLength");
-test("{getDecimalLength}", function () {
-  expect((0, _getDecimalLength.getDecimalLength)(1)).toBe(0);
-  expect((0, _getDecimalLength.getDecimalLength)(1.1)).toBe(1);
-  expect((0, _getDecimalLength.getDecimalLength)(1.11)).toBe(2);
+describe("getDecimalLength function", function () {
+  describe("integers", function () {
+    it("should return 0 for whole numbers", function () {
+      expect((0, _getDecimalLength.getDecimalLength)(1)).toBe(0);
+      expect((0, _getDecimalLength.getDecimalLength)(100)).toBe(0);
+      expect((0, _getDecimalLength.getDecimalLength)(-42)).toBe(0);
+    });
+    it("should return 0 for whole numbers with .0", function () {
+      expect((0, _getDecimalLength.getDecimalLength)(1.0)).toBe(0);
+      expect((0, _getDecimalLength.getDecimalLength)(42.0)).toBe(0);
+      expect((0, _getDecimalLength.getDecimalLength)(-1.0)).toBe(0);
+    });
+  });
+  describe("decimal numbers", function () {
+    it("should count decimal places correctly", function () {
+      expect((0, _getDecimalLength.getDecimalLength)(1.1)).toBe(1);
+      expect((0, _getDecimalLength.getDecimalLength)(1.11)).toBe(2);
+      expect((0, _getDecimalLength.getDecimalLength)(1.123)).toBe(3);
+    });
+    it("should handle leading zeros in decimals", function () {
+      expect((0, _getDecimalLength.getDecimalLength)(1.01)).toBe(2);
+      expect((0, _getDecimalLength.getDecimalLength)(1.001)).toBe(3);
+      expect((0, _getDecimalLength.getDecimalLength)(1.000001)).toBe(6);
+    });
+    it("should handle negative numbers with decimals", function () {
+      expect((0, _getDecimalLength.getDecimalLength)(-1.1)).toBe(1);
+      expect((0, _getDecimalLength.getDecimalLength)(-0.01)).toBe(2);
+    });
+  });
+  describe("edge cases", function () {
+    it("should handle zero", function () {
+      expect((0, _getDecimalLength.getDecimalLength)(0)).toBe(0);
+      expect((0, _getDecimalLength.getDecimalLength)(0.0)).toBe(0);
+      expect((0, _getDecimalLength.getDecimalLength)(-0)).toBe(0);
+    });
+    it("should handle large decimal numbers", function () {
+      expect((0, _getDecimalLength.getDecimalLength)(123456.789)).toBe(3);
+      expect((0, _getDecimalLength.getDecimalLength)(-987654.321)).toBe(3);
+    });
+  });
 });

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

@@ -1,17 +1,17 @@
 "use strict";
 
 var _lcm = require("@/Math/lcm");
-describe("lcm関数のテスト", function () {
-  // 正数同士のテスト
-  test("正数の入力", function () {
+describe("lcm function", function () {
+  // Test with positive numbers
+  test("should handle positive numbers", function () {
     expect((0, _lcm.lcm)(4, 5)).toBe(20);
     expect((0, _lcm.lcm)(6, 8)).toBe(24);
     expect((0, _lcm.lcm)(10, 15)).toBe(30);
     expect((0, _lcm.lcm)(7, 11)).toBe(77);
   });
 
-  // 0を含むテスト
-  test("0を含む", function () {
+  // Test with zero
+  test("should handle zero values", function () {
     expect((0, _lcm.lcm)(0, 5)).toBe(0);
     expect((0, _lcm.lcm)(4, 0)).toBe(0);
     expect((0, _lcm.lcm)(0, 0)).toBe(0);
@@ -19,8 +19,8 @@ describe("lcm関数のテスト", function () {
     expect((0, _lcm.lcm)(7, 0)).toBe(0);
   });
 
-  // 1を含むテスト
-  test("1を含む", function () {
+  // Test with one
+  test("should handle values with one", function () {
     expect((0, _lcm.lcm)(1, 5)).toBe(5);
     expect((0, _lcm.lcm)(4, 1)).toBe(4);
     expect((0, _lcm.lcm)(1, 1)).toBe(1);
@@ -28,9 +28,16 @@ describe("lcm関数のテスト", function () {
     expect((0, _lcm.lcm)(7, 1)).toBe(7);
   });
 
-  // 大きな数値のテスト
-  test("大きな数値", function () {
+  // Test with large numbers
+  test("should handle large numbers", function () {
     expect((0, _lcm.lcm)(1000, 2000)).toBe(2000);
     expect((0, _lcm.lcm)(12345, 67890)).toBe(55873470);
   });
+
+  // Test with negative numbers
+  test("should handle negative numbers", function () {
+    expect((0, _lcm.lcm)(-4, 6)).toBe(12);
+    expect((0, _lcm.lcm)(4, -6)).toBe(12);
+    expect((0, _lcm.lcm)(-4, -6)).toBe(12);
+  });
 });

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

@@ -2,22 +2,22 @@
 
 var _linearCongruentialGenerator = require("@/Math/linearCongruentialGenerator");
 describe("linearCongruentialGenerator", function () {
-  it("乱数を生成する", function () {
+  it("should generate random numbers", function () {
     var result = (0, _linearCongruentialGenerator.linearCongruentialGenerator)(8, 13, 3, 5);
     expect(result).toBeGreaterThanOrEqual(0);
     expect(result).toBe(3);
   });
-  it("同じシード値で同じ乱数列を生成する", function () {
+  it("should generate the same sequence for the same seed", function () {
     var result1 = (0, _linearCongruentialGenerator.linearCongruentialGenerator)(12345);
     var result2 = (0, _linearCongruentialGenerator.linearCongruentialGenerator)(12345);
     expect(result1).toBe(result2);
   });
-  it("異なるシード値で異なる乱数列を生成する", function () {
+  it("should generate different sequences for different seeds", function () {
     var result1 = (0, _linearCongruentialGenerator.linearCongruentialGenerator)(12345);
     var result2 = (0, _linearCongruentialGenerator.linearCongruentialGenerator)(54321);
     expect(result1).not.toBe(result2);
   });
-  it("カスタムパラメータで乱数を生成する", function () {
+  it("should generate numbers with custom parameters", function () {
     var result1 = (0, _linearCongruentialGenerator.linearCongruentialGenerator)(12345, Math.pow(2, 31), 1103515245, 12345);
     expect(result1).toBeGreaterThanOrEqual(0);
     expect(result1).toBe(1406932606);