umt 2.1.2 → 2.2.0

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

@@ -1,37 +1,37 @@
 "use strict";
 
 var _mathConverter = require("@/Math/mathConverter");
-describe("mathConverter関数のテスト", function () {
-  // 乗算のテスト
-  test("乗算の変換", function () {
+describe("mathConverter function", function () {
+  // Test multiplication conversion
+  test("should convert multiplication", function () {
     expect((0, _mathConverter.mathConverter)("1250*1250")).toBe("1500*1000+400*100+200*100+50*50");
     expect((0, _mathConverter.mathConverter)("1350*1350")).toBe("1700*1000+600*100+400*100+200*100+50*50");
     expect((0, _mathConverter.mathConverter)("1550*1550")).toBe("2100*1000+1000*100+800*100+600*100+400*100+200*100+50*50");
   });
 
-  // 累乗のテスト
-  test("累乗の変換", function () {
+  // Test exponentiation conversion
+  test("should convert exponentiation", function () {
     expect((0, _mathConverter.mathConverter)("1250^2")).toBe("1500*1000+400*100+200*100+50*50");
     expect((0, _mathConverter.mathConverter)("1350^2")).toBe("1700*1000+600*100+400*100+200*100+50*50");
   });
 
-  // 何も変換しない場合のテスト
-  test("変換が不要な場合", function () {
+  // Test cases where no conversion is needed
+  test("should not convert when unnecessary", function () {
     expect((0, _mathConverter.mathConverter)("1250")).toBe("1250");
   });
 
-  // 複数のオペランドがある場合のテスト
-  test("複数のオペランドがある場合の変換", function () {
+  // Test cases with multiple operands
+  test("should handle multiple operands", function () {
     expect((0, _mathConverter.mathConverter)("1250+1250")).toBe("1250+1250");
   });
 
-  // 無効な入力のテスト
-  test("無効な入力の場合", function () {
+  // Test invalid inputs
+  test("should handle invalid input", function () {
     expect((0, _mathConverter.mathConverter)("abc")).toBe("abc");
   });
 
-  // primaryがない場合のテスト
-  test("primaryがない場合", function () {
+  // Test when primary value is missing
+  test("should handle missing primary value", function () {
     expect((0, _mathConverter.mathConverter)("0*0")).toBe("0*0");
   });
 });

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

@@ -2,7 +2,7 @@
 
 var _mathSeparator = require("@/Math/mathSeparator");
 describe("mathSeparator", function () {
-  // 数字の型（number）のテスト
+  // Test number type inputs
   it("should handle single digit numbers", function () {
     expect((0, _mathSeparator.mathSeparator)(5)).toEqual([5, 0]);
   });
@@ -10,7 +10,7 @@ describe("mathSeparator", function () {
     expect((0, _mathSeparator.mathSeparator)(1250)).toEqual([1000, 250]);
   });
 
-  // 文字列型の数字のテスト
+  // Test string number inputs
   it("should handle single digit string numbers", function () {
     expect((0, _mathSeparator.mathSeparator)("5")).toEqual([5, 0]);
   });
@@ -18,7 +18,7 @@ describe("mathSeparator", function () {
     expect((0, _mathSeparator.mathSeparator)("1250")).toEqual([1000, 250]);
   });
 
-  // 0および'0'のケース
+  // Test zero cases
   it("should handle 0", function () {
     expect((0, _mathSeparator.mathSeparator)(0)).toEqual([0, 0]);
   });
@@ -26,16 +26,34 @@ describe("mathSeparator", function () {
     expect((0, _mathSeparator.mathSeparator)("0")).toEqual([0, 0]);
   });
 
-  // 不正な値のケース
+  // Test invalid inputs
   it("should return [0, 0] for non-number input", function () {
     expect((0, _mathSeparator.mathSeparator)("abc")).toEqual([0, 0]);
   });
 
-  // 小数のケース
+  // Test decimal numbers
   it("should handle decimal numbers", function () {
     expect((0, _mathSeparator.mathSeparator)(12.5)).toEqual([10, 2.5]);
   });
   it("should handle decimal string numbers", function () {
     expect((0, _mathSeparator.mathSeparator)("12.5")).toEqual([10, 2.5]);
   });
+
+  // Test edge cases
+  it("should handle negative numbers", function () {
+    expect((0, _mathSeparator.mathSeparator)(-1250)).toEqual([10000, -11250]);
+    expect((0, _mathSeparator.mathSeparator)("-1250.5")).toEqual([10000, -11249.5]);
+  });
+  it("should handle very large numbers", function () {
+    expect((0, _mathSeparator.mathSeparator)(1000000)).toEqual([1000000, 0]);
+    expect((0, _mathSeparator.mathSeparator)("1000000.123")).toEqual([1000000, 0.123]);
+  });
+  it("should handle special numeric strings", function () {
+    // Note: "1e5" is treated as a regular string "1e5"
+    expect((0, _mathSeparator.mathSeparator)("1e5")).toEqual([100, 99900]);
+    // Note: isNumber treats "0xFF" as a valid number, so it's processed accordingly
+    expect((0, _mathSeparator.mathSeparator)("0xFF")).toEqual([1000, -745]);
+    // Note: "Infinity" is not a valid number in this context
+    expect((0, _mathSeparator.mathSeparator)("Infinity")).toEqual([0, 0]);
+  });
 });

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

@@ -1,7 +1,22 @@
 "use strict";
 
 var _max = require("@/Math/max");
-test("{max}", function () {
-  expect((0, _max.max)(1, 1)).toBe(1);
-  expect((0, _max.max)(1, 2)).toBe(2);
+describe("max function", function () {
+  it("should return the maximum value", function () {
+    expect((0, _max.max)(1, 2, 3)).toBe(3);
+    expect((0, _max.max)(3, 2, 1)).toBe(3);
+    expect((0, _max.max)(-1, -2, -3)).toBe(-1);
+  });
+  it("should remove duplicates before finding maximum", function () {
+    expect((0, _max.max)(1, 1, 1)).toBe(1);
+    expect((0, _max.max)(1, 2, 2, 3, 3)).toBe(3);
+  });
+  it("should handle single value", function () {
+    expect((0, _max.max)(5)).toBe(5);
+    expect((0, _max.max)(-5)).toBe(-5);
+  });
+  it("should handle decimal numbers", function () {
+    expect((0, _max.max)(1.5, 2.5, 1.1)).toBe(2.5);
+    expect((0, _max.max)(-1.5, -2.5, -1.1)).toBe(-1.1);
+  });
 });

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

@@ -2,16 +2,16 @@
 
 var _median = require("@/Math/median");
 describe("median", function () {
-  it("偶数個の要素を持つ配列の中央値を計算する", function () {
+  it("should calculate median of array with even number of elements", function () {
     expect((0, _median.median)([1, 2, 3, 4])).toBe(2.5);
   });
-  it("奇数個の要素を持つ配列の中央値を計算する", function () {
+  it("should calculate median of array with odd number of elements", function () {
     expect((0, _median.median)([1, 3, 3, 6, 7, 8, 9])).toBe(6);
   });
-  it("空の配列が与えられた場合はNaNを返す", function () {
+  it("should return NaN for empty array", function () {
     expect((0, _median.median)([])).toBeNaN();
   });
-  it("ソートされていない配列の中央値を計算する", function () {
+  it("should calculate median of unsorted array", function () {
     expect((0, _median.median)([9, 1, 5, 3, 6])).toBe(5);
   });
 });

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

@@ -1,7 +1,22 @@
 "use strict";
 
 var _min = require("@/Math/min");
-test("{min}", function () {
-  expect((0, _min.min)(1, 1)).toBe(1);
-  expect((0, _min.min)(1, 2)).toBe(1);
+describe("min function", function () {
+  it("should return the minimum value", function () {
+    expect((0, _min.min)(1, 2, 3)).toBe(1);
+    expect((0, _min.min)(3, 2, 1)).toBe(1);
+    expect((0, _min.min)(-1, -2, -3)).toBe(-3);
+  });
+  it("should remove duplicates before finding minimum", function () {
+    expect((0, _min.min)(1, 1, 1)).toBe(1);
+    expect((0, _min.min)(1, 2, 2, 3, 3)).toBe(1);
+  });
+  it("should handle single value", function () {
+    expect((0, _min.min)(5)).toBe(5);
+    expect((0, _min.min)(-5)).toBe(-5);
+  });
+  it("should handle decimal numbers", function () {
+    expect((0, _min.min)(1.5, 2.5, 1.1)).toBe(1.1);
+    expect((0, _min.min)(-1.5, -2.5, -1.1)).toBe(-2.5);
+  });
 });

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

@@ -1,14 +1,30 @@
 "use strict";
 
 var _multiples = require("@/Math/multiples");
-test("{multiples}", function () {
-  expect((0, _multiples.multiples)(1, 1)).toEqual([1]);
-  expect((0, _multiples.multiples)(1, 2)).toEqual([1, 2]);
-  expect((0, _multiples.multiples)(1, 3)).toEqual([1, 2, 3]);
-  expect((0, _multiples.multiples)(1, 4)).toEqual([1, 2, 3, 4]);
-  expect((0, _multiples.multiples)(1, 5)).toEqual([1, 2, 3, 4, 5]);
-  expect((0, _multiples.multiples)(1, 6)).toEqual([1, 2, 3, 4, 5, 6]);
-  expect((0, _multiples.multiples)(2, 1)).toEqual([2]);
-  expect((0, _multiples.multiples)(2, 2)).toEqual([2, 4]);
-  expect((0, _multiples.multiples)(2, 3)).toEqual([2, 4, 6]);
+describe("multiples function", function () {
+  it("should generate multiples of 1", function () {
+    expect((0, _multiples.multiples)(1, 1)).toEqual([1]);
+    expect((0, _multiples.multiples)(1, 3)).toEqual([1, 2, 3]);
+    expect((0, _multiples.multiples)(1, 5)).toEqual([1, 2, 3, 4, 5]);
+  });
+  it("should generate multiples of 2", function () {
+    expect((0, _multiples.multiples)(2, 1)).toEqual([2]);
+    expect((0, _multiples.multiples)(2, 3)).toEqual([2, 4, 6]);
+    expect((0, _multiples.multiples)(2, 5)).toEqual([2, 4, 6, 8, 10]);
+  });
+  it("should generate multiples of negative numbers", function () {
+    expect((0, _multiples.multiples)(-2, 3)).toEqual([-2, -4, -6]);
+    expect((0, _multiples.multiples)(-3, 4)).toEqual([-3, -6, -9, -12]);
+  });
+  it("should handle zero as base number", function () {
+    expect((0, _multiples.multiples)(0, 3)).toEqual([0, 0, 0]);
+  });
+  it("should return empty array for zero count", function () {
+    expect((0, _multiples.multiples)(2, 0)).toEqual([]);
+    expect((0, _multiples.multiples)(-2, 0)).toEqual([]);
+  });
+  it("should handle decimal numbers", function () {
+    expect((0, _multiples.multiples)(0.5, 3)).toEqual([0.5, 1, 1.5]);
+    expect((0, _multiples.multiples)(1.5, 3)).toEqual([1.5, 3, 4.5]);
+  });
 });

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

@@ -1,14 +1,48 @@
 "use strict";
 
 var _multiplication = require("@/Math/multiplication");
-function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread(); }
-function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
-function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
-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("multiplication", function () {
-  test.each([[[1, 1], 1], [[1, 2], 2], [[1.1, 2.2], 2.42], [[1, 2, 3], 6], [[2, 2, 2], 8], [[0.5, 2, 2], 2]])("multiplication(%s) equals %s", function (args, expected) {
-    expect(_multiplication.multiplication.apply(void 0, _toConsumableArray(args))).toBeCloseTo(expected);
+describe("multiplication function", function () {
+  describe("basic integer multiplication", function () {
+    it("should multiply two positive integers", function () {
+      expect((0, _multiplication.multiplication)(2, 3)).toBe(6);
+      expect((0, _multiplication.multiplication)(10, 20)).toBe(200);
+    });
+    it("should multiply multiple positive integers", function () {
+      expect((0, _multiplication.multiplication)(2, 3, 4)).toBe(24);
+      expect((0, _multiplication.multiplication)(1, 2, 3, 4, 5)).toBe(120);
+    });
+  });
+  describe("decimal number multiplication", function () {
+    it("should handle decimal multiplication without floating point errors", function () {
+      expect((0, _multiplication.multiplication)(0.1, 0.2)).toBeCloseTo(0.02);
+      expect((0, _multiplication.multiplication)(0.1, 0.2, 0.3)).toBeCloseTo(0.006);
+      expect((0, _multiplication.multiplication)(1.23, 4.56)).toBeCloseTo(5.6088);
+    });
+    it("should handle mixed integer and decimal multiplication", function () {
+      expect((0, _multiplication.multiplication)(0.5, 2)).toBe(1);
+      expect((0, _multiplication.multiplication)(0.1, 10)).toBe(1);
+      expect((0, _multiplication.multiplication)(1.5, 2, 3)).toBe(9);
+    });
+  });
+  describe("edge cases", function () {
+    it("should handle negative numbers", function () {
+      expect((0, _multiplication.multiplication)(-2, 3)).toBe(-6);
+      expect((0, _multiplication.multiplication)(2, -3)).toBe(-6);
+      expect((0, _multiplication.multiplication)(-2, -3)).toBe(6);
+    });
+    it("should handle zero", function () {
+      expect((0, _multiplication.multiplication)(0, 5)).toBe(0);
+      expect((0, _multiplication.multiplication)(5, 0)).toBe(0);
+      expect((0, _multiplication.multiplication)(0, 0)).toBe(0);
+    });
+    it("should handle multiplication by one", function () {
+      expect((0, _multiplication.multiplication)(1, 5)).toBe(5);
+      expect((0, _multiplication.multiplication)(5, 1)).toBe(5);
+      expect((0, _multiplication.multiplication)(1, 1)).toBe(1);
+    });
+    it("should handle very small numbers", function () {
+      expect((0, _multiplication.multiplication)(0.0001, 0.0001)).toBeCloseTo(0.00000001);
+      expect((0, _multiplication.multiplication)(0.00001, 0.00001)).toBeCloseTo(0.0000000001);
+    });
   });
 });

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

@@ -2,20 +2,33 @@
 
 var _nCr = require("@/Math/nCr");
 describe("nCr function", function () {
-  // 正常系
-  test("calculate nCr for n=5, r=2", function () {
-    expect((0, _nCr.nCr)(5, 2)).toBe(10);
+  describe("valid combinations", function () {
+    it("should calculate basic combinations correctly", function () {
+      expect((0, _nCr.nCr)(5, 2)).toBe(10); // 5C2 = 10
+      expect((0, _nCr.nCr)(10, 4)).toBe(210); // 10C4 = 210
+    });
+    it("should handle choosing all items", function () {
+      expect((0, _nCr.nCr)(3, 3)).toBe(1); // 3C3 = 1
+      expect((0, _nCr.nCr)(5, 5)).toBe(1); // 5C5 = 1
+    });
+    it("should handle choosing one item", function () {
+      expect((0, _nCr.nCr)(5, 1)).toBe(5); // 5C1 = 5
+      expect((0, _nCr.nCr)(10, 1)).toBe(10); // 10C1 = 10
+    });
+    it("should calculate larger combinations", function () {
+      expect((0, _nCr.nCr)(20, 10)).toBe(184756); // 20C10 = 184,756
+      expect((0, _nCr.nCr)(15, 7)).toBe(6435); // 15C7 = 6,435
+    });
   });
-  test("calculate nCr for n=10, r=4", function () {
-    expect((0, _nCr.nCr)(10, 4)).toBe(210);
-  });
-
-  // 異常系
-  test("return NaN when n or r is 0", function () {
-    expect((0, _nCr.nCr)(0, 5)).toBeNaN();
-    expect((0, _nCr.nCr)(5, 0)).toBeNaN();
-  });
-  test("return NaN when n < r", function () {
-    expect((0, _nCr.nCr)(2, 5)).toBeNaN();
+  describe("edge cases", function () {
+    it("should return NaN when n or r is 0", function () {
+      expect((0, _nCr.nCr)(0, 5)).toBeNaN();
+      expect((0, _nCr.nCr)(5, 0)).toBeNaN();
+      expect((0, _nCr.nCr)(0, 0)).toBeNaN();
+    });
+    it("should return NaN when n is less than r", function () {
+      expect((0, _nCr.nCr)(2, 5)).toBeNaN();
+      expect((0, _nCr.nCr)(3, 4)).toBeNaN();
+    });
   });
 });

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

@@ -2,21 +2,34 @@
 
 var _nHr = require("@/Math/nHr");
 describe("nHr function", function () {
-  // 正常系
-  test("calculate nHr for n=5, r=2", function () {
-    expect((0, _nHr.nHr)(5, 2)).toBe(15);
+  describe("valid combinations with repetition", function () {
+    it("should calculate basic combinations with repetition correctly", function () {
+      expect((0, _nHr.nHr)(5, 2)).toBe(15); // 5H2 = 15
+      expect((0, _nHr.nHr)(3, 3)).toBe(10); // 3H3 = 10
+    });
+    it("should handle choosing one item", function () {
+      expect((0, _nHr.nHr)(3, 1)).toBe(3); // 3H1 = 3
+      expect((0, _nHr.nHr)(5, 1)).toBe(5); // 5H1 = 5
+    });
+    it("should handle choosing same as total items", function () {
+      expect((0, _nHr.nHr)(2, 2)).toBe(3); // 2H2 = 3
+      expect((0, _nHr.nHr)(4, 4)).toBe(35); // 4H4 = 35
+    });
+    it("should handle larger combinations", function () {
+      expect((0, _nHr.nHr)(10, 3)).toBe(220); // 10H3 = 220
+      expect((0, _nHr.nHr)(6, 4)).toBe(126); // 6H4 = 126
+    });
   });
-  test("calculate nHr for n=3, r=3", function () {
-    expect((0, _nHr.nHr)(3, 3)).toBe(10);
-  });
-
-  // 異常系
-  test("return NaN when n or r is 0", function () {
-    expect((0, _nHr.nHr)(0, 5)).toBeNaN();
-    expect((0, _nHr.nHr)(5, 0)).toBeNaN();
-  });
-  test("return NaN when n or r is negative", function () {
-    expect((0, _nHr.nHr)(-1, 5)).toBeNaN();
-    expect((0, _nHr.nHr)(5, -1)).toBeNaN();
+  describe("edge cases", function () {
+    it("should return NaN when n or r is 0", function () {
+      expect((0, _nHr.nHr)(0, 5)).toBeNaN();
+      expect((0, _nHr.nHr)(5, 0)).toBeNaN();
+      expect((0, _nHr.nHr)(0, 0)).toBeNaN();
+    });
+    it("should return NaN when n or r is negative", function () {
+      expect((0, _nHr.nHr)(-1, 5)).toBeNaN();
+      expect((0, _nHr.nHr)(5, -1)).toBeNaN();
+      expect((0, _nHr.nHr)(-1, -1)).toBeNaN();
+    });
   });
 });

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

@@ -2,20 +2,37 @@
 
 var _nPr = require("@/Math/nPr");
 describe("nPr function", function () {
-  // 正常系
-  test("calculate nPr for n=5, r=2", function () {
-    expect((0, _nPr.nPr)(5, 2)).toBe(20);
+  describe("valid permutations", function () {
+    it("should calculate basic permutations correctly", function () {
+      expect((0, _nPr.nPr)(5, 2)).toBe(20); // 5P2 = 20
+      expect((0, _nPr.nPr)(10, 4)).toBe(5040); // 10P4 = 5040
+    });
+    it("should handle choosing one item", function () {
+      expect((0, _nPr.nPr)(3, 1)).toBe(3); // 3P1 = 3
+      expect((0, _nPr.nPr)(5, 1)).toBe(5); // 5P1 = 5
+    });
+    it("should handle choosing all items", function () {
+      expect((0, _nPr.nPr)(3, 3)).toBe(6); // 3P3 = 6 (factorial of 3)
+      expect((0, _nPr.nPr)(4, 4)).toBe(24); // 4P4 = 24 (factorial of 4)
+    });
+    it("should handle larger permutations", function () {
+      expect((0, _nPr.nPr)(8, 3)).toBe(336); // 8P3 = 336
+      expect((0, _nPr.nPr)(6, 4)).toBe(360); // 6P4 = 360
+    });
   });
-  test("calculate nPr for n=10, r=4", function () {
-    expect((0, _nPr.nPr)(10, 4)).toBe(5040);
-  });
-
-  // 異常系
-  test("return NaN when n or r is 0", function () {
-    expect((0, _nPr.nPr)(0, 5)).toBeNaN();
-    expect((0, _nPr.nPr)(5, 0)).toBeNaN();
-  });
-  test("return NaN when n < r", function () {
-    expect((0, _nPr.nPr)(2, 5)).toBeNaN();
+  describe("edge cases", function () {
+    it("should return NaN when n or r is 0", function () {
+      expect((0, _nPr.nPr)(0, 5)).toBeNaN();
+      expect((0, _nPr.nPr)(5, 0)).toBeNaN();
+      expect((0, _nPr.nPr)(0, 0)).toBeNaN();
+    });
+    it("should return NaN when n is less than r", function () {
+      expect((0, _nPr.nPr)(2, 5)).toBeNaN();
+      expect((0, _nPr.nPr)(3, 4)).toBeNaN();
+    });
+    it("should calculate correctly when n equals r", function () {
+      expect((0, _nPr.nPr)(2, 2)).toBe(2); // 2P2 = 2
+      expect((0, _nPr.nPr)(5, 5)).toBe(120); // 5P5 = 120
+    });
   });
 });

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

@@ -1,13 +1,84 @@
 "use strict";
 
 var _primeFactorization = require("@/Math/primeFactorization");
-test("{primeFactorization}", function () {
-  var result = (0, _primeFactorization.primeFactorization)(100);
-  result.forEach(function (item) {
-    if (item.number === 2) {
-      expect(item.count).toBe(2);
-    } else if (item.number === 5) {
-      expect(item.count).toBe(2);
-    }
+describe("primeFactorization function", function () {
+  describe("basic prime factorization", function () {
+    it("should factorize numbers with single prime factor", function () {
+      expect((0, _primeFactorization.primeFactorization)(8)).toEqual([{
+        number: 2,
+        count: 3
+      }]);
+      expect((0, _primeFactorization.primeFactorization)(27)).toEqual([{
+        number: 3,
+        count: 3
+      }]);
+    });
+    it("should factorize numbers with multiple prime factors", function () {
+      expect((0, _primeFactorization.primeFactorization)(12)).toEqual([{
+        number: 2,
+        count: 2
+      }, {
+        number: 3,
+        count: 1
+      }]);
+      expect((0, _primeFactorization.primeFactorization)(100)).toEqual([{
+        number: 2,
+        count: 2
+      }, {
+        number: 5,
+        count: 2
+      }]);
+    });
+    it("should handle prime numbers", function () {
+      expect((0, _primeFactorization.primeFactorization)(2)).toEqual([{
+        number: 2,
+        count: 1
+      }]);
+      expect((0, _primeFactorization.primeFactorization)(17)).toEqual([{
+        number: 17,
+        count: 1
+      }]);
+      expect((0, _primeFactorization.primeFactorization)(31)).toEqual([{
+        number: 31,
+        count: 1
+      }]);
+    });
+  });
+  describe("edge cases", function () {
+    it("should handle perfect squares", function () {
+      expect((0, _primeFactorization.primeFactorization)(25)).toEqual([{
+        number: 5,
+        count: 2
+      }]);
+      expect((0, _primeFactorization.primeFactorization)(49)).toEqual([{
+        number: 7,
+        count: 2
+      }]);
+    });
+    it("should handle numbers with large prime factors", function () {
+      expect((0, _primeFactorization.primeFactorization)(997)).toEqual([{
+        number: 997,
+        count: 1
+      }]);
+      expect((0, _primeFactorization.primeFactorization)(998)).toEqual([{
+        number: 2,
+        count: 1
+      }, {
+        number: 499,
+        count: 1
+      }]);
+    });
+    it("should handle consecutive prime factors", function () {
+      expect((0, _primeFactorization.primeFactorization)(30)).toEqual([{
+        number: 2,
+        count: 1
+      }, {
+        number: 3,
+        count: 1
+      }, {
+        number: 5,
+        count: 1
+      }]);
+    });
   });
 });

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

@@ -1,14 +1,36 @@
 "use strict";
 
 var _quotient = require("@/Math/quotient");
-test("{quotient}", function () {
-  expect((0, _quotient.quotient)(1, 1)).toEqual([1, 0]);
-  expect((0, _quotient.quotient)(1, 2)).toEqual([0, 1]);
-  expect((0, _quotient.quotient)(2, 1)).toEqual([2, 0]);
-  expect((0, _quotient.quotient)(2, 2)).toEqual([1, 0]);
-  expect((0, _quotient.quotient)(2, 3)).toEqual([0, 2]);
-  expect((0, _quotient.quotient)(3, 1)).toEqual([3, 0]);
-  expect((0, _quotient.quotient)(3, 2)).toEqual([1, 1]);
-  expect((0, _quotient.quotient)(3, 3)).toEqual([1, 0]);
-  expect((0, _quotient.quotient)(3, 4)).toEqual([0, 3]);
+describe("quotient function", function () {
+  describe("basic division", function () {
+    it("should handle exact division (no remainder)", function () {
+      expect((0, _quotient.quotient)(4, 2)).toEqual([2, 0]);
+      expect((0, _quotient.quotient)(10, 5)).toEqual([2, 0]);
+      expect((0, _quotient.quotient)(100, 10)).toEqual([10, 0]);
+    });
+    it("should handle division with remainder", function () {
+      expect((0, _quotient.quotient)(5, 2)).toEqual([2, 1]);
+      expect((0, _quotient.quotient)(7, 3)).toEqual([2, 1]);
+      expect((0, _quotient.quotient)(10, 3)).toEqual([3, 1]);
+    });
+  });
+  describe("edge cases", function () {
+    it("should handle division by 1", function () {
+      expect((0, _quotient.quotient)(5, 1)).toEqual([5, 0]);
+      expect((0, _quotient.quotient)(0, 1)).toEqual([0, 0]);
+    });
+    it("should handle when dividend is smaller than divisor", function () {
+      expect((0, _quotient.quotient)(2, 5)).toEqual([0, 2]);
+      expect((0, _quotient.quotient)(1, 10)).toEqual([0, 1]);
+    });
+    it("should handle negative numbers", function () {
+      expect((0, _quotient.quotient)(-5, 2)).toEqual([-2, -1]);
+      expect((0, _quotient.quotient)(5, -2)).toEqual([-2, 1]);
+      expect((0, _quotient.quotient)(-5, -2)).toEqual([2, -1]);
+    });
+    it("should handle large numbers", function () {
+      expect((0, _quotient.quotient)(1000, 3)).toEqual([333, 1]);
+      expect((0, _quotient.quotient)(9999, 10)).toEqual([999, 9]);
+    });
+  });
 });