umt 1.9.0 → 2.1.0

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

@@ -0,0 +1,41 @@
+"use strict";
+
+var _isPrimeNumber = require("@/Validate/isPrimeNumber");
+describe("isPrimeNumber", function () {
+  test("returns false for numbers less than or equal to 1", function () {
+    expect((0, _isPrimeNumber.isPrimeNumber)(0)).toBe(false);
+    expect((0, _isPrimeNumber.isPrimeNumber)(1)).toBe(false);
+  });
+  test("returns true for prime numbers", function () {
+    expect((0, _isPrimeNumber.isPrimeNumber)(2)).toBe(true);
+    expect((0, _isPrimeNumber.isPrimeNumber)(3)).toBe(true);
+    expect((0, _isPrimeNumber.isPrimeNumber)(5)).toBe(true);
+    expect((0, _isPrimeNumber.isPrimeNumber)(7)).toBe(true);
+    expect((0, _isPrimeNumber.isPrimeNumber)(11)).toBe(true);
+    expect((0, _isPrimeNumber.isPrimeNumber)(13)).toBe(true);
+    expect((0, _isPrimeNumber.isPrimeNumber)(17)).toBe(true);
+    expect((0, _isPrimeNumber.isPrimeNumber)(19)).toBe(true);
+    expect((0, _isPrimeNumber.isPrimeNumber)(23)).toBe(true);
+    expect((0, _isPrimeNumber.isPrimeNumber)(29)).toBe(true);
+  });
+  test("returns false for composite numbers", function () {
+    expect((0, _isPrimeNumber.isPrimeNumber)(4)).toBe(false);
+    expect((0, _isPrimeNumber.isPrimeNumber)(6)).toBe(false);
+    expect((0, _isPrimeNumber.isPrimeNumber)(8)).toBe(false);
+    expect((0, _isPrimeNumber.isPrimeNumber)(9)).toBe(false);
+    expect((0, _isPrimeNumber.isPrimeNumber)(10)).toBe(false);
+    expect((0, _isPrimeNumber.isPrimeNumber)(12)).toBe(false);
+    expect((0, _isPrimeNumber.isPrimeNumber)(14)).toBe(false);
+    expect((0, _isPrimeNumber.isPrimeNumber)(15)).toBe(false);
+    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;
+    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
+    expect((0, _isPrimeNumber.isPrimeNumber)(largePrimeNumber)).toBe(true);
+  });
+});

package/module/es5/tests/unit/Validate/isValueNaN.test.d.ts

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

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

@@ -0,0 +1,15 @@
+"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);
+});

package/module/es5/tests/unit/Validate/number/core.test.d.ts

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

package/module/es5/tests/unit/Validate/number/core.test.js

@@ -0,0 +1,36 @@
+"use strict";
+
+var _core = require("@/Validate/number/core");
+var _maxValue = require("@/Validate/number/maxValue");
+var _minValue = require("@/Validate/number/minValue");
+describe("number function", function () {
+  it("should validate number with no additional options", function () {
+    var validateNumber = (0, _core.number)();
+    expect(validateNumber(5).validate).toBeTruthy();
+    // @ts-ignore
+    expect(validateNumber("5").validate).toBeFalsy();
+  });
+  it("should validate number with max value option", function () {
+    var validateNumberMax = (0, _core.number)([(0, _maxValue.maxValue)(10)]);
+    expect(validateNumberMax(5).validate).toBeTruthy();
+    expect(validateNumberMax(11).validate).toBeFalsy();
+  });
+  it("should validate number with min value option", function () {
+    var validateNumberMin = (0, _core.number)([(0, _minValue.minValue)(3)]);
+    expect(validateNumberMin(5).validate).toBeTruthy();
+    expect(validateNumberMin(2).validate).toBeFalsy();
+  });
+  it("should validate number with both min and max value options", function () {
+    var validateNumberMinMax = (0, _core.number)([(0, _minValue.minValue)(3), (0, _maxValue.maxValue)(10)]);
+    expect(validateNumberMinMax(5).validate).toBeTruthy();
+    expect(validateNumberMinMax(2).validate).toBeFalsy();
+    expect(validateNumberMinMax(11).validate).toBeFalsy();
+  });
+  it("should return custom message on validation failure", function () {
+    var customMessage = "Value must be between 3 and 10";
+    var validateNumberMinMax = (0, _core.number)([(0, _minValue.minValue)(3, customMessage), (0, _maxValue.maxValue)(10)]);
+    var result = validateNumberMinMax(2);
+    expect(result.validate).toBeFalsy();
+    expect(result.message).toBe(customMessage);
+  });
+});

