umt 2.1.2 → 2.2.1

package/module/es5/tests/unit/Validate/isNumber.test.js

@@ -1,39 +1,77 @@
 "use strict";
 
 var _isNumber = require("@/Validate/isNumber");
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
 describe("isNumber", function () {
-  // 引数が数値であるケース
-  test("should return true when a number is provided", function () {
-    expect((0, _isNumber.isNumber)(5)).toBe(true);
+  describe("integers and decimals", function () {
+    test("should return true for integer numbers", function () {
+      expect((0, _isNumber.isNumber)(5)).toBe(true);
+      expect((0, _isNumber.isNumber)(-5)).toBe(true);
+      expect((0, _isNumber.isNumber)(0)).toBe(true);
+    });
+    test("should return true for decimal numbers", function () {
+      expect((0, _isNumber.isNumber)(5.5)).toBe(true);
+      expect((0, _isNumber.isNumber)(-5.5)).toBe(true);
+      expect((0, _isNumber.isNumber)(0.0)).toBe(true);
+    });
   });
-
-  // 引数が文字列であるが、数値に変換可能なケース
-  test("should return true when a string of a number is provided (loose mode)", function () {
-    expect((0, _isNumber.isNumber)("5", true)).toBe(true);
-  });
-
-  // 引数が文字列であるが、数値に変換不可能なケース
-  test("should return false when a non-numeric string is provided", function () {
-    expect((0, _isNumber.isNumber)("abc", true)).toBe(false);
-  });
-
-  // 引数がnullであるケース
-  test("should return false when null is provided", function () {
-    expect((0, _isNumber.isNumber)(null)).toBe(false);
+  describe("string representations (loose mode)", function () {
+    test("should return true for valid number strings when loose is true", function () {
+      expect((0, _isNumber.isNumber)("5", true)).toBe(true);
+      expect((0, _isNumber.isNumber)("-5.5", true)).toBe(true);
+      expect((0, _isNumber.isNumber)("0", true)).toBe(true);
+    });
+    test("should return false for invalid number strings", function () {
+      expect((0, _isNumber.isNumber)("abc", true)).toBe(false);
+      expect((0, _isNumber.isNumber)("5abc", true)).toBe(false);
+    });
+    test("should return false for number strings when loose is false", function () {
+      expect((0, _isNumber.isNumber)("5", false)).toBe(false);
+      expect((0, _isNumber.isNumber)("-5.5", false)).toBe(false);
+    });
+    test("should handle empty string", function () {
+      expect((0, _isNumber.isNumber)("")).toBe(true); // Due to isFinite("") returning true
+    });
   });
-
-  // 引数がbooleanであるケース
-  test("should return false when a boolean is provided", function () {
-    expect((0, _isNumber.isNumber)(true)).toBe(false);
+  describe("special number values", function () {
+    test("should return false for NaN", function () {
+      expect((0, _isNumber.isNumber)(Number.NaN)).toBe(false);
+    });
+    test("should return false for Infinity", function () {
+      expect((0, _isNumber.isNumber)(Number.POSITIVE_INFINITY)).toBe(false);
+      expect((0, _isNumber.isNumber)(Number.NEGATIVE_INFINITY)).toBe(false);
+    });
   });
-
-  // 引数が文字列であるが、looseモードがオフのケース
-  test("should return false when a string is provided and loose mode is off", function () {
-    expect((0, _isNumber.isNumber)("5", false)).toBe(false);
+  describe("non-number types", function () {
+    test("should return false for null and undefined", function () {
+      expect((0, _isNumber.isNumber)(null)).toBe(false);
+      expect((0, _isNumber.isNumber)(undefined)).toBe(false);
+    });
+    test("should return false for booleans", function () {
+      expect((0, _isNumber.isNumber)(true)).toBe(false);
+      expect((0, _isNumber.isNumber)(false)).toBe(false);
+    });
+    test("should return false for objects and arrays", function () {
+      expect((0, _isNumber.isNumber)({})).toBe(false);
+      expect((0, _isNumber.isNumber)([])).toBe(false);
+    });
   });
-
-  // 空文字列が引数として渡されたケース
-  test("should return false when an empty string is provided", function () {
-    expect((0, _isNumber.isNumber)("")).toBe(true);
+  describe("type guard functionality", function () {
+    test("should work as a type guard in loose mode", function () {
+      var value = "123";
+      if ((0, _isNumber.isNumber)(value)) {
+        // TypeScript should recognize value as number | string
+        expect(typeof value === "string" || typeof value === "number").toBe(true);
+        expect(Number(value)).toBe(123);
+      }
+    });
+    test("should work as a type guard in strict mode", function () {
+      var value = 123;
+      if ((0, _isNumber.isNumber)(value, false)) {
+        // TypeScript should recognize value as number
+        expect(_typeof(value)).toBe("number");
+        expect(value).toBe(123);
+      }
+    });
   });
 });

package/module/es5/tests/unit/Validate/isPerfectSquare.test.js

@@ -19,4 +19,9 @@ describe("isPerfectSquare", function () {
     expect((0, _isPerfectSquare.isPerfectSquare)(100000000)).toBe(true);
     expect((0, _isPerfectSquare.isPerfectSquare)(100000002)).toBe(false);
   });
+  it("should handle non-integer numbers", function () {
+    expect((0, _isPerfectSquare.isPerfectSquare)(4.0)).toBe(true); // 4.0 is treated as integer 4
+    expect((0, _isPerfectSquare.isPerfectSquare)(4.5)).toBe(false);
+    expect((0, _isPerfectSquare.isPerfectSquare)(2.25)).toBe(false);
+  });
 });

package/module/es5/tests/unit/Validate/isPrimeNumber.test.js

@@ -30,12 +30,22 @@ describe("isPrimeNumber", function () {
     expect((0, _isPrimeNumber.isPrimeNumber)(16)).toBe(false);
     expect((0, _isPrimeNumber.isPrimeNumber)(18)).toBe(false);
   });
-  test("should return false for large non-prime number", function () {
-    var largeNonPrimeNumber = 10000000000000;
+  test("should return false for negative numbers", function () {
+    expect((0, _isPrimeNumber.isPrimeNumber)(-2)).toBe(false);
+    expect((0, _isPrimeNumber.isPrimeNumber)(-7)).toBe(false);
+    expect((0, _isPrimeNumber.isPrimeNumber)(-11)).toBe(false);
+  });
+  test("should return false for non-integer numbers", function () {
+    expect((0, _isPrimeNumber.isPrimeNumber)(2.5)).toBe(false);
+    expect((0, _isPrimeNumber.isPrimeNumber)(3.14)).toBe(false);
+    expect((0, _isPrimeNumber.isPrimeNumber)(7.0)).toBe(true); // 7.0 is treated as integer 7
+  });
+  test("should handle large non-prime numbers", function () {
+    var largeNonPrimeNumber = 10000000000000; // 10^13
     expect((0, _isPrimeNumber.isPrimeNumber)(largeNonPrimeNumber)).toBe(false);
   });
-  test("should return true for large prime number", function () {
-    var largePrimeNumber = 982451653; // This is a known large prime number
+  test("should handle large prime numbers", function () {
+    var largePrimeNumber = 982451653; // 982,451,653 is a known prime number
     expect((0, _isPrimeNumber.isPrimeNumber)(largePrimeNumber)).toBe(true);
   });
 });

package/module/es5/tests/unit/Validate/isValueNaN.test.js

@@ -1,15 +1,54 @@
 "use strict";
 
 var _isValueNaN = require("@/Validate/isValueNaN");
-test("{isValueNaN}", function () {
-  expect((0, _isValueNaN.isValueNaN)(0)).toBe(false);
-  expect((0, _isValueNaN.isValueNaN)(0, true)).toBe(false);
-  expect((0, _isValueNaN.isValueNaN)(NaN)).toBe(true);
-  expect((0, _isValueNaN.isValueNaN)(NaN, true)).toBe(true);
-  expect((0, _isValueNaN.isValueNaN)("NaN")).toBe(false);
-  expect((0, _isValueNaN.isValueNaN)("NaN", true)).toBe(true);
-  expect((0, _isValueNaN.isValueNaN)("0")).toBe(false);
-  expect((0, _isValueNaN.isValueNaN)("0", true)).toBe(false);
-  expect((0, _isValueNaN.isValueNaN)("a")).toBe(false);
-  expect((0, _isValueNaN.isValueNaN)("a", true)).toBe(true);
+describe("isValueNaN function", function () {
+  describe("strict mode (loose = false)", function () {
+    it("should return false for valid numbers", function () {
+      expect((0, _isValueNaN.isValueNaN)(0)).toBe(false);
+      expect((0, _isValueNaN.isValueNaN)(1)).toBe(false);
+      expect((0, _isValueNaN.isValueNaN)(-1)).toBe(false);
+      expect((0, _isValueNaN.isValueNaN)(Number.POSITIVE_INFINITY)).toBe(false);
+    });
+    it("should return true for NaN", function () {
+      expect((0, _isValueNaN.isValueNaN)(Number.NaN)).toBe(true);
+      expect((0, _isValueNaN.isValueNaN)(Number.parseInt("not a number"))).toBe(true);
+    });
+    it("should return false for string values", function () {
+      expect((0, _isValueNaN.isValueNaN)("NaN")).toBe(false);
+      expect((0, _isValueNaN.isValueNaN)("0")).toBe(false);
+      expect((0, _isValueNaN.isValueNaN)("a")).toBe(false);
+      expect((0, _isValueNaN.isValueNaN)("")).toBe(false);
+    });
+    it("should return false for non-number types", function () {
+      expect((0, _isValueNaN.isValueNaN)(undefined)).toBe(false);
+      expect((0, _isValueNaN.isValueNaN)(null)).toBe(false);
+      expect((0, _isValueNaN.isValueNaN)({})).toBe(false);
+      expect((0, _isValueNaN.isValueNaN)([])).toBe(false);
+    });
+  });
+  describe("loose mode (loose = true)", function () {
+    it("should return false for valid number strings", function () {
+      expect((0, _isValueNaN.isValueNaN)("0", true)).toBe(false);
+      expect((0, _isValueNaN.isValueNaN)("1", true)).toBe(false);
+      expect((0, _isValueNaN.isValueNaN)("-1", true)).toBe(false);
+      expect((0, _isValueNaN.isValueNaN)("Infinity", true)).toBe(false);
+    });
+    it("should return true for NaN and NaN strings", function () {
+      expect((0, _isValueNaN.isValueNaN)(Number.NaN, true)).toBe(true);
+      expect((0, _isValueNaN.isValueNaN)("NaN", true)).toBe(true);
+      expect((0, _isValueNaN.isValueNaN)(Number.parseInt("not a number"), true)).toBe(true);
+    });
+    it("should handle non-numeric strings correctly", function () {
+      expect((0, _isValueNaN.isValueNaN)("a", true)).toBe(true);
+      expect((0, _isValueNaN.isValueNaN)("abc", true)).toBe(true);
+      expect((0, _isValueNaN.isValueNaN)("", true)).toBe(false); // isNaN("") returns false
+      expect((0, _isValueNaN.isValueNaN)(" ", true)).toBe(false); // isNaN(" ") returns false (coerced to 0)
+    });
+    it("should handle non-string/non-number types", function () {
+      expect((0, _isValueNaN.isValueNaN)(undefined, true)).toBe(true);
+      expect((0, _isValueNaN.isValueNaN)(null, true)).toBe(false);
+      expect((0, _isValueNaN.isValueNaN)({}, true)).toBe(true);
+      expect((0, _isValueNaN.isValueNaN)([], true)).toBe(false);
+    });
+  });
 });

package/module/es5/tests/unit/Validate/string/uuid.test.js

@@ -3,7 +3,7 @@
 var _Validate = require("@/Validate");
 var _uuid = require("@/Validate/string/uuid");
 describe("uuid", function () {
-  it("有効なUUIDを検証する", function () {
+  it("should validate valid UUIDs", function () {
     var validateUUID = (0, _uuid.uuid)();
     expect(validateUUID.validate("123e4567-e89b-42d3-a456-426614174000")).toBe(true);
     expect(validateUUID.validate("3A86B1AB-237E-473D-A38F-06AA6A2A4783")).toBe(true);
@@ -18,54 +18,54 @@ describe("uuid", function () {
     expect(validateUUID.validate("A95E3F62-2D0E-4257-95D3-B239AF08115D")).toBe(true);
     expect(validateUUID.validate("A95E3F622D0E425795D3B239AF08115D")).toBe(true);
   });
-  it("無効なUUIDを検証する", function () {
+  it("should reject invalid UUIDs", function () {
     var validateUUID = (0, _uuid.uuid)();
     expect(validateUUID.validate("123e4567-e89b-42d3-a456-42661417400Z")).toBe(false);
     expect(validateUUID.validate("123e4567-e89b-92d3-a456-426614174000")).toBe(false);
   });
-  it("カスタムメッセージを持つ有効なUUIDを検証する", function () {
+  it("should validate valid UUID with custom message", function () {
     var validUUID = "123e4567-e89b-42d3-a456-426614174000";
-    var customMessage = "UUIDが無効です";
+    var customMessage = "Invalid UUID format";
     var validateUUID = (0, _Validate.string)([(0, _uuid.uuid)([4], customMessage)]);
     expect(validateUUID(validUUID).validate).toBe(true);
     expect(validateUUID(validUUID).message).toBe("");
   });
-  it("カスタムメッセージを持つ無効なUUIDを検証する", function () {
+  it("should reject invalid UUID with custom message", function () {
     var invalidUUID = "123e4567-e89b-12d3-a456-42661417400Z";
-    var customMessage = "UUIDが無効です";
+    var customMessage = "Invalid UUID format";
     var validateUUID = (0, _Validate.string)([(0, _uuid.uuid)([4], customMessage)]);
     expect(validateUUID(invalidUUID).validate).toBe(false);
     expect(validateUUID(invalidUUID).message).toBe(customMessage);
   });
-  it("大文字と小文字が混在する有効なUUIDを検証する", function () {
+  it("should validate UUIDs with mixed case letters", function () {
     var validateUUID = (0, _uuid.uuid)();
     expect(validateUUID.validate("123e4567-E89b-42D3-a456-426614174000")).toBe(true);
   });
-  it("UUIDのバージョンが異なる場合を検証する", function () {
+  it("should validate different UUID versions", function () {
     var validateUUID = (0, _uuid.uuid)([1, 2, 3, 4, 5]);
     expect(validateUUID.validate("123e4567-e89b-12d3-a456-426614174000")).toBe(true);
     expect(validateUUID.validate("123e4567-e89b-22d3-a456-426614174000")).toBe(true);
     expect(validateUUID.validate("123e4567-e89b-32d3-a456-426614174000")).toBe(true);
     expect(validateUUID.validate("123e4567-e89b-52d3-a456-426614174000")).toBe(true);
   });
-  it("UUIDの形式が完全に異なる文字列を検証する", function () {
+  it("should reject completely invalid UUID formats", function () {
     var validateUUID = (0, _uuid.uuid)();
     expect(validateUUID.validate("completely-invalid-format")).toBe(false);
   });
-  it("空文字列を検証する", function () {
+  it("should reject empty strings", function () {
     var validateUUID = (0, _uuid.uuid)();
     expect(validateUUID.validate("")).toBe(false);
   });
-  it("nullを検証する", function () {
+  it("should reject null values", function () {
     var validateUUID = (0, _uuid.uuid)();
     // @ts-ignore
     expect(validateUUID.validate(null)).toBe(false);
   });
-  it("UUIDの長さが不足している場合を検証する", function () {
+  it("should reject UUIDs with insufficient length", function () {
     var validateUUID = (0, _uuid.uuid)();
     expect(validateUUID.validate("123e4567-e89b-42d3-a456-42661417400")).toBe(false);
   });
-  it("UUIDの長さが超過している場合を検証する", function () {
+  it("should reject UUIDs with excessive length", function () {
     var validateUUID = (0, _uuid.uuid)();
     expect(validateUUID.validate("123e4567-e89b-42d3-a456-4266141740001234")).toBe(false);
   });