umt 2.1.2 → 2.2.1

package/module/es5/tests/unit/Color/hexaToRgba.test.js

@@ -2,7 +2,7 @@
 
 var _hexaToRgba = require("@/Color/hexaToRgba");
 describe("hexaToRgba", function () {
-  it("should convert valid hex code to rgba", function () {
+  it("should convert 6-digit hex code to rgba", function () {
     expect((0, _hexaToRgba.hexaToRgba)("#FF0000")).toEqual({
       r: 255,
       g: 0,
@@ -46,6 +46,58 @@ describe("hexaToRgba", function () {
       a: 0.6
     });
   });
+  it("should convert 3-digit hex code to rgba", function () {
+    expect((0, _hexaToRgba.hexaToRgba)("#F00")).toEqual({
+      r: 255,
+      g: 0,
+      b: 0,
+      a: 1
+    });
+    expect((0, _hexaToRgba.hexaToRgba)("#0F0")).toEqual({
+      r: 0,
+      g: 255,
+      b: 0,
+      a: 1
+    });
+    expect((0, _hexaToRgba.hexaToRgba)("#00F")).toEqual({
+      r: 0,
+      g: 0,
+      b: 255,
+      a: 1
+    });
+    expect((0, _hexaToRgba.hexaToRgba)("#FFF")).toEqual({
+      r: 255,
+      g: 255,
+      b: 255,
+      a: 1
+    });
+    expect((0, _hexaToRgba.hexaToRgba)("#000")).toEqual({
+      r: 0,
+      g: 0,
+      b: 0,
+      a: 1
+    });
+  });
+  it("should convert 8-digit hex code to rgba", function () {
+    expect((0, _hexaToRgba.hexaToRgba)("#FF0000FF")).toEqual({
+      r: 255,
+      g: 0,
+      b: 0,
+      a: 1
+    });
+    expect((0, _hexaToRgba.hexaToRgba)("#FF000080")).toEqual({
+      r: 255,
+      g: 0,
+      b: 0,
+      a: 0.5
+    });
+    expect((0, _hexaToRgba.hexaToRgba)("#FF000000")).toEqual({
+      r: 255,
+      g: 0,
+      b: 0,
+      a: 0
+    });
+  });
   it("should throw an error for invalid hex code", function () {
     expect(function () {
       return (0, _hexaToRgba.hexaToRgba)("#12345");

package/module/es5/tests/unit/Color/hslaToRgba.test.js

@@ -1,7 +1,7 @@
 "use strict";
 
 var _hslaToRgba = require("@/Color/hslaToRgba");
-describe("hslaToRgba関数のテスト", function () {
+describe("hslaToRgba function", function () {
   it.each([[0, 100, 50, 1, {
     r: 255,
     g: 0,
@@ -47,7 +47,7 @@ describe("hslaToRgba関数のテスト", function () {
     g: 0,
     b: 0,
     a: 0.5
-  }]])("HSLA(%i, %i%, %i%, %i)をRGBAに変換する", function (h, s, l, a, expected) {
+  }]])("should convert HSLA(%i, %i%, %i%, %i) to RGBA", function (h, s, l, a, expected) {
     expect((0, _hslaToRgba.hslaToRgba)(h, s, l, a)).toEqual(expected);
   });
   it.each([[0, 0, 0, {
@@ -65,7 +65,7 @@ describe("hslaToRgba関数のテスト", function () {
     g: 0,
     b: 0,
     a: 1
-  }]])("HSLA(%i, %i%, %i%)をRGBAに変換する", function (h, s, l, expected) {
+  }]])("should convert HSLA(%i, %i%, %i%) to RGBA", function (h, s, l, expected) {
     expect((0, _hslaToRgba.hslaToRgba)(h, s, l)).toEqual(expected);
   });
   it.each([[240, 100, 25, 1, {
@@ -103,57 +103,39 @@ describe("hslaToRgba関数のテスト", function () {
     g: 63.75,
     b: 63.75,
     a: 1
-  }]])("HSLA(%i, %i%, %i%, %i)をRGBAに変換する", function (h, s, l, a, expected) {
+  }]])("should convert HSLA(%i, %i%, %i%, %i) to RGBA", function (h, s, l, a, expected) {
     expect((0, _hslaToRgba.hslaToRgba)(h, s, l, a)).toEqual(expected);
   });
-  it("不正な値を渡した場合の挙動", function () {
-    expect((0, _hslaToRgba.hslaToRgba)(-60, 100, 50, 1)).toEqual({
-      r: 0,
-      g: 0,
-      b: 0,
-      a: 1
-    });
-    expect((0, _hslaToRgba.hslaToRgba)(420, 100, 50, 1)).toEqual({
-      r: 0,
-      g: 0,
-      b: 0,
-      a: 1
-    });
-    expect((0, _hslaToRgba.hslaToRgba)(0, -50, 50, 1)).toEqual({
-      r: 0,
-      g: 0,
-      b: 0,
-      a: 1
-    });
-    expect((0, _hslaToRgba.hslaToRgba)(0, 150, 50, 1)).toEqual({
-      r: 0,
-      g: 0,
-      b: 0,
-      a: 1
-    });
-    expect((0, _hslaToRgba.hslaToRgba)(0, 100, -20, 1)).toEqual({
-      r: 0,
-      g: 0,
-      b: 0,
-      a: 1
-    });
-    expect((0, _hslaToRgba.hslaToRgba)(0, 100, 120, 1)).toEqual({
-      r: 0,
-      g: 0,
-      b: 0,
-      a: 1
-    });
-    expect((0, _hslaToRgba.hslaToRgba)(0, 100, 50, -0.5)).toEqual({
-      r: 0,
-      g: 0,
-      b: 0,
-      a: 1
-    });
-    expect((0, _hslaToRgba.hslaToRgba)(0, 100, 50, 1.5)).toEqual({
-      r: 0,
-      g: 0,
-      b: 0,
-      a: 1
-    });
+  it("should throw error for invalid hue values", function () {
+    expect(function () {
+      return (0, _hslaToRgba.hslaToRgba)(-60, 100, 50, 1);
+    }).toThrow("Hue must be between 0 and 360 degrees");
+    expect(function () {
+      return (0, _hslaToRgba.hslaToRgba)(420, 100, 50, 1);
+    }).toThrow("Hue must be between 0 and 360 degrees");
+  });
+  it("should throw error for invalid saturation values", function () {
+    expect(function () {
+      return (0, _hslaToRgba.hslaToRgba)(0, -50, 50, 1);
+    }).toThrow("Saturation must be between 0 and 100 percent");
+    expect(function () {
+      return (0, _hslaToRgba.hslaToRgba)(0, 150, 50, 1);
+    }).toThrow("Saturation must be between 0 and 100 percent");
+  });
+  it("should throw error for invalid lightness values", function () {
+    expect(function () {
+      return (0, _hslaToRgba.hslaToRgba)(0, 100, -20, 1);
+    }).toThrow("Lightness must be between 0 and 100 percent");
+    expect(function () {
+      return (0, _hslaToRgba.hslaToRgba)(0, 100, 120, 1);
+    }).toThrow("Lightness must be between 0 and 100 percent");
+  });
+  it("should throw error for invalid alpha values", function () {
+    expect(function () {
+      return (0, _hslaToRgba.hslaToRgba)(0, 100, 50, -0.5);
+    }).toThrow("Alpha must be between 0 and 1");
+    expect(function () {
+      return (0, _hslaToRgba.hslaToRgba)(0, 100, 50, 1.5);
+    }).toThrow("Alpha must be between 0 and 1");
   });
 });

package/module/es5/tests/unit/Color/rgbaToCmyk.test.js

@@ -2,6 +2,72 @@
 
 var _rgbaToCmyk = require("@/Color/rgbaToCmyk");
 describe("rgbaToCmyk", function () {
+  it("should throw an error for invalid rgba values", function () {
+    expect(function () {
+      return (0, _rgbaToCmyk.rgbaToCmyk)({
+        r: -1,
+        g: 0,
+        b: 0,
+        a: 1
+      });
+    }).toThrow("Invalid rgba value");
+    expect(function () {
+      return (0, _rgbaToCmyk.rgbaToCmyk)({
+        r: 256,
+        g: 0,
+        b: 0,
+        a: 1
+      });
+    }).toThrow("Invalid rgba value");
+    expect(function () {
+      return (0, _rgbaToCmyk.rgbaToCmyk)({
+        r: 0,
+        g: -1,
+        b: 0,
+        a: 1
+      });
+    }).toThrow("Invalid rgba value");
+    expect(function () {
+      return (0, _rgbaToCmyk.rgbaToCmyk)({
+        r: 0,
+        g: 256,
+        b: 0,
+        a: 1
+      });
+    }).toThrow("Invalid rgba value");
+    expect(function () {
+      return (0, _rgbaToCmyk.rgbaToCmyk)({
+        r: 0,
+        g: 0,
+        b: -1,
+        a: 1
+      });
+    }).toThrow("Invalid rgba value");
+    expect(function () {
+      return (0, _rgbaToCmyk.rgbaToCmyk)({
+        r: 0,
+        g: 0,
+        b: 256,
+        a: 1
+      });
+    }).toThrow("Invalid rgba value");
+    expect(function () {
+      return (0, _rgbaToCmyk.rgbaToCmyk)({
+        r: 0,
+        g: 0,
+        b: 0,
+        a: -0.1
+      });
+    }).toThrow("Invalid rgba value");
+    expect(function () {
+      return (0, _rgbaToCmyk.rgbaToCmyk)({
+        r: 0,
+        g: 0,
+        b: 0,
+        a: 1.1
+      });
+    }).toThrow("Invalid rgba value");
+  });
   it.each([[{
     r: 255,
     g: 255,
@@ -67,7 +133,7 @@ describe("rgbaToCmyk", function () {
     y: 0,
     k: 0,
     a: 1
-  }]])("RGBA(%o)をCMYKに変換する", function (input, expected) {
+  }]])("should convert RGBA(%o) to CMYK", function (input, expected) {
     expect((0, _rgbaToCmyk.rgbaToCmyk)(input)).toEqual(expected);
   });
 });

package/module/es5/tests/unit/Color/rgbaToHsla.test.js

@@ -2,6 +2,96 @@
 
 var _rgbaToHsla = require("@/Color/rgbaToHsla");
 describe("rgbaToHsla", function () {
+  it("should throw error for invalid rgba values", function () {
+    expect(function () {
+      return (0, _rgbaToHsla.rgbaToHsla)({
+        r: -1,
+        g: 0,
+        b: 0,
+        a: 1
+      });
+    }).toThrow("Invalid rgba value");
+    expect(function () {
+      return (0, _rgbaToHsla.rgbaToHsla)({
+        r: 256,
+        g: 0,
+        b: 0,
+        a: 1
+      });
+    }).toThrow("Invalid rgba value");
+    expect(function () {
+      return (0, _rgbaToHsla.rgbaToHsla)({
+        r: 0,
+        g: -1,
+        b: 0,
+        a: 1
+      });
+    }).toThrow("Invalid rgba value");
+    expect(function () {
+      return (0, _rgbaToHsla.rgbaToHsla)({
+        r: 0,
+        g: 256,
+        b: 0,
+        a: 1
+      });
+    }).toThrow("Invalid rgba value");
+    expect(function () {
+      return (0, _rgbaToHsla.rgbaToHsla)({
+        r: 0,
+        g: 0,
+        b: -1,
+        a: 1
+      });
+    }).toThrow("Invalid rgba value");
+    expect(function () {
+      return (0, _rgbaToHsla.rgbaToHsla)({
+        r: 0,
+        g: 0,
+        b: 256,
+        a: 1
+      });
+    }).toThrow("Invalid rgba value");
+    expect(function () {
+      return (0, _rgbaToHsla.rgbaToHsla)({
+        r: 0,
+        g: 0,
+        b: 0,
+        a: -0.1
+      });
+    }).toThrow("Invalid rgba value");
+    expect(function () {
+      return (0, _rgbaToHsla.rgbaToHsla)({
+        r: 0,
+        g: 0,
+        b: 0,
+        a: 1.1
+      });
+    }).toThrow("Invalid rgba value");
+  });
+  it("should handle edge cases correctly", function () {
+    // Black
+    expect((0, _rgbaToHsla.rgbaToHsla)({
+      r: 0,
+      g: 0,
+      b: 0
+    })).toEqual({
+      h: 0,
+      s: 0,
+      l: 0,
+      a: 1
+    });
+    // White
+    expect((0, _rgbaToHsla.rgbaToHsla)({
+      r: 255,
+      g: 255,
+      b: 255
+    })).toEqual({
+      h: 0,
+      s: 0,
+      l: 100,
+      a: 1
+    });
+  });
   it.each([[{
     r: 100,
     g: 100,
@@ -94,7 +184,7 @@ describe("rgbaToHsla", function () {
     s: 100,
     l: 50,
     a: 1
-  }]])("RGB(%o)をHSLAに変換する", function (input, expected) {
+  }]])("should convert RGB(%o) to HSLA", function (input, expected) {
     expect((0, _rgbaToHsla.rgbaToHsla)(input)).toEqual(expected);
   });
 });

package/module/es5/tests/unit/Consts/clock.test.js

@@ -1,38 +1,71 @@
 "use strict";
 
 var _clock = require("@/Consts/clock");
-describe("時間定数のテスト", function () {
-  it("1秒は1000ミリ秒", function () {
-    expect(_clock.OneSecondMs).toBe(1000);
+describe("Time constants", function () {
+  describe("Basic time unit values", function () {
+    it("should define one second as 1000 milliseconds", function () {
+      expect(_clock.OneSecondMs).toBe(1000);
+    });
+    it("should define one minute as 60000 milliseconds", function () {
+      expect(_clock.OneMinuteMs).toBe(60000);
+    });
+    it("should define one hour as 3600000 milliseconds", function () {
+      expect(_clock.OneHourMs).toBe(3600000);
+    });
+    it("should define one day as 86400000 milliseconds", function () {
+      expect(_clock.OneDayMs).toBe(86400000);
+    });
+    it("should define one week as 604800000 milliseconds", function () {
+      expect(_clock.OneWeekMs).toBe(604800000);
+    });
   });
-  it("1分は60000ミリ秒", function () {
-    expect(_clock.OneMinuteMs).toBe(60000);
+  describe("Time unit relationships", function () {
+    it("should maintain correct relationships between units", function () {
+      expect(_clock.OneMinuteMs).toBe(_clock.OneSecondMs * 60);
+      expect(_clock.OneHourMs).toBe(_clock.OneMinuteMs * 60);
+      expect(_clock.OneDayMs).toBe(_clock.OneHourMs * 24);
+      expect(_clock.OneWeekMs).toBe(_clock.OneDayMs * 7);
+    });
   });
-  it("1時間は3600000ミリ秒", function () {
-    expect(_clock.OneHourMs).toBe(3600000);
+  describe("Month variations", function () {
+    it("should define correct relationships for different month lengths", function () {
+      expect(_clock.OneMonthMs28).toBe(_clock.OneDayMs * 28);
+      expect(_clock.OneMonthMs29).toBe(_clock.OneDayMs * 29);
+      expect(_clock.OneMonthMs).toBe(_clock.OneDayMs * 30);
+      expect(_clock.OneMonthMs31).toBe(_clock.OneDayMs * 31);
+    });
+    it("should maintain correct order of month lengths", function () {
+      expect(_clock.OneMonthMs28).toBeLessThan(_clock.OneMonthMs29);
+      expect(_clock.OneMonthMs29).toBeLessThan(_clock.OneMonthMs);
+      expect(_clock.OneMonthMs).toBeLessThan(_clock.OneMonthMs31);
+    });
   });
-  it("1日は86400000ミリ秒", function () {
-    expect(_clock.OneDayMs).toBe(86400000);
+  describe("Year variations", function () {
+    it("should define correct relationships for different year lengths", function () {
+      expect(_clock.OneYearMs).toBe(_clock.OneDayMs * 365);
+      expect(_clock.OneYearMs366).toBe(_clock.OneDayMs * 366);
+    });
+    it("should maintain correct relationship between regular and leap years", function () {
+      expect(_clock.OneYearMs).toBeLessThan(_clock.OneYearMs366);
+      expect(_clock.OneYearMs366 - _clock.OneYearMs).toBe(_clock.OneDayMs);
+    });
   });
-  it("1週間は604800000ミリ秒", function () {
-    expect(_clock.OneWeekMs).toBe(604800000);
-  });
-  it("1ヶ月（28日として）は2419200000ミリ秒", function () {
+  it("should define one month (28 days) as 2419200000 milliseconds", function () {
     expect(_clock.OneMonthMs28).toBe(2419200000);
   });
-  it("1ヶ月（29日として）は2505600000ミリ秒", function () {
+  it("should define one month (29 days) as 2505600000 milliseconds", function () {
     expect(_clock.OneMonthMs29).toBe(2505600000);
   });
-  it("1ヶ月（30日として）は2592000000ミリ秒", function () {
+  it("should define one month (30 days) as 2592000000 milliseconds", function () {
     expect(_clock.OneMonthMs).toBe(2592000000);
   });
-  it("1ヶ月（31日として）は2678400000ミリ秒", function () {
+  it("should define one month (31 days) as 2678400000 milliseconds", function () {
     expect(_clock.OneMonthMs31).toBe(2678400000);
   });
-  it("1年（365日として）は31536000000ミリ秒", function () {
+  it("should define one year (365 days) as 31536000000 milliseconds", function () {
     expect(_clock.OneYearMs).toBe(31536000000);
   });
-  it("1年（366日として）は31622400000ミリ秒", function () {
+  it("should define one year (366 days) as 31622400000 milliseconds", function () {
     expect(_clock.OneYearMs366).toBe(31622400000);
   });
 });

package/module/es5/tests/unit/Consts/httpStatus.test.js

@@ -2,6 +2,15 @@
 
 var _httpStatus = require("@/Consts/httpStatus");
 describe("HttpStatus", function () {
+  describe("Exports", function () {
+    it("should export all HTTP status types", function () {
+      expect(_httpStatus.HttpClientErrorStatus).toBeDefined();
+      expect(_httpStatus.HttpInformationalStatus).toBeDefined();
+      expect(_httpStatus.HttpRedirectionStatus).toBeDefined();
+      expect(_httpStatus.HttpServerErrorStatus).toBeDefined();
+      expect(_httpStatus.HttpSuccessStatus).toBeDefined();
+    });
+  });
   describe("1xx Informational", function () {
     it("should have correct informational status codes", function () {
       expect(_httpStatus.HttpStatus.CONTINUE).toBe(100);

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

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

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

@@ -0,0 +1,31 @@
+"use strict";
+
+var _birthday = require("@/Date/birthday");
+describe("birthday", function () {
+  beforeEach(function () {
+    // Mock current date to 2025-04-04
+    jest.useFakeTimers();
+    jest.setSystemTime(new Date("2025-04-04"));
+  });
+  afterEach(function () {
+    jest.useRealTimers();
+  });
+  it("should calculate age correctly for past birthday this year", function () {
+    // Someone born on January 1, 2000 would be 25 on April 4, 2025
+    expect((0, _birthday.birthday)(2000, 1, 1)).toBe(25);
+  });
+  it("should calculate age correctly for future birthday this year", function () {
+    // Someone born on December 31, 2000 would still be 24 on April 4, 2025
+    expect((0, _birthday.birthday)(2000, 12, 31)).toBe(24);
+  });
+  it("should handle two-digit years", function () {
+    // Year 99 should be treated as year 1999 (26 years before 2025)
+    expect((0, _birthday.birthday)(99, 1, 1)).toBe(1926);
+  });
+  it("should handle timezone offset", function () {
+    // Test with default timezone (UTC+9)
+    expect((0, _birthday.birthday)(2000, 1, 1)).toBe(25);
+    // Test with different timezone (UTC+0)
+    expect((0, _birthday.birthday)(2000, 1, 1, 0)).toBe(25);
+  });
+});

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

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

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

@@ -0,0 +1,40 @@
+"use strict";
+
+var _dateRange = require("@/Date/dateRange");
+describe("dateRange", function () {
+  it("should generate array of dates between start and end dates", function () {
+    var start = new Date("2025-01-01");
+    var end = new Date("2025-01-03");
+    var dates = (0, _dateRange.dateRange)(start, end);
+    expect(dates).toHaveLength(3);
+    expect(dates[0]).toEqual(new Date("2025-01-01"));
+    expect(dates[1]).toEqual(new Date("2025-01-02"));
+    expect(dates[2]).toEqual(new Date("2025-01-03"));
+  });
+  it("should handle single day range", function () {
+    var date = new Date("2025-01-01");
+    var dates = (0, _dateRange.dateRange)(date, date);
+    expect(dates).toHaveLength(1);
+    expect(dates[0]).toEqual(new Date("2025-01-01"));
+  });
+  it("should create new Date instances", function () {
+    var start = new Date("2025-01-01");
+    var end = new Date("2025-01-01");
+    var dates = (0, _dateRange.dateRange)(start, end);
+
+    // Modify the original date to ensure we have a new instance
+    start.setDate(2);
+    expect(dates[0]).not.toBe(start);
+    expect(dates[0].getDate()).toBe(1);
+  });
+  it("should handle month and year transitions", function () {
+    var start = new Date("2024-12-30");
+    var end = new Date("2025-01-02");
+    var dates = (0, _dateRange.dateRange)(start, end);
+    expect(dates).toHaveLength(4);
+    expect(dates[0]).toEqual(new Date("2024-12-30"));
+    expect(dates[1]).toEqual(new Date("2024-12-31"));
+    expect(dates[2]).toEqual(new Date("2025-01-01"));
+    expect(dates[3]).toEqual(new Date("2025-01-02"));
+  });
+});

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

@@ -2,8 +2,8 @@
 
 var _Date = require("@/Date");
 var _dayOfWeek = require("@/Date/dayOfWeek");
-describe("isArr", function () {
-  it("dayOfWeek", function () {
+describe("dayOfWeek function", function () {
+  it("should return correct day of week for a given date", function () {
     expect((0, _dayOfWeek.dayOfWeek)({
       year: 2020,
       mon: 1,
@@ -15,7 +15,7 @@ describe("isArr", function () {
       day: 2
     })).toBe(4);
   });
-  it("year is undefined", function () {
+  it("should use current year when year is not provided", function () {
     var nowDate = (0, _Date.now)();
     nowDate.setMonth(0);
     nowDate.setDate(2);
@@ -24,14 +24,14 @@ describe("isArr", function () {
       day: 2
     })).toBe(nowDate.getDay());
   });
-  it("year and mon is undefined", function () {
+  it("should use current year and month when both are not provided", function () {
     var nowDate = (0, _Date.now)();
     nowDate.setDate(2);
     expect((0, _dayOfWeek.dayOfWeek)({
       day: 2
     })).toBe(nowDate.getDay());
   });
-  it("props is undefined", function () {
+  it("should use current date when no parameters are provided", function () {
     var nowDate = (0, _Date.now)();
     expect((0, _dayOfWeek.dayOfWeek)({})).toBe(nowDate.getDay());
     expect((0, _dayOfWeek.dayOfWeek)()).toBe((0, _Date.now)().getDay());

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

@@ -25,4 +25,26 @@ describe("format", function () {
     expect((0, _format.format)(date, "hh:mm:ss A")).toBe("03:30:45 PM");
     expect((0, _format.format)(date, "h:m:s a")).toBe("3:30:45 pm");
   });
+  it("should handle day of week format", function () {
+    var date = new Date(2023, 5, 10); // June 10, 2023 was a Saturday
+    expect((0, _format.format)(date, "d")).toBe("6");
+    expect((0, _format.format)(date, "YYYY-MM-DD (d)")).toBe("2023-06-10 (6)");
+  });
+  it("should handle morning hours correctly", function () {
+    var date = new Date(2023, 5, 10, 9, 5, 8, 4);
+    expect((0, _format.format)(date, "HH:mm:ss")).toBe("09:05:08");
+    expect((0, _format.format)(date, "H:m:s")).toBe("9:5:8");
+    expect((0, _format.format)(date, "hh:mm A")).toBe("09:05 AM");
+    expect((0, _format.format)(date, "h:mm a")).toBe("9:05 am");
+  });
+  it("should handle invalid date", function () {
+    // @ts-expect-error Testing invalid input
+    expect(function () {
+      return (0, _format.format)("not a date");
+    }).toThrow("Invalid Date in format");
+    // @ts-expect-error Testing invalid input
+    expect(function () {
+      return (0, _format.format)(null);
+    }).toThrow("Invalid Date in format");
+  });
 });

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

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

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

@@ -0,0 +1,40 @@
+"use strict";
+
+var _getDay = require("@/Date/getDay");
+describe("getDay", function () {
+  it("should return Sunday in different languages", function () {
+    expect((0, _getDay.getDay)(0, "en")).toBe("Sun");
+    expect((0, _getDay.getDay)(0, "ja")).toBe("日");
+    expect((0, _getDay.getDay)(0, "ko")).toBe("일");
+    expect((0, _getDay.getDay)(0, "de")).toBe("So");
+    expect((0, _getDay.getDay)(0, "fr")).toBe("Dim");
+  });
+  it("should return weekdays in different languages", function () {
+    // Test Wednesday (3) in different languages
+    expect((0, _getDay.getDay)(3, "en")).toBe("Wed");
+    expect((0, _getDay.getDay)(3, "ja")).toBe("水");
+    expect((0, _getDay.getDay)(3, "ko")).toBe("수");
+    expect((0, _getDay.getDay)(3, "de")).toBe("Mi");
+    expect((0, _getDay.getDay)(3, "fr")).toBe("Mer");
+  });
+  it("should use Japanese as default language", function () {
+    expect((0, _getDay.getDay)(0)).toBe("日");
+    expect((0, _getDay.getDay)(1)).toBe("月");
+    expect((0, _getDay.getDay)(2)).toBe("火");
+    expect((0, _getDay.getDay)(3)).toBe("水");
+    expect((0, _getDay.getDay)(4)).toBe("木");
+    expect((0, _getDay.getDay)(5)).toBe("金");
+    expect((0, _getDay.getDay)(6)).toBe("土");
+  });
+  it("should return Sunday for invalid day numbers", function () {
+    expect((0, _getDay.getDay)(-1)).toBe("日");
+    expect((0, _getDay.getDay)(7)).toBe("日");
+    expect((0, _getDay.getDay)(100)).toBe("日");
+  });
+  it("should handle all days in English", function () {
+    var days = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+    days.forEach(function (day, index) {
+      expect((0, _getDay.getDay)(index, "en")).toBe(day);
+    });
+  });
+});