package/module/es5/tests/unit/Validate/number/double.test.d.ts

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

package/module/es5/tests/unit/Validate/number/double.test.js

@@ -0,0 +1,23 @@
+"use strict";
+
+var _double2 = require("@/Validate/number/double");
+describe("double", function () {
+  it("should return true for double numbers", function () {
+    var validateDouble = (0, _double2["double"])();
+    expect(validateDouble.validate(1.5)).toBe(true);
+    expect(validateDouble.validate(2.22)).toBe(true);
+    expect(validateDouble.validate(0.1)).toBe(true);
+  });
+  it("should return false for non-double numbers", function () {
+    var validateDouble = (0, _double2["double"])();
+    expect(validateDouble.validate(1)).toBe(false);
+    expect(validateDouble.validate(100)).toBe(false);
+    expect(validateDouble.validate(0)).toBe(false);
+  });
+  it("should return the custom message for invalid input", function () {
+    var customMessage = "This is not a double number";
+    var validateDouble = (0, _double2["double"])(customMessage);
+    expect(validateDouble.validate(1)).toBe(false);
+    expect(validateDouble.message).toBe(customMessage);
+  });
+});

package/module/es5/tests/unit/Validate/number/even.test.d.ts

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

package/module/es5/tests/unit/Validate/number/even.test.js

@@ -0,0 +1,23 @@
+"use strict";
+
+var _even = require("@/Validate/number/even");
+describe("even", function () {
+  it("should return true for even numbers", function () {
+    var validateEven = (0, _even.even)();
+    expect(validateEven.validate(2)).toBe(true);
+    expect(validateEven.validate(4)).toBe(true);
+    expect(validateEven.validate(6)).toBe(true);
+  });
+  it("should return false for odd numbers", function () {
+    var validateEven = (0, _even.even)();
+    expect(validateEven.validate(1)).toBe(false);
+    expect(validateEven.validate(3)).toBe(false);
+    expect(validateEven.validate(5)).toBe(false);
+  });
+  it("should return the custom message for invalid input", function () {
+    var customMessage = "This is a custom message";
+    var validateEven = (0, _even.even)(customMessage);
+    expect(validateEven.validate(1)).toBe(false);
+    expect(validateEven.message).toBe(customMessage);
+  });
+});

package/module/es5/tests/unit/Validate/number/maxValue.test.d.ts

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

package/module/es5/tests/unit/Validate/number/maxValue.test.js

@@ -0,0 +1,20 @@
+"use strict";
+
+var _maxValue = require("@/Validate/number/maxValue");
+describe("maxValue", function () {
+  it("should return true for numbers less than or equal to the max value", function () {
+    var validateMaxValue = (0, _maxValue.maxValue)(10);
+    expect(validateMaxValue.validate(5)).toBe(true);
+    expect(validateMaxValue.validate(10)).toBe(true);
+  });
+  it("should return false for numbers greater than the max value", function () {
+    var validateMaxValue = (0, _maxValue.maxValue)(10);
+    expect(validateMaxValue.validate(11)).toBe(false);
+  });
+  it("should return the custom message for invalid input", function () {
+    var customMessage = "Value must be less than or equal to 10";
+    var validateMaxValue = (0, _maxValue.maxValue)(10, customMessage);
+    expect(validateMaxValue.validate(11)).toBe(false);
+    expect(validateMaxValue.message).toBe(customMessage);
+  });
+});

package/module/es5/tests/unit/Validate/number/minValue.test.d.ts

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

package/module/es5/tests/unit/Validate/number/minValue.test.js

@@ -0,0 +1,20 @@
+"use strict";
+
+var _minValue = require("@/Validate/number/minValue");
+describe("minValue", function () {
+  it("should return true for numbers greater than or equal to the minimum value", function () {
+    var validateMinValue = (0, _minValue.minValue)(10);
+    expect(validateMinValue.validate(10)).toBe(true);
+    expect(validateMinValue.validate(15)).toBe(true);
+  });
+  it("should return false for numbers less than the minimum value", function () {
+    var validateMinValue = (0, _minValue.minValue)(10);
+    expect(validateMinValue.validate(9)).toBe(false);
+  });
+  it("should return the custom message for invalid input", function () {
+    var customMessage = "Value must be at least 10";
+    var validateMinValue = (0, _minValue.minValue)(10, customMessage);
+    expect(validateMinValue.validate(9)).toBe(false);
+    expect(validateMinValue.message).toBe(customMessage);
+  });
+});

