umt 2.1.2 → 2.2.0

package/module/es5/tests/unit/Date/getTimezoneOffsetString.test.js

@@ -2,21 +2,21 @@
 
 var _getTimezoneOffsetString = require("@/Date/getTimezoneOffsetString");
 describe("getTimezoneOffsetString", function () {
-  it("タイムゾーンオフセットが正の場合", function () {
+  it("should handle positive timezone offset", function () {
     var date = new Date("2023-01-01T12:00:00Z");
     date.getTimezoneOffset = function () {
       return -480;
     }; // UTC+8
     expect((0, _getTimezoneOffsetString.getTimezoneOffsetString)(date)).toBe("+08:00");
   });
-  it("タイムゾーンオフセットが負の場合", function () {
+  it("should handle negative timezone offset", function () {
     var date = new Date("2023-01-01T12:00:00Z");
     date.getTimezoneOffset = function () {
       return 300;
     }; // UTC-5
     expect((0, _getTimezoneOffsetString.getTimezoneOffsetString)(date)).toBe("-05:00");
   });
-  it("タイムゾーンオフセットが0の場合", function () {
+  it("should handle zero timezone offset", function () {
     var date = new Date("2023-01-01T12:00:00Z");
     date.getTimezoneOffset = function () {
       return 0;

package/module/es5/tests/unit/Date/isLeapYear.test.d.ts

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

package/module/es5/tests/unit/Date/isLeapYear.test.js

@@ -0,0 +1,30 @@
+"use strict";
+
+var _isLeapYear = require("@/Date/isLeapYear");
+describe("isLeapYear", function () {
+  it("should return true for years divisible by 4 but not by 100", function () {
+    expect((0, _isLeapYear.isLeapYear)(2020)).toBe(true);
+    expect((0, _isLeapYear.isLeapYear)(2024)).toBe(true);
+    expect((0, _isLeapYear.isLeapYear)(1996)).toBe(true);
+  });
+  it("should return false for years divisible by 100 but not by 400", function () {
+    expect((0, _isLeapYear.isLeapYear)(1900)).toBe(false);
+    expect((0, _isLeapYear.isLeapYear)(2100)).toBe(false);
+    expect((0, _isLeapYear.isLeapYear)(1700)).toBe(false);
+  });
+  it("should return true for years divisible by 400", function () {
+    expect((0, _isLeapYear.isLeapYear)(2000)).toBe(true);
+    expect((0, _isLeapYear.isLeapYear)(1600)).toBe(true);
+    expect((0, _isLeapYear.isLeapYear)(2400)).toBe(true);
+  });
+  it("should return false for non-leap years", function () {
+    expect((0, _isLeapYear.isLeapYear)(2023)).toBe(false);
+    expect((0, _isLeapYear.isLeapYear)(2025)).toBe(false);
+    expect((0, _isLeapYear.isLeapYear)(1997)).toBe(false);
+  });
+  it("should handle early years", function () {
+    expect((0, _isLeapYear.isLeapYear)(4)).toBe(true);
+    expect((0, _isLeapYear.isLeapYear)(100)).toBe(false);
+    expect((0, _isLeapYear.isLeapYear)(400)).toBe(true);
+  });
+});

package/module/es5/tests/unit/Date/new.test.d.ts

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

package/module/es5/tests/unit/Date/new.test.js

@@ -0,0 +1,39 @@
+"use strict";
+
+var _new = require("@/Date/new");
+describe("newDateInt", function () {
+  it("should create date with components matching input values", function () {
+    var date = (0, _new.newDateInt)(2025, 1, 1);
+    expect(date.getFullYear()).toBe(2025);
+    expect(date.getMonth()).toBe(0); // 0-based month
+    expect(date.getDate()).toBe(1);
+  });
+  it("should create date with all time components matching input values", function () {
+    var date = (0, _new.newDateInt)(2025, 1, 1, 10, 30, 45, 500);
+    expect(date.getFullYear()).toBe(2025);
+    expect(date.getMonth()).toBe(0);
+    expect(date.getDate()).toBe(1);
+    expect(date.getHours()).toBe(10);
+    expect(date.getMinutes()).toBe(30);
+    expect(date.getSeconds()).toBe(45);
+    expect(date.getMilliseconds()).toBe(500);
+  });
+});
+describe("newDateString", function () {
+  it("should create date with default time values", function () {
+    var date = (0, _new.newDateString)("2025-01-01");
+    // Use toISOString to check the UTC time, which should be midnight
+    expect(date.toISOString()).toBe("2025-01-01T00:00:00.000Z");
+  });
+  it("should create date with specific time components", function () {
+    var date = (0, _new.newDateString)("2025-01-01", "10", "30", "45", "500", "09");
+    expect(date.toISOString()).toBe("2025-01-01T01:30:45.500Z"); // UTC+9 -> UTC
+  });
+  it("should handle different timezone offsets", function () {
+    var dateUTC = (0, _new.newDateString)("2025-01-01", "12", "00", "00", "000", "00");
+    var dateJST = (0, _new.newDateString)("2025-01-01", "12", "00", "00", "000", "09");
+
+    // JST (UTC+9) date should be 9 hours behind UTC date
+    expect(dateJST.getTime()).toBe(dateUTC.getTime() - 9 * 60 * 60 * 1000);
+  });
+});

package/module/es5/tests/unit/Date/now.test.d.ts

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

package/module/es5/tests/unit/Date/now.test.js

@@ -0,0 +1,42 @@
+"use strict";
+
+var _now = require("@/Date/now");
+describe("now", function () {
+  var FIXED_TIME = 1712192400000; // 2024-04-04T01:00:00.000Z (confirmed with Date object)
+
+  beforeEach(function () {
+    // Mock Date.now() to return a fixed timestamp
+    jest.spyOn(Date, "now").mockImplementation(function () {
+      return FIXED_TIME;
+    });
+  });
+  afterEach(function () {
+    jest.restoreAllMocks();
+  });
+  it("should return current time in JST by default", function () {
+    var result = (0, _now.now)();
+    // Expected: 2024-04-04T10:00:00.000Z (FIXED_TIME + 9 hours)
+    expect(result.toISOString()).toBe("2024-04-04T10:00:00.000Z");
+  });
+  it("should return UTC time when offset is 0", function () {
+    var result = (0, _now.now)(0);
+    // Expected: 2024-04-04T01:00:00.000Z (FIXED_TIME + 0 hours)
+    expect(result.toISOString()).toBe("2024-04-04T01:00:00.000Z");
+  });
+  it("should handle different UTC offsets", function () {
+    // Test UTC+1 (CET)
+    var resultCET = (0, _now.now)(1);
+    expect(resultCET.toISOString()).toBe("2024-04-04T02:00:00.000Z");
+
+    // Test UTC+8 (CST)
+    var resultCST = (0, _now.now)(8);
+    expect(resultCST.toISOString()).toBe("2024-04-04T09:00:00.000Z");
+  });
+  it("should return correct time difference between timezones", function () {
+    var utcResult = (0, _now.now)(0);
+    var jstResult = (0, _now.now)(9);
+
+    // JST should be 9 hours ahead of UTC
+    expect(jstResult.getTime() - utcResult.getTime()).toBe(9 * 60 * 60 * 1000);
+  });
+});

package/module/es5/tests/unit/Error/safeExecute.test.js

@@ -1,21 +1,75 @@
 "use strict";
 
 var _safeExecute = require("@/Error/safeExecute");
-describe("result function tests", function () {
-  it("should return OkType for successful operations", function () {
-    var successfulOperation = function successfulOperation() {
-      return "test";
-    };
-    var resultValue = (0, _safeExecute.safeExecute)(successfulOperation);
-    expect(resultValue).toHaveProperty("type", "success");
-    expect(resultValue).toHaveProperty("value", "test");
+describe("safeExecute function", function () {
+  describe("successful operations", function () {
+    it("should return success type with string value", function () {
+      var successfulOperation = function successfulOperation() {
+        return "test";
+      };
+      var result = (0, _safeExecute.safeExecute)(successfulOperation);
+      expect(result).toEqual({
+        type: "success",
+        value: "test"
+      });
+    });
+    it("should return success type with number value", function () {
+      var successfulOperation = function successfulOperation() {
+        return 42;
+      };
+      var result = (0, _safeExecute.safeExecute)(successfulOperation);
+      expect(result).toEqual({
+        type: "success",
+        value: 42
+      });
+    });
+    it("should return success type with object value", function () {
+      var testObject = {
+        key: "value"
+      };
+      var successfulOperation = function successfulOperation() {
+        return testObject;
+      };
+      var result = (0, _safeExecute.safeExecute)(successfulOperation);
+      expect(result).toEqual({
+        type: "success",
+        value: testObject
+      });
+    });
   });
-  it("should return ErrorType for operations that throw", function () {
-    var errorOperation = function errorOperation() {
-      throw new Error("test error");
-    };
-    var resultValue = (0, _safeExecute.safeExecute)(errorOperation);
-    expect(resultValue).toHaveProperty("type", "error");
-    expect(resultValue).toHaveProperty("error");
+  describe("error handling", function () {
+    it("should return error type with Error instance", function () {
+      var errorOperation = function errorOperation() {
+        throw new Error("test error");
+      };
+      var result = (0, _safeExecute.safeExecute)(errorOperation);
+      expect(result.type).toBe("error");
+      if (result.type === "error") {
+        expect(result.error).toBeInstanceOf(Error);
+        expect(result.error.message).toBe("test error");
+      }
+    });
+    it("should return error type with custom error message", function () {
+      var customError = new TypeError("custom type error");
+      var errorOperation = function errorOperation() {
+        throw customError;
+      };
+      var result = (0, _safeExecute.safeExecute)(errorOperation);
+      expect(result.type).toBe("error");
+      if (result.type === "error") {
+        expect(result.error).toBe(customError);
+        expect(result.error.message).toBe("custom type error");
+      }
+    });
+    it("should handle non-Error thrown values", function () {
+      var errorOperation = function errorOperation() {
+        throw "string error";
+      };
+      var result = (0, _safeExecute.safeExecute)(errorOperation);
+      expect(result.type).toBe("error");
+      if (result.type === "error") {
+        expect(result.error).toBe("string error");
+      }
+    });
   });
 });

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

@@ -1,10 +1,32 @@
 "use strict";
 
 var _cidrToLong = require("@/IP/cidrToLong");
-describe("cidrToLong for IPv4", function () {
-  test.each([
-  // [CIDR, 期待されるサブネットマスクの数値]
-  [32, 0xffffffff], [24, 0xffffff00], [16, 0xffff0000], [8, 0xff000000], [0, 0x00000000]])("cidrToLong(%i) should return %i for IPv4", function (cidr, expected) {
-    expect((0, _cidrToLong.cidrToLong)(cidr)).toBe(expected);
+describe("cidrToLong", function () {
+  describe("valid CIDR values", function () {
+    test.each([
+    // [CIDR, expected subnet mask value]
+    [32, 0xffffffff],
+    // 255.255.255.255
+    [24, 0xffffff00],
+    // 255.255.255.0
+    [16, 0xffff0000],
+    // 255.255.0.0
+    [8, 0xff000000],
+    // 255.0.0.0
+    [0, 0x00000000],
+    // 0.0.0.0
+    [1, 0x80000000],
+    // 128.0.0.0
+    [31, 0xfffffffe] // 255.255.255.254
+    ])("should convert CIDR %i to subnet mask %i", function (cidr, expected) {
+      expect((0, _cidrToLong.cidrToLong)(cidr)).toBe(expected);
+    });
+  });
+  describe("invalid CIDR values", function () {
+    test.each([[-1, "CIDR must be an integer between 0 and 32"], [33, "CIDR must be an integer between 0 and 32"], [3.5, "CIDR must be an integer between 0 and 32"], [Number.NaN, "CIDR must be an integer between 0 and 32"], [Number.POSITIVE_INFINITY, "CIDR must be an integer between 0 and 32"]])("should throw error for invalid CIDR %p", function (cidr, expectedError) {
+      expect(function () {
+        return (0, _cidrToLong.cidrToLong)(cidr);
+      }).toThrow(expectedError);
+    });
   });
 });

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

@@ -1,17 +1,36 @@
 "use strict";
 
 var _cidrToSubnetMask = require("@/IP/cidrToSubnetMask");
-// cidrToSubnetMask.test.ts
-
 describe("cidrToSubnetMask", function () {
-  // IPv4のテスト
-  test("IPv4 CIDR /24 をサブネットマスクに変換", function () {
-    expect((0, _cidrToSubnetMask.cidrToSubnetMask)(24)).toBe("255.255.255.0");
-  });
-  test("IPv4 CIDR /16 をサブネットマスクに変換", function () {
-    expect((0, _cidrToSubnetMask.cidrToSubnetMask)(16)).toBe("255.255.0.0");
+  describe("valid CIDR values", function () {
+    test.each([
+    // [CIDR, expected subnet mask]
+    [32, "255.255.255.255"],
+    // Full mask
+    [24, "255.255.255.0"],
+    // Common class C
+    [16, "255.255.0.0"],
+    // Common class B
+    [8, "255.0.0.0"],
+    // Common class A
+    [0, "0.0.0.0"],
+    // No mask
+    [1, "128.0.0.0"],
+    // First bit
+    [31, "255.255.255.254"],
+    // Second to last
+    [28, "255.255.255.240"],
+    // Common subnet
+    [20, "255.255.240.0"] // Less common subnet
+    ])("should convert CIDR /%i to subnet mask %s", function (cidr, expected) {
+      expect((0, _cidrToSubnetMask.cidrToSubnetMask)(cidr)).toBe(expected);
+    });
   });
-  test("IPv4 CIDR /8 をサブネットマスクに変換", function () {
-    expect((0, _cidrToSubnetMask.cidrToSubnetMask)(8)).toBe("255.0.0.0");
+  describe("invalid CIDR values", function () {
+    test.each([[-1, "CIDR must be an integer between 0 and 32"], [33, "CIDR must be an integer between 0 and 32"], [3.5, "CIDR must be an integer between 0 and 32"], [Number.NaN, "CIDR must be an integer between 0 and 32"], [Number.POSITIVE_INFINITY, "CIDR must be an integer between 0 and 32"]])("should throw error for invalid CIDR %p", function (cidr, expectedError) {
+      expect(function () {
+        return (0, _cidrToSubnetMask.cidrToSubnetMask)(cidr);
+      }).toThrow(expectedError);
+    });
   });
 });

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

@@ -2,24 +2,35 @@
 
 var _getIpClass = require("@/IP/getIpClass");
 describe("getIpClass", function () {
-  // IPv4のテストケース
-  test("IPクラスAを識別する", function () {
-    expect((0, _getIpClass.getIpClass)("1.2.3.4")).toBe("A");
+  describe("valid IP addresses", function () {
+    test.each([
+    // [IP address, expected class]
+    ["1.0.0.0", "A"],
+    // Start of class A
+    ["126.0.0.1", "A"],
+    // End of class A
+    ["128.0.0.1", "B"],
+    // Start of class B
+    ["191.255.0.1", "B"],
+    // End of class B
+    ["192.0.0.1", "C"],
+    // Start of class C
+    ["223.255.0.1", "C"],
+    // End of class C
+    ["224.0.0.1", "D"],
+    // Start of class D
+    ["239.0.0.1", "D"],
+    // End of class D
+    ["240.0.0.1", "E"],
+    // Start of class E
+    ["255.255.255.255", "E"] // End of class E
+    ])("should identify %s as class %s", function (ip, expectedClass) {
+      expect((0, _getIpClass.getIpClass)(ip)).toBe(expectedClass);
+    });
   });
-  test("IPクラスBを識別する", function () {
-    expect((0, _getIpClass.getIpClass)("128.1.2.3")).toBe("B");
-  });
-  test("IPクラスCを識別する", function () {
-    expect((0, _getIpClass.getIpClass)("192.0.2.1")).toBe("C");
-  });
-  test("IPクラスDを識別する", function () {
-    expect((0, _getIpClass.getIpClass)("224.0.0.1")).toBe("D");
-  });
-  test("IPクラスEを識別する", function () {
-    expect((0, _getIpClass.getIpClass)("240.0.0.1")).toBe("E");
-  });
-  test("無効な範囲のIPアドレス", function () {
-    expect((0, _getIpClass.getIpClass)("")).toBe("");
-    expect((0, _getIpClass.getIpClass)("256.0.0.1")).toBe("");
+  describe("invalid IP addresses", function () {
+    test.each([["", "empty string"], ["0.0.0.0", "reserved address"], ["256.0.0.1", "first octet > 255"], ["192.168", "incomplete IP"], ["192.168.1.1.1", "too many octets"], ["a.b.c.d", "non-numeric octets"], ["192.168.1", "too few octets"], ["-1.0.0.0", "negative octet"], ["1.2.3.4.5", "too many segments"]])("should return empty string for %s (%s)", function (ip) {
+      expect((0, _getIpClass.getIpClass)(ip)).toBe("");
+    });
   });
 });

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

@@ -1,19 +1,40 @@
 "use strict";
 
 var _getNetworkAddress = require("@/IP/getNetworkAddress");
-describe("getNetworkAddress function", function () {
-  it("正常なIPアドレスとサブネットマスクが正しいネットワークアドレスに変換される", function () {
-    // 一般的なケース
-    expect((0, _getNetworkAddress.getNetworkAddress)("192.168.1.1", "255.255.255.0")).toBe(0xc0a80100);
-    expect((0, _getNetworkAddress.getNetworkAddress)("172.16.5.1", "255.255.0.0")).toBe(0xac100000);
-    expect((0, _getNetworkAddress.getNetworkAddress)("10.0.0.15", "255.0.0.0")).toBe(0x0a000000);
-
-    // エッジケース（全てのホストビットが1または0）
-    expect((0, _getNetworkAddress.getNetworkAddress)("255.255.255.255", "255.255.255.0")).toBe(0xffffff00);
-    expect((0, _getNetworkAddress.getNetworkAddress)("0.0.0.0", "255.255.255.0")).toBe(0x00000000);
-
-    // 異なるCIDR値を持つサブネットマスク
-    expect((0, _getNetworkAddress.getNetworkAddress)("192.168.1.1", "255.255.254.0")).toBe(0xc0a80000);
-    // expect(getNetworkAddress("172.16.5.1", "255.255.255.128")).toBe(0xac100501);
+describe("getNetworkAddress", function () {
+  describe("valid IP addresses and subnet masks", function () {
+    test.each([
+    // [IP address, subnet mask, expected network address]
+    ["192.168.1.1", "255.255.255.0", 0xc0a80100],
+    // Common Class C network
+    ["172.16.5.1", "255.255.0.0", 0xac100000],
+    // Common Class B network
+    ["10.0.0.15", "255.0.0.0", 0x0a000000],
+    // Common Class A network
+    ["192.168.1.1", "255.255.254.0", 0xc0a80000],
+    // Non-standard subnet mask
+    ["255.255.255.255", "255.255.255.0", 0xffffff00],
+    // All host bits set
+    ["0.0.0.0", "255.255.255.0", 0x00000000],
+    // All bits zero
+    ["192.168.1.1", "255.255.255.252", 0xc0a80100],
+    // Small subnet (/30)
+    ["10.10.10.10", "255.255.255.240", 0x0a0a0a00] // Subnet mask with /28
+    ])("should calculate network address for %s with mask %s", function (ip, mask, expected) {
+      expect((0, _getNetworkAddress.getNetworkAddress)(ip, mask)).toBe(expected);
+    });
+  });
+  describe("invalid inputs", function () {
+    test.each([[undefined, "255.255.255.0", "IP address is required"], ["192.168.1.1", undefined, "Subnet mask is required"], ["", "255.255.255.0", "IP address is required"], ["192.168.1.1", "", "Subnet mask is required"], ["invalid", "255.255.255.0", "Invalid IP address or subnet mask"], ["192.168.1.1", "invalid", "Invalid IP address or subnet mask"], ["256.256.256.256", "255.255.255.0", "Invalid IP address or subnet mask"], ["192.168.1.1", "256.256.256.256", "Invalid IP address or subnet mask"]])("should throw error for %s and %s: %s", function (ip, mask, expectedError) {
+      expect(function () {
+        return (0, _getNetworkAddress.getNetworkAddress)(ip, mask);
+      }).toThrow(expectedError);
+    });
+  });
+  test("should handle internal function exceptions", function () {
+    // Test for exception handling in catch block (line 49)
+    expect(function () {
+      return (0, _getNetworkAddress.getNetworkAddress)("192.168.1.1", "255.255.128.3");
+    }).toThrow("Invalid IP address or subnet mask");
   });
 });

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

@@ -2,16 +2,45 @@
 
 var _ipToBinaryString = require("@/IP/ipToBinaryString");
 describe("ipToBinaryString", function () {
-  it("正常なIPアドレスを正しくバイナリ文字列に変換する", function () {
-    expect((0, _ipToBinaryString.ipToBinaryString)("192.168.0.1")).toBe("11000000101010000000000000000001");
+  describe("valid IP addresses", function () {
+    test.each([
+    // [IP address, expected binary string]
+    ["192.168.0.1", "11000000101010000000000000000001"],
+    // Common private network
+    ["0.0.0.0", "00000000000000000000000000000000"],
+    // All zeros
+    ["255.255.255.255", "11111111111111111111111111111111"],
+    // All ones
+    ["1.2.3.4", "00000001000000100000001100000100"],
+    // Single digit octets
+    ["10.0.0.1", "00001010000000000000000000000001"],
+    // Class A private
+    ["172.16.0.1", "10101100000100000000000000000001"],
+    // Class B private
+    ["127.0.0.1", "01111111000000000000000000000001"],
+    // Localhost
+    ["169.254.0.1", "10101001111111100000000000000001"] // Link-local
+    ])("should convert %s to binary", function (ip, expected) {
+      expect((0, _ipToBinaryString.ipToBinaryString)(ip)).toBe(expected);
+    });
   });
-  it("全てのオクテットが0のIPアドレスを正しく変換する", function () {
-    expect((0, _ipToBinaryString.ipToBinaryString)("0.0.0.0")).toBe("00000000000000000000000000000000");
+  describe("invalid IP addresses", function () {
+    test.each([[undefined, "IP address is required"], ["", "IP address is required"], ["192.168", "Invalid IP address format"], ["a.b.c.d", "Invalid IP address format"], ["256.1.2.3", "Invalid IP address format"], ["-1.1.1.1", "Invalid IP address format"], ["1.2.3.4.5", "Invalid IP address format"], ["192.168.1", "Invalid IP address format"], ["192.168.1.1.1", "Invalid IP address format"], ["192.168.1.", "Invalid IP address format"], ["192.168..1", "Invalid IP address format"], [".192.168.1", "Invalid IP address format"], ["192,168,1,1", "Invalid IP address format"], ["192.168.1.1.", "Invalid IP address format"], ["192.168.1.+1", "Invalid IP address format"], ["256.256.256.256", "Invalid IP address format"], ["999.999.999.999", "Invalid IP address format"]])("should throw error for %s: %s", function (ip, expectedError) {
+      expect(function () {
+        return (0, _ipToBinaryString.ipToBinaryString)(ip);
+      }).toThrow(expectedError);
+    });
   });
-  it("全てのオクテットが255のIPアドレスを正しく変換する", function () {
-    expect((0, _ipToBinaryString.ipToBinaryString)("255.255.255.255")).toBe("11111111111111111111111111111111");
-  });
-  it("エッジケース（オクテットが1桁）を正しく扱う", function () {
-    expect((0, _ipToBinaryString.ipToBinaryString)("1.2.3.4")).toBe("00000001000000100000001100000100");
+  describe("edge cases", function () {
+    test.each([
+    // [IP address, expected binary string]
+    ["0.0.0.0", "00000000000000000000000000000000"], ["1.1.1.1", "00000001000000010000000100000001"], ["255.255.255.255", "11111111111111111111111111111111"], ["128.0.0.0", "10000000000000000000000000000000"], ["0.255.0.255", "00000000111111110000000011111111"]])("should handle boundary values: %s", function (ip, expected) {
+      expect((0, _ipToBinaryString.ipToBinaryString)(ip)).toBe(expected);
+    });
+    test.each(["0000", "00.00", "0.0.0", "192.168.01.1", "192.168.1.01", "010.020.030.040"])("should reject IP with invalid format: %s", function (ip) {
+      expect(function () {
+        return (0, _ipToBinaryString.ipToBinaryString)(ip);
+      }).toThrow("Invalid IP address format");
+    });
   });
 });

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

@@ -2,19 +2,33 @@
 
 var _ipToLong = require("@/IP/ipToLong");
 describe("ipToLong", function () {
-  it("正常なIPアドレスが正しい数値に変換される", function () {
-    expect((0, _ipToLong.ipToLong)("128.0.0.1")).toBe(2147483649);
+  describe("valid IP addresses", function () {
+    test.each([
+    // [IP address, expected long value]
+    ["192.168.0.1", 0xc0a80001],
+    // Common private network
+    ["128.0.0.1", 0x80000001],
+    // Class B start
+    ["10.0.0.1", 0x0a000001],
+    // Class A private
+    ["172.16.0.1", 0xac100001],
+    // Class B private
+    ["255.255.255.255", 0xffffffff],
+    // Maximum value
+    ["0.0.0.0", 0x00000000],
+    // Minimum value
+    ["127.0.0.1", 0x7f000001],
+    // Localhost
+    ["1.2.3.4", 0x01020304] // Simple incremental
+    ])("should convert %s to %i", function (ip, expected) {
+      expect((0, _ipToLong.ipToLong)(ip)).toBe(expected);
+    });
   });
-  it("全てのオクテットが255の場合、最大値に変換される", function () {
-    expect((0, _ipToLong.ipToLong)("255.255.255.255")).toBe(4294967295);
-  });
-  it("全てのオクテットが0の場合、0に変換される", function () {
-    expect((0, _ipToLong.ipToLong)("0.0.0.0")).toBe(0);
-  });
-  it("空の文字列が渡された場合、0に変換される", function () {
-    expect((0, _ipToLong.ipToLong)("")).toBe(0);
-  });
-  it("範囲外のIPアドレスの場合、0に変換される", function () {
-    expect((0, _ipToLong.ipToLong)("256.0.0.0")).toBe(0);
+  describe("invalid IP addresses", function () {
+    test.each([[undefined, "IP address is required"], ["", "IP address is required"], ["192.168", "Invalid IP address format"], ["256.1.2.3", "Invalid IP address format"], ["a.b.c.d", "Invalid IP address format"], ["-1.0.0.0", "Invalid IP address format"], ["192.168.1.1.1", "Invalid IP address format"], ["192.168..1", "Invalid IP address format"]])("should throw error for %s: %s", function (ip, expectedError) {
+      expect(function () {
+        return (0, _ipToLong.ipToLong)(ip);
+      }).toThrow(expectedError);
+    });
   });
 });

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

@@ -2,10 +2,81 @@
 
 var _isInRange = require("@/IP/isInRange");
 describe("isInRange", function () {
-  it("returns true for an IP within the range", function () {
-    expect((0, _isInRange.isInRange)("192.168.1.2", "192.168.1.0", 24)).toBe(true);
+  describe("valid IP ranges", function () {
+    test.each([
+    // [remoteIp, networkIp, cidr, expected]
+    ["192.168.1.2", "192.168.1.0", 24, true],
+    // Common class C network
+    ["192.168.2.2", "192.168.1.0", 24, false],
+    // Outside class C network
+    ["10.0.0.5", "10.0.0.0", 8, true],
+    // Class A network
+    ["11.0.0.5", "10.0.0.0", 8, false],
+    // Outside class A network
+    ["172.16.1.1", "172.16.0.0", 16, true],
+    // Class B network
+    ["172.17.1.1", "172.16.0.0", 16, false],
+    // Outside class B network
+    ["192.168.1.0", "192.168.1.0", 32, true],
+    // Single host network - exact match
+    ["192.168.1.1", "192.168.1.1", 32, true],
+    // Single host network - exact match
+    ["192.168.1.1", "192.168.1.0", 32, false],
+    // Single host network - different IP
+    ["192.168.1.1", "192.168.1.0", 30, true],
+    // Small subnet
+    ["192.168.1.4", "192.168.1.0", 30, false],
+    // Outside small subnet
+    ["0.0.0.1", "0.0.0.0", 0, true],
+    // All IPs in range (CIDR 0)
+    ["255.255.255.255", "0.0.0.0", 0, true] // All IPs in range (CIDR 0)
+    ])("should evaluate if %s is in network %s/%i => %s", function (remoteIp, networkIp, cidr, expected) {
+      expect((0, _isInRange.isInRange)(remoteIp, networkIp, cidr)).toBe(expected);
+    });
+    test.each([
+    // [remoteIp, networkIp, cidr, description]
+    ["192.168.1.1", "0.0.0.0", 0, "CIDR 0: all IPs in range"], ["192.168.1.0", "192.168.1.0", 32, "CIDR 32: exact match only"], ["192.168.1.1", "192.168.1.0", 31, "CIDR 31: two IPs"], ["192.168.1.1", "192.168.1.0", 1, "CIDR 1: half of all IPs"]])("should handle %s (%s)", function (ip, network, cidr) {
+      expect((0, _isInRange.isInRange)(ip, network, cidr)).toBe(true);
+    });
+    test("should correctly handle edge cases with specific CIDR masks", function () {
+      expect((0, _isInRange.isInRange)("192.168.1.5", "192.168.1.0", 24)).toBe(true);
+      expect((0, _isInRange.isInRange)("192.168.2.0", "192.168.1.0", 24)).toBe(false);
+      expect((0, _isInRange.isInRange)("192.168.1.0", "192.168.1.0", 31)).toBe(true);
+      expect((0, _isInRange.isInRange)("192.168.1.1", "192.168.1.0", 31)).toBe(true);
+      expect((0, _isInRange.isInRange)("192.168.1.2", "192.168.1.0", 31)).toBe(false);
+      expect((0, _isInRange.isInRange)("192.168.1.3", "192.168.1.0", 30)).toBe(true);
+      expect((0, _isInRange.isInRange)("192.168.1.4", "192.168.1.4", 30)).toBe(true);
+    });
   });
-  it("returns false for an IP outside the range", function () {
-    expect((0, _isInRange.isInRange)("192.168.2.2", "192.168.1.0", 24)).toBe(false);
+  describe("invalid inputs", function () {
+    test.each([[undefined, "192.168.1.0", 24, "Remote IP address is required"], ["192.168.1.1", undefined, 24, "Network IP address is required"], ["", "192.168.1.0", 24, "Remote IP address is required"], ["192.168.1.1", "", 24, "Network IP address is required"], ["192.168.1.1", "192.168.1.0", undefined, "CIDR must be an integer between 0 and 32"], ["192.168.1.1", "192.168.1.0", -1, "CIDR must be an integer between 0 and 32"], ["192.168.1.1", "192.168.1.0", 33, "CIDR must be an integer between 0 and 32"], ["192.168.1.1", "192.168.1.0", 1.5, "CIDR must be an integer between 0 and 32"]])("should throw error for remoteIp=%s, networkIp=%s, cidr=%s", function (remoteIp, networkIp, cidr, expectedError) {
+      expect(function () {
+        return (0, _isInRange.isInRange)(remoteIp, networkIp, cidr);
+      }).toThrow(expectedError);
+    });
+  });
+  describe("invalid IP formats", function () {
+    test.each([["invalid", "192.168.1.0", 24], ["192.168.1.1", "invalid", 24], ["256.256.256.256", "192.168.1.0", 24], ["192.168.1.1", "256.256.256.256", 24], ["192.168.1.1.1", "192.168.1.0", 24], ["192.168.-1.1", "192.168.1.0", 24], ["192.168.1", "192.168.1.0", 24]])("should throw for invalid IP format: %s", function (remoteIp, networkIp, cidr) {
+      expect(function () {
+        return (0, _isInRange.isInRange)(remoteIp, networkIp, cidr);
+      }).toThrow("Invalid IP address format");
+    });
+  });
+  describe("error message formatting", function () {
+    test("should format error messages correctly with String(error) for invalid IP", function () {
+      expect(function () {
+        return (0, _isInRange.isInRange)("invalid-ip", "192.168.1.0", 24);
+      }).toThrow("Invalid IP address format: Error: Invalid IP address format");
+    });
+    test("should format error messages correctly for invalid network IP", function () {
+      expect(function () {
+        return (0, _isInRange.isInRange)("192.168.1.1", "invalid-network", 24);
+      }).toThrow("Invalid IP address format: Error: Invalid IP address format");
+    });
+    test("should format error messages for out-of-range IP values", function () {
+      expect(function () {
+        return (0, _isInRange.isInRange)("999.999.999.999", "192.168.1.0", 24);
+      }).toThrow("Invalid IP address format: Error: Invalid IP address format");
+    });
   });
 });