umt 2.1.2 → 2.2.1

package/module/es5/tests/unit/IP/isPrivateIp.test.js

@@ -2,19 +2,25 @@
 
 var _isPrivateIp = require("@/IP/isPrivateIp");
 describe("isPrivateIp", function () {
-  it("10.0.0.1はプライベートIPである", function () {
-    expect((0, _isPrivateIp.isPrivateIp)("10.0.0.1")).toBeTruthy();
+  describe("private IP addresses", function () {
+    test.each([
+    // [IP address, description]
+    ["10.0.0.1", "Class A private - start range"], ["10.255.255.255", "Class A private - end range"], ["172.16.0.1", "Class B private - start range"], ["172.31.255.255", "Class B private - end range"], ["192.168.0.1", "Class C private - start range"], ["192.168.255.255", "Class C private - end range"]])("should identify %s as private IP (%s)", function (ip) {
+      expect((0, _isPrivateIp.isPrivateIp)(ip)).toBe(true);
+    });
   });
-  it("172.16.0.1はプライベートIPである", function () {
-    expect((0, _isPrivateIp.isPrivateIp)("172.16.0.1")).toBeTruthy();
+  describe("non-private IP addresses", function () {
+    test.each([
+    // [IP address, description]
+    ["9.255.255.255", "Just before Class A private"], ["11.0.0.0", "Just after Class A private"], ["172.15.255.255", "Just before Class B private"], ["172.32.0.0", "Just after Class B private"], ["192.167.255.255", "Just before Class C private"], ["192.169.0.0", "Just after Class C private"], ["8.8.8.8", "Google DNS"], ["1.1.1.1", "Cloudflare DNS"], ["169.254.0.1", "Link-local address"], ["127.0.0.1", "Localhost"]])("should identify %s as non-private IP (%s)", function (ip) {
+      expect((0, _isPrivateIp.isPrivateIp)(ip)).toBe(false);
+    });
   });
-  it("192.168.0.1はプライベートIPである", function () {
-    expect((0, _isPrivateIp.isPrivateIp)("192.168.0.1")).toBeTruthy();
-  });
-  it("8.8.8.8はプライベートIPではない", function () {
-    expect((0, _isPrivateIp.isPrivateIp)("8.8.8.8")).toBeFalsy();
-  });
-  it("169.254.0.1はプライベートIPではない（リンクローカルアドレス）", function () {
-    expect((0, _isPrivateIp.isPrivateIp)("169.254.0.1")).toBeFalsy();
+  describe("invalid inputs", function () {
+    test.each([[undefined, "IP address is required"], ["", "IP address is required"], ["256.256.256.256", "Invalid IP address"], ["192.168", "Invalid IP address"], ["a.b.c.d", "Invalid IP address"], ["192.168.1.1.1", "Invalid IP address"], ["-1.0.0.0", "Invalid IP address"]])("should throw error for %s: %s", function (ip, expectedError) {
+      expect(function () {
+        return (0, _isPrivateIp.isPrivateIp)(ip);
+      }).toThrow(expectedError);
+    });
   });
 });

package/module/es5/tests/unit/IP/longToIp.test.d.ts

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

package/module/es5/tests/unit/IP/longToIp.test.js

@@ -0,0 +1,39 @@
+"use strict";
+
+var _longToIp = require("@/IP/longToIp");
+describe("longToIp", function () {
+  describe("valid 32-bit integers", function () {
+    test.each([
+    // [long value, expected IP]
+    [0xc0a80001, "192.168.0.1"],
+    // Common private network
+    [0x80000001, "128.0.0.1"],
+    // Class B start
+    [0x0a000001, "10.0.0.1"],
+    // Class A private
+    [0xac100001, "172.16.0.1"],
+    // Class B private
+    [0xffffffff, "255.255.255.255"],
+    // Maximum value
+    [0x00000000, "0.0.0.0"],
+    // Minimum value
+    [0x7f000001, "127.0.0.1"],
+    // Localhost
+    [0x01020304, "1.2.3.4"] // Simple incremental
+    ])("should convert %i to %s", function (_long, expected) {
+      expect((0, _longToIp.longToIp)(_long)).toBe(expected);
+    });
+  });
+  describe("invalid inputs", function () {
+    test.each([[undefined, "Input must be a valid 32-bit unsigned integer"], [null, "Input must be a valid 32-bit unsigned integer"], [Number.NaN, "Input must be a valid 32-bit unsigned integer"], [Number.POSITIVE_INFINITY, "Input must be a valid 32-bit unsigned integer"], [-1, "Input must be a valid 32-bit unsigned integer"], [0x100000000, "Input must be a valid 32-bit unsigned integer"],
+    // Too large
+    [1.5, "Input must be a valid 32-bit unsigned integer"],
+    // Not an integer
+    ["123", "Input must be a valid 32-bit unsigned integer"] // Wrong type
+    ])("should throw error for %p: %s", function (input, expectedError) {
+      expect(function () {
+        return (0, _longToIp.longToIp)(input);
+      }).toThrow(expectedError);
+    });
+  });
+});

package/module/es5/tests/unit/IP/subnetMaskToCidr.test.js

@@ -2,26 +2,40 @@
 
 var _subnetMaskToCidr = require("@/IP/subnetMaskToCidr");
 describe("subnetMaskToCidr", function () {
-  test("正しいCIDR値を返す", function () {
-    expect((0, _subnetMaskToCidr.subnetMaskToCidr)("255.255.255.0")).toBe(24);
-    expect((0, _subnetMaskToCidr.subnetMaskToCidr)("255.255.0.0")).toBe(16);
-    expect((0, _subnetMaskToCidr.subnetMaskToCidr)("255.0.0.0")).toBe(8);
+  describe("valid subnet masks", function () {
+    test.each([
+    // [subnet mask, expected CIDR]
+    ["255.255.255.255", 32],
+    // All bits set
+    ["255.255.255.0", 24],
+    // Common /24 network
+    ["255.255.0.0", 16],
+    // Common /16 network
+    ["255.0.0.0", 8],
+    // Common /8 network
+    ["255.255.254.0", 23],
+    // Less common /23 network
+    ["255.255.255.252", 30],
+    // Small /30 network
+    ["255.255.255.248", 29],
+    // Small /29 network
+    ["255.255.240.0", 20],
+    // Medium /20 network
+    ["0.0.0.0", 0] // No bits set
+    ])("should convert %s to /%i", function (mask, expected) {
+      expect((0, _subnetMaskToCidr.subnetMaskToCidr)(mask)).toBe(expected);
+    });
   });
-  test("無効なサブネットマスクの場合は0を返す", function () {
-    expect((0, _subnetMaskToCidr.subnetMaskToCidr)("255.255.255.256")).toBe(0);
-    expect((0, _subnetMaskToCidr.subnetMaskToCidr)("")).toBe(0);
-    expect((0, _subnetMaskToCidr.subnetMaskToCidr)("255.-1.255.0")).toBe(0);
-    expect((0, _subnetMaskToCidr.subnetMaskToCidr)("255.255.255.abc")).toBe(0);
-  });
-  test("すべてのオクテットが有効な数値の場合", function () {
-    expect((0, _subnetMaskToCidr.subnetMaskToCidr)("255.255.255.255")).toBe(32);
-  });
-  test("1つ以上のオクテットが0の場合", function () {
-    expect((0, _subnetMaskToCidr.subnetMaskToCidr)("255.0.0.0")).toBe(8);
-    expect((0, _subnetMaskToCidr.subnetMaskToCidr)("255.255.0.0")).toBe(16);
-  });
-  test("1つ以上のオクテットが255でない場合", function () {
-    expect((0, _subnetMaskToCidr.subnetMaskToCidr)("255.255.254.0")).toBe(23);
-    expect((0, _subnetMaskToCidr.subnetMaskToCidr)("255.255.255.252")).toBe(30);
+  describe("invalid subnet masks", function () {
+    test.each([[undefined, "Subnet mask is required"], ["", "Subnet mask is required"], ["192.168", "Invalid subnet mask format"], ["256.255.255.0", "Invalid subnet mask format"], ["255.255.255.256", "Invalid subnet mask format"], ["255.-1.255.0", "Invalid subnet mask format"], ["255.255.255.abc", "Invalid subnet mask format"], ["a.b.c.d", "Invalid subnet mask format"], ["255.255.255.1", "Invalid subnet mask: must be consecutive 1s followed by 0s"],
+    // Non-continuous mask
+    ["255.0.255.0", "Invalid subnet mask: must be consecutive 1s followed by 0s"],
+    // Non-continuous mask
+    ["254.255.255.0", "Invalid subnet mask: must be consecutive 1s followed by 0s"] // Invalid bit pattern
+    ])("should throw error for %s: %s", function (mask, expectedError) {
+      expect(function () {
+        return (0, _subnetMaskToCidr.subnetMaskToCidr)(mask);
+      }).toThrow(expectedError);
+    });
   });
 });

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

@@ -2,25 +2,47 @@
 
 var _average = require("@/Math/average");
 describe("average function", function () {
-  test("Basic scenarios", function () {
-    expect((0, _average.average)([1, 2])).toBe(1.5);
-    expect((0, _average.average)([1.1, 2.2])).toBeCloseTo(1.65);
-    expect((0, _average.average)([1.1, 2.2, 3.3, 4.4, 5.5])).toBeCloseTo(3.3);
-    expect((0, _average.average)([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])).toBe(5.5);
+  describe("basic scenarios", function () {
+    it("should calculate average of integer numbers", function () {
+      expect((0, _average.average)([1, 2])).toBe(1.5);
+      expect((0, _average.average)([1, 2, 3, 4, 5])).toBe(3);
+    });
+    it("should calculate average of decimal numbers", function () {
+      expect((0, _average.average)([1.1, 2.2])).toBeCloseTo(1.65);
+      expect((0, _average.average)([1.1, 2.2, 3.3, 4.4, 5.5])).toBeCloseTo(3.3);
+    });
+    it("should handle single element arrays", function () {
+      expect((0, _average.average)([5])).toBe(5);
+      expect((0, _average.average)([3.14])).toBe(3.14);
+    });
   });
-  test("Array with single element", function () {
-    expect((0, _average.average)([5])).toBe(5);
+  describe("special cases", function () {
+    it("should handle arrays with zeros", function () {
+      expect((0, _average.average)([0, 0, 0])).toBe(0);
+      expect((0, _average.average)([1, 0, 2, 0, 3])).toBe(1.2);
+    });
+    it("should handle negative numbers", function () {
+      expect((0, _average.average)([-1, -2])).toBe(-1.5);
+      expect((0, _average.average)([-10, -20, -30])).toBe(-20);
+    });
+    it("should handle mixed positive and negative numbers", function () {
+      expect((0, _average.average)([-1, 1])).toBe(0);
+      expect((0, _average.average)([-10, 10, -5, 5])).toBe(0);
+    });
+    it("should return 0 for empty arrays", function () {
+      expect((0, _average.average)([])).toBe(0);
+    });
   });
-  test("Array with zero", function () {
-    expect((0, _average.average)([0, 0, 0])).toBe(0);
-  });
-  test("Negative numbers", function () {
-    expect((0, _average.average)([-1, -2])).toBe(-1.5);
-  });
-  test("Mixed positive and negative numbers", function () {
-    expect((0, _average.average)([-1, 1])).toBe(0);
-  });
-  test("Empty array", function () {
-    expect((0, _average.average)([])).toBe(0);
+  describe("edge cases", function () {
+    it("should handle large numbers", function () {
+      expect((0, _average.average)([Number.MAX_SAFE_INTEGER, Number.MAX_SAFE_INTEGER])).toBe(Number.MAX_SAFE_INTEGER);
+    });
+    it("should handle small numbers", function () {
+      expect((0, _average.average)([Number.MIN_SAFE_INTEGER, Number.MIN_SAFE_INTEGER])).toBe(Number.MIN_SAFE_INTEGER);
+    });
+    it("should handle large arrays", function () {
+      var largeArray = new Array(10000).fill(1);
+      expect((0, _average.average)(largeArray)).toBe(1);
+    });
   });
 });

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

@@ -2,59 +2,59 @@
 
 var _bitwise = require("@/Math/bitwise");
 describe("bitwise", function () {
-  it("左に8ビット回転する", function () {
+  it("should rotate 8 bits to the left", function () {
     var result = (0, _bitwise.bitwise)(0x12345678, 8);
     expect(result.toString(16)).toBe("34567812");
   });
-  it("左に16ビット回転する", function () {
+  it("should rotate 16 bits to the left", function () {
     var result = (0, _bitwise.bitwise)(0x12345678, 16);
     expect(result.toString(16)).toBe("56781234");
   });
-  it("左に24ビット回転する", function () {
+  it("should rotate 24 bits to the left", function () {
     var result = (0, _bitwise.bitwise)(0x12345678, 24);
     expect(result.toString(16)).toBe("78123456");
   });
-  it("左に32ビット回転する (元の値と同じ)", function () {
+  it("should rotate 32 bits to the left (same as original value)", function () {
     var result = (0, _bitwise.bitwise)(0x12345678, 32);
     expect(result.toString(16)).toBe("12345678");
   });
-  it("左に0ビット回転する (元の値と同じ)", function () {
+  it("should rotate 0 bits to the left (same as original value)", function () {
     var result = (0, _bitwise.bitwise)(0x12345678, 0);
     expect(result.toString(16)).toBe("12345678");
   });
-  it("負のビット数で回転する (右回転と同じ)", function () {
+  it("should handle negative bit count (same as right rotation)", function () {
     var result = (0, _bitwise.bitwise)(0x12345678, -8);
     expect(result.toString(16)).toBe("78123456");
   });
-  it("ビット数が32を超える場合 (32で割った余りのビット数で回転)", function () {
+  it("should handle bit count over 32 (rotate by remainder when divided by 32)", function () {
     var result = (0, _bitwise.bitwise)(0x12345678, 40); // 40 % 32 = 8
     expect(result.toString(16)).toBe("34567812");
   });
-  it("右に8ビット回転する", function () {
+  it("should rotate 8 bits to the right", function () {
     var result = (0, _bitwise.bitwise)(0x12345678, 8, "right");
     expect(result.toString(16)).toBe("78123456");
   });
-  it("右に16ビット回転する", function () {
+  it("should rotate 16 bits to the right", function () {
     var result = (0, _bitwise.bitwise)(0x12345678, 16, "right");
     expect(result.toString(16)).toBe("56781234");
   });
-  it("右に24ビット回転する", function () {
+  it("should rotate 24 bits to the right", function () {
     var result = (0, _bitwise.bitwise)(0x12345678, 24, "right");
     expect(result.toString(16)).toBe("34567812");
   });
-  it("右に32ビット回転する (元の値と同じ)", function () {
+  it("should rotate 32 bits to the right (same as original value)", function () {
     var result = (0, _bitwise.bitwise)(0x12345678, 32, "right");
     expect(result.toString(16)).toBe("12345678");
   });
-  it("右に0ビット回転する (元の値と同じ)", function () {
+  it("should rotate 0 bits to the right (same as original value)", function () {
     var result = (0, _bitwise.bitwise)(0x12345678, 0, "right");
     expect(result.toString(16)).toBe("12345678");
   });
-  it("ビット数が32を超える場合 (32で割った余りのビット数で回転)", function () {
+  it("should handle bit count over 32 (rotate by remainder when divided by 32)", function () {
     var result = (0, _bitwise.bitwise)(0x12345678, 40, "right"); // 40 % 32 = 8
     expect(result.toString(16)).toBe("78123456");
   });
-  it("不正な方向を指定する", function () {
+  it("should throw error for invalid direction", function () {
     expect(function () {
       return (0, _bitwise.bitwise)(0x12345678, 8, "invalid");
     }).toThrowError("Invalid direction");

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

@@ -1,8 +1,8 @@
 "use strict";
 
 var _calculator = require("@/Math/calculator");
-describe("calculator", function () {
-  // 足し算
+describe("calculator function", function () {
+  // Addition
   test("should handle addition", function () {
     expect((0, _calculator.calculator)("1+")).toBe("1+");
     expect((0, _calculator.calculator)("1+1")).toBe("2");
@@ -11,7 +11,7 @@ describe("calculator", function () {
     expect((0, _calculator.calculator)("1+1+1+1+1")).toBe("5");
   });
 
-  // 引き算
+  // Subtraction
   test("should handle subtraction", function () {
     expect((0, _calculator.calculator)("1-")).toBe("1-");
     expect((0, _calculator.calculator)("1-1")).toBe("0");
@@ -20,7 +20,7 @@ describe("calculator", function () {
     expect((0, _calculator.calculator)("1-1-1-1-1")).toBe("-3");
   });
 
-  // 掛け算
+  // Multiplication
   test("should handle multiplication", function () {
     expect((0, _calculator.calculator)("2*")).toBe("2*");
     expect((0, _calculator.calculator)("2*2")).toBe("4");
@@ -29,7 +29,7 @@ describe("calculator", function () {
     expect((0, _calculator.calculator)("2*2*2*2*2")).toBe("32");
   });
 
-  // 割り算
+  // Division
   test("should handle division", function () {
     expect((0, _calculator.calculator)("2/")).toBe("2/");
     expect((0, _calculator.calculator)("2/2")).toBe("1");
@@ -38,7 +38,7 @@ describe("calculator", function () {
     expect((0, _calculator.calculator)("2/2/2/2/2")).toBe("0.125");
   });
 
-  // べき乗
+  // Exponentiation
   test("should handle exponentiation", function () {
     expect((0, _calculator.calculator)("2^")).toBe("2^");
     expect((0, _calculator.calculator)("2^2")).toBe("4");
@@ -49,7 +49,7 @@ describe("calculator", function () {
     expect((0, _calculator.calculator)("3^4^2")).toBe("43046721");
   });
 
-  // 括弧
+  // Parentheses
   test("should handle parentheses", function () {
     expect((0, _calculator.calculator)("(1+1)")).toBe("2");
     expect((0, _calculator.calculator)("(1")).toBe("(1");
@@ -59,12 +59,12 @@ describe("calculator", function () {
     expect((0, _calculator.calculator)("(1+1)+(1+1)")).toBe("4");
   });
 
-  // 方程式
+  // Equations
   test("should handle equations", function () {
     expect((0, _calculator.calculator)("2x=(1+1)+(1+1)+(1+1)")).toBe("3");
   });
 
-  // 変数
+  // Variables and currency conversion
   test("should handle variables", function () {
     expect((0, _calculator.calculator)("$10*2", {
       $: 100

package/module/es5/tests/unit/Math/calculator/calculatorInitialization.test.js

@@ -1,10 +1,21 @@
 "use strict";
 
 var _calculatorInitialization = require("@/Math/calculator/calculatorInitialization");
-test("calculatorInitialization", function () {
-  var calculator = (0, _calculatorInitialization.calculatorInitialization)({
-    $: 100
+describe("calculatorInitialization function", function () {
+  it("should initialize a calculator with exchange rates", function () {
+    var calculator = (0, _calculatorInitialization.calculatorInitialization)({
+      $: 100
+    });
+    expect(calculator("$1")).toBe("100");
+    expect(calculator("100 + $1")).toBe("200");
+  });
+  it("should handle multiple exchange rates", function () {
+    var calculator = (0, _calculatorInitialization.calculatorInitialization)({
+      $: 100,
+      EUR: 120
+    });
+    expect(calculator("$1")).toBe("100");
+    expect(calculator("EUR1")).toBe("120");
+    expect(calculator("$1 + EUR1")).toBe("220");
   });
-  expect(calculator("$1")).toBe("100");
-  expect(calculator("100 + $1")).toBe("200");
 });

package/module/es5/tests/unit/Math/calculator/convertCurrency.test.js

@@ -2,37 +2,37 @@
 
 var _convertCurrency = require("@/Math/calculator/convertCurrency");
 /**
- * convertCurrency関数のテスト
+ * Tests for the convertCurrency function
  */
-describe("convertCurrency", function () {
-  // ケース 1
-  test("conversionRatesが未定義", function () {
+describe("convertCurrency function", function () {
+  // Case 1: No conversion rates provided
+  test("should return original string when conversionRates is undefined", function () {
     expect((0, _convertCurrency.convertCurrency)("¥1000")).toBe("¥1000");
   });
 
-  // ケース 2
-  test("通貨記号がマッチしない", function () {
+  // Case 2: Currency symbol doesn't match
+  test("should return original string when currency symbol doesn't match", function () {
     expect((0, _convertCurrency.convertCurrency)("¥1000", {
       $: 1.1
     })).toBe("¥1000");
   });
 
-  // ケース 3
-  test("通貨記号がマッチし、換算レートが数値", function () {
+  // Case 3: Currency symbol matches and conversion rate is a number
+  test("should convert currency when symbol matches and rate is a number", function () {
     expect((0, _convertCurrency.convertCurrency)("¥1000", {
       "¥": 1.1
     })).toBe("1100");
   });
 
-  // ケース 4
-  test("通貨記号がマッチし、換算レートが数値でない", function () {
+  // Case 4: Currency symbol matches but conversion rate is not a number
+  test("should return original string when rate is not a number", function () {
     expect((0, _convertCurrency.convertCurrency)("¥1000", {
       "¥": "invalid"
     })).toBe("¥1000");
   });
 
-  // ケース 5
-  test("換算結果がNaN", function () {
+  // Case 5: Conversion result is NaN
+  test("should return original string when conversion result is NaN", function () {
     expect((0, _convertCurrency.convertCurrency)("¥NaN", {
       "¥": 1.1
     })).toBe("¥NaN");

package/module/es5/tests/unit/Math/calculator/literalExpression.test.js

@@ -1,22 +1,22 @@
 "use strict";
 
 var _literalExpression = require("@/Math/calculator/literalExpression");
-describe("literalExpression", function () {
-  // 基本的な方程式
+describe("literalExpression function", function () {
+  // Basic equations with variable on left side
   test("should handle basic equations", function () {
     expect((0, _literalExpression.literalExpression)("x=1")).toBe("1");
     expect((0, _literalExpression.literalExpression)("x=0")).toBe("0");
     expect((0, _literalExpression.literalExpression)("x=-1")).toBe("-1");
   });
 
-  // 基本的な方程式(右辺)
+  // Basic equations with variable on right side
   test("should handle basic equations (right side)", function () {
     expect((0, _literalExpression.literalExpression)("1=x")).toBe("1");
     expect((0, _literalExpression.literalExpression)("0=x")).toBe("0");
     expect((0, _literalExpression.literalExpression)("-1=x")).toBe("-1");
   });
 
-  // 数値と変数が混在
+  // Equations with coefficients and additional terms (variable on left)
   test("should handle equations with mixed numerical and variable parts", function () {
     expect((0, _literalExpression.literalExpression)("2x=4")).toBe("2");
     expect((0, _literalExpression.literalExpression)("1x=1")).toBe("1");
@@ -25,7 +25,7 @@ describe("literalExpression", function () {
     expect((0, _literalExpression.literalExpression)("3x-2=-6")).toBe("-4/3");
   });
 
-  // 数値と変数が混在(右辺)
+  // Equations with coefficients and additional terms (variable on right)
   test("should handle equations with mixed numerical and variable parts (right side)", function () {
     expect((0, _literalExpression.literalExpression)("4=2x")).toBe("2");
     expect((0, _literalExpression.literalExpression)("1=1x")).toBe("1");
@@ -34,17 +34,17 @@ describe("literalExpression", function () {
     expect((0, _literalExpression.literalExpression)("-6=3x-2")).toBe("-4/3");
   });
 
-  // 最大公約数が1より大きい場合
+  // Simplification using greatest common divisor (variable on left)
   test("should simplify when gcd is greater than 1", function () {
     expect((0, _literalExpression.literalExpression)("2x=8")).toBe("4");
   });
 
-  // 最大公約数が1より大きい場合(右辺)
+  // Simplification using greatest common divisor (variable on right)
   test("should simplify when gcd is greater than 1 (right side)", function () {
     expect((0, _literalExpression.literalExpression)("8=2x")).toBe("4");
   });
 
-  // 無効な方程式
+  // Invalid equations
   test("should handle invalid equations", function () {
     expect((0, _literalExpression.literalExpression)("x=x")).toBe("");
   });

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

@@ -2,7 +2,7 @@
 
 var _degToRad = require("@/Math/degToRad");
 describe("degToRad", function () {
-  // 正常ケース
+  // Normal test cases
   test("degToRad: Normal Cases", function () {
     expect((0, _degToRad.degToRad)(0)).toBeCloseTo(0);
     expect((0, _degToRad.degToRad)(90)).toBeCloseTo(Math.PI / 2);
@@ -11,7 +11,7 @@ describe("degToRad", function () {
     expect((0, _degToRad.degToRad)(360)).toBeCloseTo(2 * Math.PI);
   });
 
-  // 負の角度
+  // Negative angles
   test("degToRad: Negative Angles", function () {
     expect((0, _degToRad.degToRad)(-90)).toBeCloseTo(-Math.PI / 2);
     expect((0, _degToRad.degToRad)(-180)).toBeCloseTo(-Math.PI);
@@ -19,14 +19,14 @@ describe("degToRad", function () {
     expect((0, _degToRad.degToRad)(-360)).toBeCloseTo(-2 * Math.PI);
   });
 
-  // 浮動小数点数の角度
+  // Floating point angles
   test("degToRad: Floating Point Angles", function () {
     expect((0, _degToRad.degToRad)(45.5)).toBeCloseTo(Math.PI / 4 + Math.PI / 360);
     expect((0, _degToRad.degToRad)(60.7)).toBeCloseTo(Math.PI * 60.7 / 180);
     expect((0, _degToRad.degToRad)(120.2)).toBeCloseTo(Math.PI * 120.2 / 180);
   });
 
-  // 360度以上と1000度以上の角度
+  // Angles greater than 360 and 1000 degrees
   test("degToRad: Angles Greater Than 360 and 1000 Degrees", function () {
     expect((0, _degToRad.degToRad)(450)).toBeCloseTo(5 * Math.PI / 2);
     expect((0, _degToRad.degToRad)(720)).toBeCloseTo(4 * Math.PI);
@@ -34,17 +34,17 @@ describe("degToRad", function () {
     expect((0, _degToRad.degToRad)(1440)).toBeCloseTo(8 * Math.PI);
   });
 
-  // NaNとInfinity
+  // NaN and Infinity cases
   test("degToRad: NaN and Infinity", function () {
-    expect((0, _degToRad.degToRad)(NaN)).toBe(NaN);
-    expect((0, _degToRad.degToRad)(Infinity)).toBe(Infinity);
-    expect((0, _degToRad.degToRad)(-Infinity)).toBe(-Infinity);
+    expect((0, _degToRad.degToRad)(Number.NaN)).toBe(Number.NaN);
+    expect((0, _degToRad.degToRad)(Number.POSITIVE_INFINITY)).toBe(Number.POSITIVE_INFINITY);
+    expect((0, _degToRad.degToRad)(Number.NEGATIVE_INFINITY)).toBe(Number.NEGATIVE_INFINITY);
   });
 
-  // 無効な入力
+  // Invalid inputs
   test("degToRad: Invalid Inputs", function () {
     expect((0, _degToRad.degToRad)("90")).toBeCloseTo(Math.PI / 2);
     expect((0, _degToRad.degToRad)([90])).toBeCloseTo(Math.PI / 2);
-    expect((0, _degToRad.degToRad)({})).toBe(NaN);
+    expect((0, _degToRad.degToRad)({})).toBe(Number.NaN);
   });
 });

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

@@ -1,30 +1,30 @@
 "use strict";
 
 var _deviationValue = require("@/Math/deviationValue");
-// 偏差値の計算に関するテスト
+// Tests for standard score calculation
 describe("deviationValue", function () {
-  // 正常な入力値でのテスト
-  test("正常な入力値", function () {
+  // Test with normal input values
+  test("should handle normal input values", function () {
     expect((0, _deviationValue.deviationValue)(100, 50, 10)).toBe(100);
   });
 
-  // 平均値と同じ値でのテスト
-  test("平均値と同じ値", function () {
+  // Test with value equal to mean
+  test("should handle value equal to mean", function () {
     expect((0, _deviationValue.deviationValue)(50, 50, 10)).toBe(50);
   });
 
-  // 標準偏差が0のケース（例外処理が必要な場合）
-  test("標準偏差が0", function () {
-    expect((0, _deviationValue.deviationValue)(100, 50, 0)).toBe(Infinity);
+  // Test with zero standard deviation
+  test("should handle zero standard deviation", function () {
+    expect((0, _deviationValue.deviationValue)(100, 50, 0)).toBe(Number.POSITIVE_INFINITY);
   });
 
-  // 負の値を含むケース
-  test("負の値を含む", function () {
+  // Test with negative values
+  test("should handle negative values", function () {
     expect((0, _deviationValue.deviationValue)(-20, 0, 20)).toBe(40);
   });
 
-  // 浮動小数点数を含むケース
-  test("浮動小数点数を含む", function () {
+  // Test with floating point numbers
+  test("should handle floating point numbers", function () {
     expect((0, _deviationValue.deviationValue)(55.5, 50, 10)).toBeCloseTo(55.5);
   });
 });