package/module/es5/tests/unit/Validate/number/odd.test.d.ts

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

package/module/es5/tests/unit/Validate/number/odd.test.js

@@ -0,0 +1,23 @@
+"use strict";
+
+var _odd = require("@/Validate/number/odd");
+describe("odd", function () {
+  it("should return true for odd numbers", function () {
+    var validateOdd = (0, _odd.odd)();
+    expect(validateOdd.validate(1)).toBe(true);
+    expect(validateOdd.validate(3)).toBe(true);
+    expect(validateOdd.validate(5)).toBe(true);
+  });
+  it("should return false for even numbers", function () {
+    var validateOdd = (0, _odd.odd)();
+    expect(validateOdd.validate(2)).toBe(false);
+    expect(validateOdd.validate(4)).toBe(false);
+    expect(validateOdd.validate(6)).toBe(false);
+  });
+  it("should return the custom message for invalid input", function () {
+    var customMessage = "This is a custom message";
+    var validateOdd = (0, _odd.odd)(customMessage);
+    expect(validateOdd.validate(2)).toBe(false);
+    expect(validateOdd.message).toBe(customMessage);
+  });
+});

package/module/es5/tests/unit/Validate/number/prime.test.d.ts

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

package/module/es5/tests/unit/Validate/number/prime.test.js

@@ -0,0 +1,25 @@
+"use strict";
+
+var _prime = require("@/Validate/number/prime");
+describe("prime", function () {
+  it("should return true for prime numbers", function () {
+    var validatePrime = (0, _prime.prime)();
+    expect(validatePrime.validate(2)).toBe(true);
+    expect(validatePrime.validate(3)).toBe(true);
+    expect(validatePrime.validate(5)).toBe(true);
+    expect(validatePrime.validate(7)).toBe(true);
+  });
+  it("should return false for non-prime numbers", function () {
+    var validatePrime = (0, _prime.prime)();
+    expect(validatePrime.validate(4)).toBe(false);
+    expect(validatePrime.validate(6)).toBe(false);
+    expect(validatePrime.validate(8)).toBe(false);
+    expect(validatePrime.validate(9)).toBe(false);
+  });
+  it("should return the custom message for invalid input", function () {
+    var customMessage = "This is not a prime number";
+    var validatePrime = (0, _prime.prime)(customMessage);
+    expect(validatePrime.validate(4)).toBe(false);
+    expect(validatePrime.message).toBe(customMessage);
+  });
+});

package/module/es5/tests/unit/Validate/object/core.test.d.ts

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

package/module/es5/tests/unit/Validate/object/core.test.js

@@ -0,0 +1,79 @@
+"use strict";
+
+var _Validate = require("@/Validate");
+var _number = require("@/Validate/number");
+var _core = require("@/Validate/object/core");
+var _string = require("@/Validate/string");
+describe("object validation", function () {
+  it("should validate an object with string type", function () {
+    var validateObject = (0, _core.object)();
+    var invalidData = {
+      name: "John Doe",
+      age: "thirty"
+    };
+    // @ts-ignore
+    var result = validateObject(invalidData);
+    expect(result.validate).toBe(true);
+  });
+  it("should validate an object with string and number types", function () {
+    var validateObject = (0, _core.object)({
+      name: (0, _string.string)([], "string"),
+      age: (0, _number.number)([], "number"),
+      array: (0, _Validate.array)({
+        string: (0, _string.string)([], "string"),
+        number: (0, _number.number)([], "number")
+      }, "array")
+    }, "object");
+    var validData = {
+      name: "John Doe",
+      age: 30,
+      array: ["John Doe", 30]
+    };
+    var invalidData = {
+      name: "John Doe",
+      age: "thirty"
+    };
+    expect(validateObject(validData).message).toBe("");
+    expect(validateObject(validData).validate).toBe(true);
+    // @ts-ignore
+    expect(validateObject(invalidData).validate).toBe(false);
+  });
+  it("should return a custom message on number validation failure", function () {
+    var customMessage = "Invalid object structure";
+    var validateObject = (0, _core.object)({
+      name: (0, _string.string)(),
+      age: (0, _number.number)([], customMessage)
+    });
+    var invalidData = {
+      name: "John Doe",
+      age: "thirty"
+    };
+    // @ts-ignore
+    var result = validateObject(invalidData);
+    expect(result.validate).toBe(false);
+    expect(result.message).toBe(customMessage);
+  });
+  it("should return a custom message on validation failure", function () {
+    var customMessage = "Invalid object structure";
+    var validateObject = (0, _core.object)({
+      name: (0, _string.string)(),
+      age: (0, _number.number)()
+    }, customMessage);
+    var invalidData = "John Doe";
+    // @ts-ignore
+    var result = validateObject(invalidData);
+    expect(result.validate).toBe(false);
+    expect(result.message).toBe(customMessage);
+  });
+  it("should return an empty message on validation failure", function () {
+    var validateObject = (0, _core.object)({
+      name: (0, _string.string)(),
+      age: (0, _number.number)()
+    });
+    var invalidData = "John Doe";
+    // @ts-ignore
+    var result = validateObject(invalidData);
+    expect(result.validate).toBe(false);
+    expect(result.message).toBe("");
+  });
+});

package/module/es5/tests/unit/Validate/string/core.test.d.ts

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

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

@@ -0,0 +1,27 @@
+"use strict";
+
+var _string = require("@/Validate/string");
+describe("string validation", function () {
+  it("string", function () {
+    var validateString = (0, _string.string)();
+    expect(validateString("").validate).toBeTruthy();
+    expect(validateString("abc").validate).toBeTruthy();
+    // @ts-expect-error
+    expect(validateString(123).validate).toBeFalsy();
+  });
+  it("string with message", function () {
+    var validateStringWithMessage = (0, _string.string)([], "Must be string");
+    expect(validateStringWithMessage("").message).toEqual("");
+    expect(validateStringWithMessage("abc").validate).toBeTruthy();
+    // @ts-expect-error
+    expect(validateStringWithMessage(123).validate).toBeFalsy();
+  });
+  it("can specify the maximum and minimum number of characters", function () {
+    var validateString = (0, _string.string)([(0, _string.minLength)(3), (0, _string.maxLength)(5)]);
+    expect(validateString("ab").validate).toBeFalsy();
+    expect(validateString("abc").validate).toBeTruthy();
+    expect(validateString("abcde").validate).toBeTruthy();
+    expect(validateString("abcdef").validate).toBeFalsy();
+    expect(validateString("abcdefg").validate).toBeFalsy();
+  });
+});

package/module/es5/tests/unit/Validate/string/email.test.d.ts

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

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

@@ -0,0 +1,21 @@
+"use strict";
+
+var _Validate = require("@/Validate");
+var _email = require("@/Validate/string/email");
+describe("email", function () {
+  it("email with message", function () {
+    var emailValidatorWithMessage = (0, _email.email)("Invalid email format");
+    var validateEmailWithMessage = (0, _Validate.string)([emailValidatorWithMessage]);
+    expect(validateEmailWithMessage("user@example.com").message).toEqual("");
+    expect(validateEmailWithMessage("user@example.com").validate).toBeTruthy();
+    expect(validateEmailWithMessage("userexample.com").message).toEqual("Invalid email format");
+    expect(validateEmailWithMessage("userexample.com").validate).toBeFalsy();
+  });
+  it("email without message", function () {
+    var emailValidatorWithoutMessage = (0, _email.email)();
+    var validateEmailWithoutMessage = (0, _Validate.string)([emailValidatorWithoutMessage]);
+    expect(validateEmailWithoutMessage("user@example.com").message).toEqual("");
+    expect(validateEmailWithoutMessage("user@example.com").validate).toBeTruthy();
+    expect(validateEmailWithoutMessage("userexample.com").validate).toBeFalsy();
+  });
+});

package/module/es5/tests/unit/Validate/string/length.test.d.ts

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

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

@@ -0,0 +1,18 @@
+"use strict";
+
+var _string = require("@/Validate/string");
+describe("length", function () {
+  it("length with message", function () {
+    var lengthValidatorWithMessage = (0, _string.length_)(3, "Length must be 3");
+    var validateStringWithMessage = (0, _string.string)([lengthValidatorWithMessage]);
+    expect(validateStringWithMessage("abcd").message).toEqual("Length must be 3");
+    expect(validateStringWithMessage("abc").validate).toBeTruthy();
+    expect(validateStringWithMessage("ab").validate).toBeFalsy();
+  });
+  it("length without message", function () {
+    var lengthValidatorWithoutMessage = (0, _string.length_)(3);
+    var validateStringWithoutMessage = (0, _string.string)([lengthValidatorWithoutMessage]);
+    expect(validateStringWithoutMessage("abc").message).toEqual("");
+    expect(validateStringWithoutMessage("abcd").validate).toBeFalsy();
+  });
+});

package/module/es5/tests/unit/Validate/string/maxLength.test.d.ts

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

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

@@ -0,0 +1,18 @@
+"use strict";
+
+var _string = require("@/Validate/string");
+describe("maxLength", function () {
+  it("maxLength with message", function () {
+    var maxLengthValidatorWithMessage = (0, _string.maxLength)(3, "Maximum length is 3");
+    var validateStringWithMessage = (0, _string.string)([maxLengthValidatorWithMessage]);
+    expect(validateStringWithMessage("abcd").message).toEqual("Maximum length is 3");
+    expect(validateStringWithMessage("abc").validate).toBeTruthy();
+    expect(validateStringWithMessage("ab").validate).toBeTruthy();
+  });
+  it("maxLength without message", function () {
+    var maxLengthValidatorWithoutMessage = (0, _string.maxLength)(3);
+    var validateStringWithoutMessage = (0, _string.string)([maxLengthValidatorWithoutMessage]);
+    expect(validateStringWithoutMessage("abc").message).toEqual("");
+    expect(validateStringWithoutMessage("abcd").validate).toBeFalsy();
+  });
+});

package/module/es5/tests/unit/Validate/string/minLength.test.d.ts

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

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

@@ -0,0 +1,18 @@
+"use strict";
+
+var _string = require("@/Validate/string");
+describe("minLength", function () {
+  it("minLength with message", function () {
+    var minLengthValidatorWithMessage = (0, _string.minLength)(3, "Minimum length is 3");
+    var validateStringWithMessage = (0, _string.string)([minLengthValidatorWithMessage]);
+    expect(validateStringWithMessage("").message).toEqual("Minimum length is 3");
+    expect(validateStringWithMessage("ab").validate).toBeFalsy();
+    expect(validateStringWithMessage("abc").validate).toBeTruthy();
+  });
+  it("minLength without message", function () {
+    var minLengthValidatorWithoutMessage = (0, _string.minLength)(3);
+    var validateStringWithoutMessage = (0, _string.string)([minLengthValidatorWithoutMessage]);
+    expect(validateStringWithoutMessage("abc").message).toEqual("");
+    expect(validateStringWithoutMessage("ab").validate).toBeFalsy();
+  });
+});

package/module/es5/tests/unit/Validate/string/numberString.test.d.ts

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

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

@@ -0,0 +1,22 @@
+"use strict";
+
+var _numberString = require("@/Validate/string/numberString");
+describe("numberString", function () {
+  it("should return true for valid number strings", function () {
+    var validateNumberString = (0, _numberString.numberString)();
+    expect(validateNumberString.validate("123")).toBe(true);
+    expect(validateNumberString.validate("0.56")).toBe(true);
+  });
+  it("should return false for invalid number strings", function () {
+    var validateNumberString = (0, _numberString.numberString)();
+    expect(validateNumberString.validate("abc")).toBe(false);
+    expect(validateNumberString.validate("123abc")).toBe(false);
+    expect(validateNumberString.validate("")).toBe(true);
+  });
+  it("should return the custom message for invalid input", function () {
+    var customMessage = "This is not a valid number string";
+    var validateNumberString = (0, _numberString.numberString)(customMessage);
+    expect(validateNumberString.validate("abc")).toBe(false);
+    expect(validateNumberString.message).toBe(customMessage);
+  });
+});

package/module/es5/tests/unit/Validate/string/regexMatch.test.d.ts

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

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

@@ -0,0 +1,29 @@
+"use strict";
+
+var _regexMatch = require("@/Validate/string/regexMatch");
+describe("regexMatch", function () {
+  test("should validate matching patterns", function () {
+    var pattern = /^[a-z]+$/;
+    var validator = (0, _regexMatch.regexMatch)(pattern);
+    expect(validator.validate("abc")).toBe(true);
+    expect(validator.validate("ABC")).toBe(false);
+    expect(validator.validate("123")).toBe(false);
+    expect(validator.validate("abc123")).toBe(false);
+  });
+  test("should validate non-matching patterns", function () {
+    var pattern = /^[0-9]+$/;
+    var validator = (0, _regexMatch.regexMatch)(pattern);
+    expect(validator.validate("123")).toBe(true);
+    expect(validator.validate("abc")).toBe(false);
+    expect(validator.validate("123abc")).toBe(false);
+    expect(validator.validate("")).toBe(false);
+  });
+  test("should handle custom error messages", function () {
+    var pattern = /^[A-Z]+$/;
+    var message = "Only uppercase letters are allowed";
+    var validator = (0, _regexMatch.regexMatch)(pattern, message);
+    expect(validator.validate("ABC")).toBe(true);
+    expect(validator.validate("abc")).toBe(false);
+    expect(validator.message).toBe(message);
+  });
+});

package/module/es5/tests/unit/Validate/string/uuid.test.d.ts

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

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

@@ -0,0 +1,72 @@
+"use strict";
+
+var _Validate = require("@/Validate");
+var _uuid = require("@/Validate/string/uuid");
+describe("uuid", function () {
+  it("有効なUUIDを検証する", 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);
+    expect(validateUUID.validate("B86D03E7-7B2D-4710-897B-77D05A1F0B4B")).toBe(true);
+    expect(validateUUID.validate("573F42D5-1734-45E1-9D4D-AA43E6DF697E")).toBe(true);
+    expect(validateUUID.validate("D1643B1F-DCEC-46A0-9196-D2C9B8446601")).toBe(true);
+    expect(validateUUID.validate("44046745-283C-4507-955E-430DAAD16189")).toBe(true);
+    expect(validateUUID.validate("7185AF69-0153-4C42-B63F-368291A74AAF")).toBe(true);
+    expect(validateUUID.validate("ADD5ABC1-54B8-4D5D-A8A0-ABA55089A1CF")).toBe(true);
+    expect(validateUUID.validate("0C338BD0-768B-4510-95D0-0D1571B08405")).toBe(true);
+    expect(validateUUID.validate("C48EACCC-CEA3-4C4D-B669-0D1669D4DBBF")).toBe(true);
+    expect(validateUUID.validate("A95E3F62-2D0E-4257-95D3-B239AF08115D")).toBe(true);
+    expect(validateUUID.validate("A95E3F622D0E425795D3B239AF08115D")).toBe(true);
+  });
+  it("無効なUUIDを検証する", 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 () {
+    var validUUID = "123e4567-e89b-42d3-a456-426614174000";
+    var customMessage = "UUIDが無効です";
+    var validateUUID = (0, _Validate.string)([(0, _uuid.uuid)([4], customMessage)]);
+    expect(validateUUID(validUUID).validate).toBe(true);
+    expect(validateUUID(validUUID).message).toBe("");
+  });
+  it("カスタムメッセージを持つ無効なUUIDを検証する", function () {
+    var invalidUUID = "123e4567-e89b-12d3-a456-42661417400Z";
+    var customMessage = "UUIDが無効です";
+    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 () {
+    var validateUUID = (0, _uuid.uuid)();
+    expect(validateUUID.validate("123e4567-E89b-42D3-a456-426614174000")).toBe(true);
+  });
+  it("UUIDのバージョンが異なる場合を検証する", 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 () {
+    var validateUUID = (0, _uuid.uuid)();
+    expect(validateUUID.validate("completely-invalid-format")).toBe(false);
+  });
+  it("空文字列を検証する", function () {
+    var validateUUID = (0, _uuid.uuid)();
+    expect(validateUUID.validate("")).toBe(false);
+  });
+  it("nullを検証する", function () {
+    var validateUUID = (0, _uuid.uuid)();
+    // @ts-ignore
+    expect(validateUUID.validate(null)).toBe(false);
+  });
+  it("UUIDの長さが不足している場合を検証する", function () {
+    var validateUUID = (0, _uuid.uuid)();
+    expect(validateUUID.validate("123e4567-e89b-42d3-a456-42661417400")).toBe(false);
+  });
+  it("UUIDの長さが超過している場合を検証する", function () {
+    var validateUUID = (0, _uuid.uuid)();
+    expect(validateUUID.validate("123e4567-e89b-42d3-a456-4266141740001234")).toBe(false);
+  });
+});

package/module/es5/tests/unit/types/arrayType.test.d.ts

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

package/module/es5/tests/unit/types/arrayType.test.js

@@ -0,0 +1,11 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+describe("arrayType", function () {
+  it("ChunkArrayType", function () {
+    var _ = [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10]];
+    expect(_).toEqual(_);
+  });
+});

package/module/es5/tests/unit/types/clockType.test.d.ts

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