@beinformed/ui 1.58.4 → 1.59.0

package/src/utils/datetime/__tests__/DateTime.spec.js

@@ -5,10 +5,12 @@ import {
   TimestampUtil,
 } from "../DateTimeUtil";
 import {
+  INCLUDE_TIME_OFFSET,
   ISO_DATE_FORMAT,
   ISO_DATETIME_FORMAT,
   ISO_TIME_FORMAT,
   ISO_TIMESTAMP_FORMAT,
+  DATETIME_OFFSET_FORMAT,
 } from "../../../constants";
 
 import { setSettings } from "../../../constants/Settings";
@@ -16,10 +18,10 @@ import { setSettings } from "../../../constants/Settings";
 const DUTCH_DATE_FORMAT = "dd-MM-yyyy";
 const DUTCH_DATETIME_FORMAT = "dd-MM-yyyy HH:mm";
 
-const DUTCH_DATE = "13-06-2017";
-const DUTCH_DATETIME = "13-06-2017 14:15";
+const INPUT_13_06_2017 = "13-06-2017";
+const INPUT_13_06_2017_14_15 = "13-06-2017 14:15";
 
-const ISO_DATE = "2017-06-13";
+const ISO_2017_06_13 = "2017-06-13";
 
 const INVALID_DATE = "Invalid Date";
 
@@ -31,548 +33,834 @@ const ISO_1979_12_31 = "1979-12-31";
 const ISO_1980_01_15 = "1980-01-15";
 
 const ISO_1980_10_18T13_20_00 = "1980-10-18T13:20:00";
+const ISO_1980_01_01T13_20_00 = "1980-01-01T13:20:00";
+
+const ISO_1980_10_18T13_20_00_OFFSET = "1980-10-18T13:20:00+02:00"; // CEST
+const ISO_1980_01_01T13_20_00_OFFSET = "1980-01-01T13:20:00+01:00"; // CET
+
 const ISO_1980_10_18T13_20_00_000 = "1980-10-18T13:20:00.000";
 const ISO_1980_10_18T13_19_00_000 = "1980-10-18T13:19:00.000";
 const ISO_1980_10_18T13_21_00_000 = "1980-10-18T13:21:00.000";
 const ISO_1980_01_01T13_20_00_000 = "1980-01-01T13:20:00.000";
 
-describe("dateTimeUtil", () => {
-  it("should convert java date time format to moment date time format", () => {
-    expect(DateUtil.convertFormat()).toBe(ISO_DATE_FORMAT);
-    expect(DateTimeUtil.convertFormat()).toBe(ISO_DATETIME_FORMAT);
-    expect(TimeUtil.convertFormat()).toBe(ISO_TIME_FORMAT);
-    expect(TimestampUtil.convertFormat()).toBe(ISO_TIMESTAMP_FORMAT);
-
-    expect(DateUtil.convertFormat("yyyy-MM-dd")).toBe("yyyy-MM-dd");
-    expect(DateTimeUtil.convertFormat("yyyy-MM-dd HH:mm:ss")).toBe(
-      "yyyy-MM-dd HH:mm:ss",
-    );
-    expect(TimeUtil.convertFormat("HH:mm:ss")).toBe("HH:mm:ss");
-    expect(TimestampUtil.convertFormat("yyyy-MM-dd HH:mm:ss.SSS")).toBe(
-      "yyyy-MM-dd HH:mm:ss.SSS",
-    );
-  });
+describe("asserts for date/time utilities", () => {
+  beforeEach(() => {
+    DateUtil.setTimeZone("Europe/Amsterdam");
+    DateTimeUtil.setTimeZone("Europe/Amsterdam");
+    TimeUtil.setTimeZone("Europe/Amsterdam");
+    TimestampUtil.setTimeZone("Europe/Amsterdam");
 
-  it("should render iso date to specified format", () => {
-    expect(DateUtil.toFormat(ISO_DATE, DUTCH_DATE_FORMAT)).toBe(DUTCH_DATE);
-    expect(DateUtil.toFormat(ISO_DATE, "MM-dd-yyyy")).toBe("06-13-2017");
+    setSettings({ [INCLUDE_TIME_OFFSET]: false });
   });
 
-  it("should render specified format to iso date", () => {
-    expect(DateUtil.toISO(DUTCH_DATE, DUTCH_DATE_FORMAT)).toBe(ISO_DATE);
-    expect(DateUtil.toISO("06-13-2017", "MM-dd-yyyy")).toBe(ISO_DATE);
-  });
+  describe("test DateUtil", () => {
+    it("should convert java date time format to date-fns date time format", () => {
+      expect(DateUtil.convertFormat()).toBe(ISO_DATE_FORMAT);
+      expect(DateUtil.convertFormat("yyyy-MM-dd")).toBe("yyyy-MM-dd");
+    });
 
-  it("should render iso datetime to specified format", () => {
-    expect(
-      DateTimeUtil.toFormat("2017-06-13T14:15:12", DUTCH_DATETIME_FORMAT),
-    ).toBe(DUTCH_DATETIME);
-    expect(DateTimeUtil.toFormat("2017-06-13T14:15:12", "h:mm")).toBe("2:15");
-    expect(
-      DateTimeUtil.toFormat("2017-06-13T23:15:12", DUTCH_DATE_FORMAT),
-    ).toBe(DUTCH_DATE);
-  });
+    it("should render iso date to specified format", () => {
+      expect(DateUtil.toFormat(ISO_2017_06_13, DUTCH_DATE_FORMAT)).toBe(
+        INPUT_13_06_2017,
+      );
+      expect(DateUtil.toFormat(ISO_2017_06_13, "MM-dd-yyyy")).toBe(
+        "06-13-2017",
+      );
+    });
 
-  it("should render specified format to iso datetime", () => {
-    expect(DateTimeUtil.toISO(DUTCH_DATETIME, DUTCH_DATETIME_FORMAT)).toBe(
-      "2017-06-13T14:15:00",
-    );
-    expect(DateTimeUtil.toISO("13-06-2017 2:15", "dd-MM-yyyy h:mm")).toBe(
-      "2017-06-13T02:15:00",
-    );
-    expect(DateTimeUtil.toISO(DUTCH_DATE, DUTCH_DATE_FORMAT)).toBe(
-      "2017-06-13T00:00:00",
-    );
-  });
+    it("should render specified format to iso date", () => {
+      expect(DateUtil.toISO(INPUT_13_06_2017, DUTCH_DATE_FORMAT)).toBe(
+        ISO_2017_06_13,
+      );
+      expect(DateUtil.toISO("06-13-2017", "MM-dd-yyyy")).toBe(ISO_2017_06_13);
+    });
 
-  it("should render iso time to specified format", () => {
-    expect(TimeUtil.toFormat("14:15:12", "HH:mm")).toBe("14:15");
-    expect(TimeUtil.toFormat("14:15:12", "h:mm")).toBe("2:15");
-    expect(TimeUtil.toFormat("23:15:12", "h:mm")).toBe("11:15");
-  });
+    it("should return invalid date when date entered is not a date", () => {
+      expect(DateUtil.toISO("bla", DUTCH_DATE_FORMAT)).toBe(INVALID_DATE);
+    });
 
-  it("should render specified format to iso time", () => {
-    expect(TimeUtil.toISO("14:15", "HH:mm")).toBe("14:15:00");
-    expect(TimeUtil.toISO("2:15 AM", "h:mm aa")).toBe("02:15:00");
-    expect(TimeUtil.toISO("02:15 PM", "hh:mm aa")).toBe("14:15:00");
-    expect(TimeUtil.toISO("11:15 AM", "h:mm aa")).toBe("11:15:00");
-  });
+    describe("asserts", () => {
+      it("hasFormat", () => {
+        expect(DateUtil.hasFormat("18-10-1980", DUTCH_DATE_FORMAT)).toBe(true);
+        expect(DateUtil.hasFormat("18-1-1980", DUTCH_DATE_FORMAT)).toBe(true);
+        expect(DateUtil.hasFormat("18-1980", DUTCH_DATE_FORMAT)).toBe(false);
+      });
 
-  it("should render iso timestamp to specified format", () => {
-    expect(
-      TimestampUtil.toFormat("2017-06-13T14:15:12.000", DUTCH_DATETIME_FORMAT),
-    ).toBe(DUTCH_DATETIME);
-    expect(TimestampUtil.toFormat("2017-06-13T14:15:12.000", "h:mm")).toBe(
-      "2:15",
-    );
-    expect(
-      TimestampUtil.toFormat("2017-06-13T23:15:12.000", DUTCH_DATE_FORMAT),
-    ).toBe(DUTCH_DATE);
-  });
+      it("isValid", () => {
+        expect(DateUtil.isValid("18-10-1980", DUTCH_DATE_FORMAT)).toBe(true);
+        expect(DateUtil.isValid("bla", DUTCH_DATE_FORMAT)).toBe(false);
+      });
 
-  it("should render specified format to iso timestamp", () => {
-    expect(TimestampUtil.toISO(DUTCH_DATETIME, DUTCH_DATETIME_FORMAT)).toBe(
-      "2017-06-13T14:15:00.000",
-    );
-    expect(TimestampUtil.toISO("13-06-2017 2:15", "dd-MM-yyyy h:mm")).toBe(
-      "2017-06-13T02:15:00.000",
-    );
-    expect(TimestampUtil.toISO(DUTCH_DATE, DUTCH_DATE_FORMAT)).toBe(
-      "2017-06-13T00:00:00.000",
-    );
-  });
+      it("isAfter", () => {
+        expect(DateUtil.isAfter(ISO_1980_10_18, ISO_1980_10_17)).toBe(true);
+        expect(DateUtil.isAfter(ISO_1980_10_18, ISO_1980_10_18)).toBe(false);
+        expect(DateUtil.isAfter(ISO_1980_10_18, ISO_1980_10_19)).toBe(false);
+      });
 
-  it("should return invalid date when date entered is not a date", () => {
-    expect(DateUtil.toISO("bla", DUTCH_DATE_FORMAT)).toBe(INVALID_DATE);
-    expect(DateTimeUtil.toISO("bla", DUTCH_DATETIME_FORMAT)).toBe(INVALID_DATE);
-    expect(TimeUtil.toISO("bla", "HH:mm")).toBe(INVALID_DATE);
-    expect(TimestampUtil.toISO("bla", DUTCH_DATETIME_FORMAT)).toBe(
-      INVALID_DATE,
-    );
-  });
+      it("isSameOrAfter", () => {
+        expect(DateUtil.isSameOrAfter(ISO_1980_10_18, ISO_1980_10_17)).toBe(
+          true,
+        );
+        expect(DateUtil.isSameOrAfter(ISO_1980_10_18, ISO_1980_10_18)).toBe(
+          true,
+        );
+        expect(DateUtil.isSameOrAfter(ISO_1980_10_18, ISO_1980_10_19)).toBe(
+          false,
+        );
+      });
 
-  it("hasFormat", () => {
-    expect(DateUtil.hasFormat("18-10-1980", DUTCH_DATE_FORMAT)).toBe(true);
-    expect(DateUtil.hasFormat("18-1-1980", DUTCH_DATE_FORMAT)).toBe(true);
-    expect(DateUtil.hasFormat("18-1980", DUTCH_DATE_FORMAT)).toBe(false);
-  });
+      it("isBefore", () => {
+        expect(DateUtil.isBefore(ISO_1980_10_18, ISO_1980_10_17)).toBe(false);
+        expect(DateUtil.isBefore(ISO_1980_10_18, ISO_1980_10_18)).toBe(false);
+        expect(DateUtil.isBefore(ISO_1980_10_18, ISO_1980_10_19)).toBe(true);
+      });
 
-  it("isValid", () => {
-    expect(DateUtil.isValid("18-10-1980", DUTCH_DATE_FORMAT)).toBe(true);
-    expect(
-      DateTimeUtil.isValid("18-10-1980 13:20", DUTCH_DATETIME_FORMAT),
-    ).toBe(true);
-    expect(TimeUtil.isValid("13:20", "HH:mm")).toBe(true);
-    expect(
-      TimestampUtil.isValid("18-10-1980 13:20", DUTCH_DATETIME_FORMAT),
-    ).toBe(true);
-
-    expect(DateUtil.isValid("bla", DUTCH_DATE_FORMAT)).toBe(false);
-    expect(DateTimeUtil.isValid("bla", DUTCH_DATETIME_FORMAT)).toBe(false);
-    expect(TimeUtil.isValid("bla", "HH:mm")).toBe(false);
-    expect(TimestampUtil.isValid("bla", DUTCH_DATETIME_FORMAT)).toBe(false);
-  });
+      it("isSameOrBefore", () => {
+        expect(DateUtil.isSameOrBefore(ISO_1980_10_18, ISO_1980_10_17)).toBe(
+          false,
+        );
+        expect(DateUtil.isSameOrBefore(ISO_1980_10_18, ISO_1980_10_18)).toBe(
+          true,
+        );
+        expect(DateUtil.isSameOrBefore(ISO_1980_10_18, ISO_1980_10_19)).toBe(
+          true,
+        );
+      });
 
-  it("isAfter", () => {
-    expect(DateUtil.isAfter(ISO_1980_10_18, ISO_1980_10_17)).toBe(true);
-    expect(
-      DateTimeUtil.isAfter(ISO_1980_10_18T13_20_00, "1980-10-18T13:19:00"),
-    ).toBe(true);
-    expect(TimeUtil.isAfter("13:20:00", "13:19:00")).toBe(true);
-    expect(
-      TimestampUtil.isAfter(
-        ISO_1980_10_18T13_20_00_000,
-        ISO_1980_10_18T13_19_00_000,
-      ),
-    ).toBe(true);
-
-    expect(DateUtil.isAfter(ISO_1980_10_18, ISO_1980_10_18)).toBe(false);
-    expect(
-      DateTimeUtil.isAfter(ISO_1980_10_18T13_20_00, ISO_1980_10_18T13_20_00),
-    ).toBe(false);
-    expect(TimeUtil.isAfter("13:20:00", "13:20:00")).toBe(false);
-    expect(
-      TimestampUtil.isAfter(
-        ISO_1980_10_18T13_20_00_000,
-        ISO_1980_10_18T13_20_00_000,
-      ),
-    ).toBe(false);
-
-    expect(DateUtil.isAfter(ISO_1980_10_18, ISO_1980_10_19)).toBe(false);
-    expect(
-      DateTimeUtil.isAfter(ISO_1980_10_18T13_20_00, "1980-10-18T13:21:00"),
-    ).toBe(false);
-    expect(TimeUtil.isAfter("13:20:00", "13:21:00")).toBe(false);
-    expect(
-      TimestampUtil.isAfter(
-        ISO_1980_10_18T13_20_00_000,
-        ISO_1980_10_18T13_21_00_000,
-      ),
-    ).toBe(false);
-  });
+      it("isSame", () => {
+        expect(DateUtil.isSame(ISO_1980_10_18, ISO_1980_10_17)).toBe(false);
+        expect(DateUtil.isSame(ISO_1980_10_18, ISO_1980_10_18)).toBe(true);
+        expect(DateUtil.isSame(ISO_1980_10_18, ISO_1980_10_19)).toBe(false);
+      });
 
-  it("isSameOrAfter", () => {
-    expect(DateUtil.isSameOrAfter(ISO_1980_10_18, ISO_1980_10_17)).toBe(true);
-    expect(
-      DateTimeUtil.isSameOrAfter(
-        ISO_1980_10_18T13_20_00,
-        "1980-10-18T13:19:00",
-      ),
-    ).toBe(true);
-    expect(TimeUtil.isSameOrAfter("13:20:00", "13:19:00")).toBe(true);
-    expect(
-      TimestampUtil.isSameOrAfter(
-        ISO_1980_10_18T13_20_00_000,
-        ISO_1980_10_18T13_19_00_000,
-      ),
-    ).toBe(true);
-
-    expect(DateUtil.isSameOrAfter(ISO_1980_10_18, ISO_1980_10_18)).toBe(true);
-    expect(
-      DateTimeUtil.isSameOrAfter(
-        ISO_1980_10_18T13_20_00,
-        ISO_1980_10_18T13_20_00,
-      ),
-    ).toBe(true);
-    expect(TimeUtil.isSameOrAfter("13:20:00", "13:20:00")).toBe(true);
-    expect(
-      TimestampUtil.isSameOrAfter(
-        ISO_1980_10_18T13_20_00_000,
-        ISO_1980_10_18T13_20_00_000,
-      ),
-    ).toBe(true);
-
-    expect(DateUtil.isSameOrAfter(ISO_1980_10_18, ISO_1980_10_19)).toBe(false);
-    expect(TimeUtil.isSameOrAfter("13:20:00", "13:21:00")).toBe(false);
-    expect(
-      TimestampUtil.isSameOrAfter(
-        ISO_1980_10_18T13_20_00_000,
-        ISO_1980_10_18T13_21_00_000,
-      ),
-    ).toBe(false);
-  });
+      it("isSameDay", () => {
+        expect(DateUtil.isSameDay(ISO_1980_10_18, ISO_1980_10_17)).toBe(false);
+        expect(DateUtil.isSameDay(ISO_1980_10_18, ISO_1980_10_18)).toBe(true);
+      });
 
-  it("isBefore", () => {
-    expect(DateUtil.isBefore(ISO_1980_10_18, ISO_1980_10_17)).toBe(false);
-    expect(TimeUtil.isBefore("13:20:00", "13:19:00")).toBe(false);
-    expect(
-      TimestampUtil.isBefore(
-        ISO_1980_10_18T13_20_00_000,
-        ISO_1980_10_18T13_19_00_000,
-      ),
-    ).toBe(false);
-
-    expect(DateUtil.isBefore(ISO_1980_10_18, ISO_1980_10_18)).toBe(false);
-    expect(TimeUtil.isBefore("13:20:00", "13:20:00")).toBe(false);
-    expect(
-      TimestampUtil.isBefore(
-        ISO_1980_10_18T13_20_00_000,
-        ISO_1980_10_18T13_20_00_000,
-      ),
-    ).toBe(false);
-
-    expect(DateUtil.isBefore(ISO_1980_10_18, ISO_1980_10_19)).toBe(true);
-    expect(TimeUtil.isBefore("13:20:00", "13:21:00")).toBe(true);
-    expect(
-      TimestampUtil.isBefore(
-        ISO_1980_10_18T13_20_00_000,
-        ISO_1980_10_18T13_21_00_000,
-      ),
-    ).toBe(true);
-  });
+      it("isOther", () => {
+        expect(DateUtil.isOther(ISO_1980_10_18, ISO_1980_10_17)).toBe(true);
+        expect(DateUtil.isOther(ISO_1980_10_18, ISO_1980_10_18)).toBe(false);
+        expect(DateUtil.isOther(ISO_1980_10_18, ISO_1980_10_19)).toBe(true);
+      });
 
-  it("isSameOrBefore", () => {
-    expect(DateUtil.isSameOrBefore(ISO_1980_10_18, ISO_1980_10_17)).toBe(false);
-    expect(TimeUtil.isSameOrBefore("13:20:00", "13:19:00")).toBe(false);
-    expect(
-      TimestampUtil.isSameOrBefore(
-        ISO_1980_10_18T13_20_00_000,
-        ISO_1980_10_18T13_19_00_000,
-      ),
-    ).toBe(false);
-
-    expect(DateUtil.isSameOrBefore(ISO_1980_10_18, ISO_1980_10_18)).toBe(true);
-    expect(TimeUtil.isSameOrBefore("13:20:00", "13:20:00")).toBe(true);
-    expect(
-      TimestampUtil.isSameOrBefore(
-        ISO_1980_10_18T13_20_00_000,
-        ISO_1980_10_18T13_20_00_000,
-      ),
-    ).toBe(true);
-
-    expect(DateUtil.isSameOrBefore(ISO_1980_10_18, ISO_1980_10_19)).toBe(true);
-    expect(TimeUtil.isSameOrBefore("13:20:00", "13:21:00")).toBe(true);
-    expect(
-      TimestampUtil.isSameOrBefore(
-        ISO_1980_10_18T13_20_00_000,
-        ISO_1980_10_18T13_21_00_000,
-      ),
-    ).toBe(true);
-  });
+      it("isWeekend", () => {
+        expect(DateUtil.isWeekend("2018-12-14")).toBe(false);
+        expect(DateUtil.isWeekend("2018-12-15")).toBe(true);
+        expect(DateUtil.isWeekend("2018-12-16")).toBe(true);
+        expect(DateUtil.isWeekend("2018-12-17")).toBe(false);
+        expect(DateUtil.isWeekend("2018-12-18")).toBe(false);
+        expect(DateUtil.isWeekend("2018-12-19")).toBe(false);
+        expect(DateUtil.isWeekend("2018-12-20")).toBe(false);
+      });
+    });
 
-  it("isSame", () => {
-    expect(DateUtil.isSame(ISO_1980_10_18, ISO_1980_10_17)).toBe(false);
-    expect(TimeUtil.isSame("13:20:00", "13:19:00")).toBe(false);
-    expect(
-      TimestampUtil.isSame(
-        ISO_1980_10_18T13_20_00_000,
-        ISO_1980_10_18T13_19_00_000,
-      ),
-    ).toBe(false);
-
-    expect(DateUtil.isSame(ISO_1980_10_18, ISO_1980_10_18)).toBe(true);
-    expect(TimeUtil.isSame("13:20:00", "13:20:00")).toBe(true);
-    expect(
-      TimestampUtil.isSame(
-        ISO_1980_10_18T13_20_00_000,
-        ISO_1980_10_18T13_20_00_000,
-      ),
-    ).toBe(true);
-
-    expect(DateUtil.isSame(ISO_1980_10_18, ISO_1980_10_19)).toBe(false);
-    expect(TimeUtil.isSame("13:20:00", "13:21:00")).toBe(false);
-    expect(
-      TimestampUtil.isSame(
-        ISO_1980_10_18T13_20_00_000,
-        ISO_1980_10_18T13_21_00_000,
-      ),
-    ).toBe(false);
-  });
+    test("Calculations", () => {
+      expect(DateUtil.addSeconds(ISO_1980_01_01, 1)).toBe(ISO_1980_01_01);
+      expect(DateUtil.addMinutes(ISO_1980_01_01, 1)).toBe(ISO_1980_01_01);
+      expect(DateUtil.addHours(ISO_1980_01_01, 1)).toBe(ISO_1980_01_01);
+      expect(DateUtil.addDays(ISO_1980_01_01, 1)).toBe("1980-01-02");
+      expect(DateUtil.addWeeks(ISO_1980_01_01, 1)).toBe("1980-01-08");
+      expect(DateUtil.addMonths(ISO_1980_01_01, 1)).toBe("1980-02-01");
+      expect(DateUtil.addYears(ISO_1980_01_01, 1)).toBe("1981-01-01");
+      expect(DateUtil.subtractSeconds(ISO_1980_01_01, 1)).toBe(ISO_1979_12_31);
+      expect(DateUtil.subtractMinutes(ISO_1980_01_01, 1)).toBe(ISO_1979_12_31);
+      expect(DateUtil.subtractHours(ISO_1980_01_01, 1)).toBe(ISO_1979_12_31);
+      expect(DateUtil.subtractDays(ISO_1980_01_01, 1)).toBe(ISO_1979_12_31);
+      expect(DateUtil.subtractWeeks(ISO_1980_01_01, 1)).toBe("1979-12-25");
+      expect(DateUtil.subtractMonths(ISO_1980_01_01, 1)).toBe("1979-12-01");
+      expect(DateUtil.subtractYears(ISO_1980_01_01, 1)).toBe("1979-01-01");
+    });
 
-  it("isSameDay", () => {
-    expect(DateUtil.isSameDay(ISO_1980_10_18, ISO_1980_10_17)).toBe(false);
-    expect(DateUtil.isSameDay(ISO_1980_10_18, ISO_1980_10_18)).toBe(true);
-    expect(
-      TimestampUtil.isSameDay(
-        ISO_1980_10_18T13_20_00_000,
-        "1980-10-19T13:19:00.000",
-      ),
-    ).toBe(false);
-    expect(
-      TimestampUtil.isSameDay(
-        ISO_1980_10_18T13_20_00_000,
-        ISO_1980_10_18T13_19_00_000,
-      ),
-    ).toBe(true);
-  });
+    describe("test the start of the  week", () => {
+      describe("with week start on sunday", () => {
+        beforeEach(() => {
+          // week starts on day 0 (sunday)
+          setSettings({ CALENDAR_WEEK_STARTS_ON: 0 });
+        });
+        it("startOfWeek", () => {
+          expect(DateUtil.startOfWeek("2021-03-01")).toBe("2021-02-28");
+        });
+      });
 
-  it("isOther", () => {
-    expect(DateUtil.isOther(ISO_1980_10_18, ISO_1980_10_17)).toBe(true);
-    expect(TimeUtil.isOther("13:20:00", "13:19:00")).toBe(true);
-    expect(
-      TimestampUtil.isOther(
-        ISO_1980_10_18T13_20_00_000,
-        ISO_1980_10_18T13_19_00_000,
-      ),
-    ).toBe(true);
-
-    expect(DateUtil.isOther(ISO_1980_10_18, ISO_1980_10_18)).toBe(false);
-    expect(TimeUtil.isOther("13:20:00", "13:20:00")).toBe(false);
-    expect(
-      TimestampUtil.isOther(
-        ISO_1980_10_18T13_20_00_000,
-        ISO_1980_10_18T13_20_00_000,
-      ),
-    ).toBe(false);
-
-    expect(DateUtil.isOther(ISO_1980_10_18, ISO_1980_10_19)).toBe(true);
-    expect(TimeUtil.isOther("13:20:00", "13:21:00")).toBe(true);
-    expect(
-      TimestampUtil.isOther(
-        ISO_1980_10_18T13_20_00_000,
-        ISO_1980_10_18T13_21_00_000,
-      ),
-    ).toBe(true);
-  });
+      describe("with week start on monday", () => {
+        beforeEach(() => {
+          // week starts on day 1 (monday)
+          setSettings({ CALENDAR_WEEK_STARTS_ON: 1 });
+        });
 
-  it("isWeekend", () => {
-    expect(DateUtil.isWeekend("2018-12-14")).toBe(false);
-    expect(DateUtil.isWeekend("2018-12-15")).toBe(true);
-    expect(DateUtil.isWeekend("2018-12-16")).toBe(true);
-    expect(DateUtil.isWeekend("2018-12-17")).toBe(false);
-    expect(DateUtil.isWeekend("2018-12-18")).toBe(false);
-    expect(DateUtil.isWeekend("2018-12-19")).toBe(false);
-    expect(DateUtil.isWeekend("2018-12-20")).toBe(false);
-  });
+        it("startOfWeek", () => {
+          expect(DateUtil.startOfWeek("2021-03-01")).toBe("2021-03-01");
+        });
+      });
 
-  it("addSeconds", () => {
-    expect(DateUtil.addSeconds(ISO_1980_01_01, 1)).toBe(ISO_1980_01_01);
-    expect(TimeUtil.addSeconds("13:20:00", 1)).toBe("13:20:01");
-    expect(TimestampUtil.addSeconds(ISO_1980_01_01T13_20_00_000, 1)).toBe(
-      "1980-01-01T13:20:01.000",
-    );
-  });
+      describe("with week start on saturday", () => {
+        beforeEach(() => {
+          setSettings({ CALENDAR_WEEK_STARTS_ON: 6 });
+        });
+        it("startOfWeek", () => {
+          expect(DateUtil.startOfWeek("2021-03-01")).toBe("2021-02-27");
+        });
+      });
+    });
 
-  it("addMinutes", () => {
-    expect(DateUtil.addMinutes(ISO_1980_01_01, 1)).toBe(ISO_1980_01_01);
-    expect(TimeUtil.addMinutes("13:20:00", 1)).toBe("13:21:00");
-    expect(TimestampUtil.addMinutes(ISO_1980_01_01T13_20_00_000, 1)).toBe(
-      "1980-01-01T13:21:00.000",
-    );
-  });
+    test("Individual getters and setters", () => {
+      expect(DateUtil.startOfMonth(ISO_1980_01_15)).toBe(ISO_1980_01_01);
 
-  it("addHours", () => {
-    expect(DateUtil.addHours(ISO_1980_01_01, 1)).toBe(ISO_1980_01_01);
-    expect(TimeUtil.addHours("13:20:00", 1)).toBe("14:20:00");
-    expect(TimestampUtil.addHours(ISO_1980_01_01T13_20_00_000, 1)).toBe(
-      "1980-01-01T14:20:00.000",
-    );
+      expect(DateUtil.getWeek(ISO_1980_01_15)).toBe(3);
+      expect(DateUtil.setSecond(ISO_1980_01_01, 22)).toBe(ISO_1980_01_01);
+      expect(DateUtil.setMinute(ISO_1980_01_01, 22)).toBe(ISO_1980_01_01);
+      expect(DateUtil.setHour(ISO_1980_01_01, 22)).toBe(ISO_1980_01_01);
+      expect(DateUtil.setMonth(ISO_1980_01_01, 6)).toBe("1980-07-01");
+      expect(DateUtil.setYear(ISO_1980_01_01, 1986)).toBe("1986-01-01");
+    });
   });
 
-  it("addDays", () => {
-    expect(DateUtil.addDays(ISO_1980_01_01, 1)).toBe("1980-01-02");
-    expect(TimeUtil.addDays("13:20:00", 1)).toBe("13:20:00");
-    expect(TimestampUtil.addDays(ISO_1980_01_01T13_20_00_000, 1)).toBe(
-      "1980-01-02T13:20:00.000",
-    );
-  });
+  describe("test TimeUtil", () => {
+    it("should convert java date time format to date-fns date time format", () => {
+      expect(TimeUtil.convertFormat()).toBe(ISO_TIME_FORMAT);
+      expect(TimeUtil.convertFormat("HH:mm:ss")).toBe("HH:mm:ss");
+    });
 
-  it("addWeeks", () => {
-    expect(DateUtil.addWeeks(ISO_1980_01_01, 1)).toBe("1980-01-08");
-    expect(TimeUtil.addWeeks("13:20:00", 1)).toBe("13:20:00");
-    expect(TimestampUtil.addWeeks(ISO_1980_01_01T13_20_00_000, 1)).toBe(
-      "1980-01-08T13:20:00.000",
-    );
-  });
+    it("should render iso time to specified format", () => {
+      expect(TimeUtil.toFormat("14:15:12", "HH:mm")).toBe("14:15");
+      expect(TimeUtil.toFormat("14:15:12", "h:mm")).toBe("2:15");
+      expect(TimeUtil.toFormat("23:15:12", "h:mm")).toBe("11:15");
+    });
 
-  it("addMonths", () => {
-    expect(DateUtil.addMonths(ISO_1980_01_01, 1)).toBe("1980-02-01");
-    expect(TimeUtil.addMonths("13:20:00", 1)).toBe("13:20:00");
-    expect(TimestampUtil.addMonths(ISO_1980_01_01T13_20_00_000, 1)).toBe(
-      "1980-02-01T13:20:00.000",
-    );
-  });
+    it("should render specified format to iso time", () => {
+      expect(TimeUtil.toISO("14:15", "HH:mm")).toBe("14:15:00");
+      expect(TimeUtil.toISO("2:15 AM", "h:mm aa")).toBe("02:15:00");
+      expect(TimeUtil.toISO("02:15 PM", "hh:mm aa")).toBe("14:15:00");
+      expect(TimeUtil.toISO("11:15 AM", "h:mm aa")).toBe("11:15:00");
+    });
 
-  it("addYears", () => {
-    expect(DateUtil.addYears(ISO_1980_01_01, 1)).toBe("1981-01-01");
-    expect(TimeUtil.addYears("13:20:00", 1)).toBe("13:20:00");
-    expect(TimestampUtil.addYears(ISO_1980_01_01T13_20_00_000, 1)).toBe(
-      "1981-01-01T13:20:00.000",
-    );
-  });
+    it("should return invalid date when date entered is not a date", () => {
+      expect(TimeUtil.toISO("bla", "HH:mm")).toBe(INVALID_DATE);
+    });
 
-  it("subtractSeconds", () => {
-    expect(DateUtil.subtractSeconds(ISO_1980_01_01, 1)).toBe(ISO_1979_12_31);
-    expect(TimeUtil.subtractSeconds("13:20:00", 1)).toBe("13:19:59");
-    expect(TimestampUtil.subtractSeconds(ISO_1980_01_01T13_20_00_000, 1)).toBe(
-      "1980-01-01T13:19:59.000",
-    );
-  });
+    describe("asserts", () => {
+      it("isValid", () => {
+        expect(TimeUtil.isValid("13:20", "HH:mm")).toBe(true);
+        expect(TimeUtil.isValid("bla", "HH:mm")).toBe(false);
+      });
 
-  it("subtractMinutes", () => {
-    expect(DateUtil.subtractMinutes(ISO_1980_01_01, 1)).toBe(ISO_1979_12_31);
-    expect(TimeUtil.subtractMinutes("13:20:00", 1)).toBe("13:19:00");
-    expect(TimestampUtil.subtractMinutes(ISO_1980_01_01T13_20_00_000, 1)).toBe(
-      "1980-01-01T13:19:00.000",
-    );
-  });
+      it("isAfter", () => {
+        expect(TimeUtil.isAfter("13:20:00", "13:19:00")).toBe(true);
+        expect(TimeUtil.isAfter("13:20:00", "13:20:00")).toBe(false);
+        expect(TimeUtil.isAfter("13:20:00", "13:21:00")).toBe(false);
+      });
 
-  it("subtractHours", () => {
-    expect(DateUtil.subtractHours(ISO_1980_01_01, 1)).toBe(ISO_1979_12_31);
-    expect(TimeUtil.subtractHours("13:20:00", 1)).toBe("12:20:00");
-    expect(TimestampUtil.subtractHours(ISO_1980_01_01T13_20_00_000, 1)).toBe(
-      "1980-01-01T12:20:00.000",
-    );
-  });
+      it("isSameOrAfter", () => {
+        expect(TimeUtil.isSameOrAfter("13:20:00", "13:19:00")).toBe(true);
+        expect(TimeUtil.isSameOrAfter("13:20:00", "13:20:00")).toBe(true);
+        expect(TimeUtil.isSameOrAfter("13:20:00", "13:21:00")).toBe(false);
+      });
 
-  it("subtractDays", () => {
-    expect(DateUtil.subtractDays(ISO_1980_01_01, 1)).toBe(ISO_1979_12_31);
-    expect(TimeUtil.subtractDays("13:20:00", 1)).toBe("13:20:00");
-    expect(TimestampUtil.subtractDays(ISO_1980_01_01T13_20_00_000, 1)).toBe(
-      "1979-12-31T13:20:00.000",
-    );
-  });
+      it("isBefore", () => {
+        expect(TimeUtil.isBefore("13:20:00", "13:19:00")).toBe(false);
+        expect(TimeUtil.isBefore("13:20:00", "13:20:00")).toBe(false);
+        expect(TimeUtil.isBefore("13:20:00", "13:21:00")).toBe(true);
+      });
 
-  it("subtractWeeks", () => {
-    expect(DateUtil.subtractWeeks(ISO_1980_01_01, 1)).toBe("1979-12-25");
-    expect(TimeUtil.subtractWeeks("13:20:00", 1)).toBe("13:20:00");
-    expect(TimestampUtil.subtractWeeks(ISO_1980_01_01T13_20_00_000, 1)).toBe(
-      "1979-12-25T13:20:00.000",
-    );
-  });
+      it("isSameOrBefore", () => {
+        expect(TimeUtil.isSameOrBefore("13:20:00", "13:19:00")).toBe(false);
+        expect(TimeUtil.isSameOrBefore("13:20:00", "13:20:00")).toBe(true);
+        expect(TimeUtil.isSameOrBefore("13:20:00", "13:21:00")).toBe(true);
+      });
 
-  it("subtractMonths", () => {
-    expect(DateUtil.subtractMonths(ISO_1980_01_01, 1)).toBe("1979-12-01");
-    expect(TimeUtil.subtractMonths("13:20:00", 1)).toBe("13:20:00");
-    expect(TimestampUtil.subtractMonths(ISO_1980_01_01T13_20_00_000, 1)).toBe(
-      "1979-12-01T13:20:00.000",
-    );
-  });
+      it("isSame", () => {
+        expect(TimeUtil.isSame("13:20:00", "13:19:00")).toBe(false);
+        expect(TimeUtil.isSame("13:20:00", "13:20:00")).toBe(true);
+        expect(TimeUtil.isSame("13:20:00", "13:21:00")).toBe(false);
+      });
 
-  it("subtractYears", () => {
-    expect(DateUtil.subtractYears(ISO_1980_01_01, 1)).toBe("1979-01-01");
-    expect(TimeUtil.subtractYears("13:20:00", 1)).toBe("13:20:00");
-    expect(TimestampUtil.subtractYears(ISO_1980_01_01T13_20_00_000, 1)).toBe(
-      "1979-01-01T13:20:00.000",
-    );
-  });
+      it("isOther", () => {
+        expect(TimeUtil.isOther("13:20:00", "13:19:00")).toBe(true);
+        expect(TimeUtil.isOther("13:20:00", "13:20:00")).toBe(false);
+        expect(TimeUtil.isOther("13:20:00", "13:21:00")).toBe(true);
+      });
+    });
+
+    test("Calculations", () => {
+      expect(TimeUtil.addSeconds("13:20:00", 1)).toBe("13:20:01");
+      expect(TimeUtil.addMinutes("13:20:00", 1)).toBe("13:21:00");
+      expect(TimeUtil.addHours("13:20:00", 1)).toBe("14:20:00");
+      expect(TimeUtil.addDays("13:20:00", 1)).toBe("13:20:00");
+      expect(TimeUtil.addWeeks("13:20:00", 1)).toBe("13:20:00");
+      expect(TimeUtil.addMonths("13:20:00", 1)).toBe("13:20:00");
+      expect(TimeUtil.addYears("13:20:00", 1)).toBe("13:20:00");
+      expect(TimeUtil.subtractSeconds("13:20:00", 1)).toBe("13:19:59");
+      expect(TimeUtil.subtractMinutes("13:20:00", 1)).toBe("13:19:00");
+      expect(TimeUtil.subtractHours("13:20:00", 1)).toBe("12:20:00");
+      expect(TimeUtil.subtractDays("13:20:00", 1)).toBe("13:20:00");
+      expect(TimeUtil.subtractWeeks("13:20:00", 1)).toBe("13:20:00");
+      expect(TimeUtil.subtractMonths("13:20:00", 1)).toBe("13:20:00");
+      expect(TimeUtil.subtractYears("13:20:00", 1)).toBe("13:20:00");
+    });
 
-  it("startOfMonth", () => {
-    expect(DateUtil.startOfMonth(ISO_1980_01_15)).toBe(ISO_1980_01_01);
+    test("Individual getters and setters", () => {
+      expect(TimeUtil.getHours("13:20:00")).toBe(13);
+      expect(TimeUtil.getMinutes("13:20:00")).toBe(20);
+      expect(TimeUtil.setSecond("13:20:00", 22)).toBe("13:20:22");
+      expect(TimeUtil.setMinute("13:20:00", 22)).toBe("13:22:00");
+      expect(TimeUtil.setHour("13:20:00", 22)).toBe("22:20:00");
+      expect(TimeUtil.setMonth("13:20:00", 6)).toBe("13:20:00");
+      expect(TimeUtil.setYear("13:20:00", 1986)).toBe("13:20:00");
+    });
   });
 
-  describe("test the start of the  week", () => {
-    describe("with week start on sunday", () => {
-      beforeEach(() => {
-        // week starts on day 0 (sunday)
-        setSettings({ CALENDAR_WEEK_STARTS_ON: 0 });
+  describe(`test DateTimeUtil`, () => {
+    describe(`test DateTimeUtil - offset off`, () => {
+      it("should convert java date time format to date-fns date time format", () => {
+        expect(DateTimeUtil.convertFormat()).toBe(ISO_DATETIME_FORMAT);
+        expect(DateTimeUtil.convertFormat("yyyy-MM-dd HH:mm:ss")).toBe(
+          "yyyy-MM-dd HH:mm:ss",
+        );
       });
-      it("startOfWeek", () => {
-        expect(DateUtil.startOfWeek("2021-03-01")).toBe("2021-02-28");
+
+      it("should render iso datetime to specified format", () => {
+        expect(
+          DateTimeUtil.toFormat("2017-06-13T14:15:12", DUTCH_DATETIME_FORMAT),
+        ).toBe(INPUT_13_06_2017_14_15);
+        expect(DateTimeUtil.toFormat("2017-06-13T14:15:12", "h:mm")).toBe(
+          "2:15",
+        );
+        expect(
+          DateTimeUtil.toFormat("2017-06-13T23:15:12", DUTCH_DATE_FORMAT),
+        ).toBe(INPUT_13_06_2017);
       });
-    });
 
-    describe("with week start on monday", () => {
-      beforeEach(() => {
-        // week starts on day 1 (monday)
-        setSettings({ CALENDAR_WEEK_STARTS_ON: 1 });
+      it("should render specified format to iso datetime", () => {
+        expect(
+          DateTimeUtil.toISO(INPUT_13_06_2017_14_15, DUTCH_DATETIME_FORMAT),
+        ).toBe("2017-06-13T14:15:00");
+        expect(DateTimeUtil.toISO("13-06-2017 2:15", "dd-MM-yyyy h:mm")).toBe(
+          "2017-06-13T02:15:00",
+        );
+        expect(DateTimeUtil.toISO(INPUT_13_06_2017, DUTCH_DATE_FORMAT)).toBe(
+          "2017-06-13T00:00:00",
+        );
+      });
+
+      it("should return invalid date when date entered is not a date", () => {
+        expect(DateTimeUtil.toISO("bla", DUTCH_DATETIME_FORMAT)).toBe(
+          INVALID_DATE,
+        );
+      });
+
+      describe("asserts", () => {
+        it("isValid", () => {
+          expect(
+            DateTimeUtil.isValid("18-10-1980 13:20", DUTCH_DATETIME_FORMAT),
+          ).toBe(true);
+          expect(DateTimeUtil.isValid("bla", DUTCH_DATETIME_FORMAT)).toBe(
+            false,
+          );
+        });
+
+        it("isAfter", () => {
+          expect(
+            DateTimeUtil.isAfter(
+              ISO_1980_10_18T13_20_00,
+              "1980-10-18T13:19:00",
+            ),
+          ).toBe(true);
+          expect(
+            DateTimeUtil.isAfter(
+              ISO_1980_10_18T13_20_00,
+              ISO_1980_10_18T13_20_00,
+            ),
+          ).toBe(false);
+          expect(
+            DateTimeUtil.isAfter(
+              ISO_1980_10_18T13_20_00,
+              "1980-10-18T13:21:00",
+            ),
+          ).toBe(false);
+        });
+
+        it("isAmbiguous", () => {
+          expect(DateTimeUtil.isAmbiguous(null, DUTCH_DATETIME_FORMAT)).toBe(
+            false,
+          );
+
+          expect(DateTimeUtil.isAmbiguous("", DUTCH_DATETIME_FORMAT)).toBe(
+            false,
+          );
+
+          expect(
+            DateTimeUtil.isAmbiguous("18-10-1980 13:20", DUTCH_DATETIME_FORMAT),
+          ).toBe(false);
+
+          expect(
+            DateTimeUtil.isAmbiguous("27-10-2024 02:30", DUTCH_DATETIME_FORMAT),
+          ).toBe(true);
+
+          expect(
+            DateTimeUtil.isAmbiguous(new Date(2024, 9, 27, 2, 30, 0)),
+          ).toBe(true);
+
+          const d = DateTimeUtil.toDate(
+            "27-10-2024T02:30+01:00",
+            "dd-MM-yyyy'T'HH:mmxxx",
+          );
+          expect(DateTimeUtil.isAmbiguous(d)).toBe(true);
+        });
       });
 
-      it("startOfWeek", () => {
-        expect(DateUtil.startOfWeek("2021-03-01")).toBe("2021-03-01");
+      test("Calculations", () => {
+        expect(DateTimeUtil.addSeconds(ISO_1980_01_01T13_20_00, 1)).toBe(
+          "1980-01-01T13:20:01",
+        );
+        expect(DateTimeUtil.addMinutes(ISO_1980_01_01T13_20_00, 1)).toBe(
+          "1980-01-01T13:21:00",
+        );
+        expect(DateTimeUtil.addHours(ISO_1980_01_01T13_20_00, 1)).toBe(
+          "1980-01-01T14:20:00",
+        );
+        expect(DateTimeUtil.addDays(ISO_1980_01_01T13_20_00, 1)).toBe(
+          "1980-01-02T13:20:00",
+        );
+        expect(DateTimeUtil.addWeeks(ISO_1980_01_01T13_20_00, 1)).toBe(
+          "1980-01-08T13:20:00",
+        );
+        expect(DateTimeUtil.addMonths(ISO_1980_01_01T13_20_00, 1)).toBe(
+          "1980-02-01T13:20:00",
+        );
+        expect(DateTimeUtil.addYears(ISO_1980_01_01T13_20_00, 1)).toBe(
+          "1981-01-01T13:20:00",
+        );
+        expect(DateTimeUtil.subtractSeconds(ISO_1980_01_01T13_20_00, 1)).toBe(
+          "1980-01-01T13:19:59",
+        );
+        expect(DateTimeUtil.subtractMinutes(ISO_1980_01_01T13_20_00, 1)).toBe(
+          "1980-01-01T13:19:00",
+        );
+        expect(DateTimeUtil.subtractHours(ISO_1980_01_01T13_20_00, 1)).toBe(
+          "1980-01-01T12:20:00",
+        );
+        expect(DateTimeUtil.subtractDays(ISO_1980_01_01T13_20_00, 1)).toBe(
+          "1979-12-31T13:20:00",
+        );
+        expect(DateTimeUtil.subtractWeeks(ISO_1980_01_01T13_20_00, 1)).toBe(
+          "1979-12-25T13:20:00",
+        );
+        expect(DateTimeUtil.subtractMonths(ISO_1980_01_01T13_20_00, 1)).toBe(
+          "1979-12-01T13:20:00",
+        );
+        expect(DateTimeUtil.subtractYears(ISO_1980_01_01T13_20_00, 1)).toBe(
+          "1979-01-01T13:20:00",
+        );
       });
     });
 
-    describe("with week start on saturday", () => {
+    describe(`test DateTimeUtil - offset on`, () => {
       beforeEach(() => {
-        setSettings({ CALENDAR_WEEK_STARTS_ON: 6 });
+        setSettings({ [INCLUDE_TIME_OFFSET]: true });
+        DateTimeUtil.setTimeZone("Europe/Amsterdam");
       });
-      it("startOfWeek", () => {
-        expect(DateUtil.startOfWeek("2021-03-01")).toBe("2021-02-27");
+
+      it("Retrieves available offsets for the timezone", () => {
+        expect(DateTimeUtil.getTimezoneOffsets()).toEqual({
+          daylight: {
+            abbr: "CEST",
+            label: "Central European Summer Time",
+            value: "+02:00",
+          },
+          standard: {
+            abbr: "CET",
+            label: "Central European Standard Time",
+            value: "+01:00",
+          },
+        });
+      });
+
+      it("Retrieves offset information", () => {
+        expect(DateTimeUtil.getOffset("2024-01-01T10:10:10+00:00")).toEqual({
+          abbr: "CET",
+          label: "Central European Standard Time",
+          value: "+01:00",
+        });
+
+        expect(DateTimeUtil.getOffset("")).toEqual(null);
+      });
+
+      it("should convert java date time format to date-fns date time format", () => {
+        expect(DateTimeUtil.convertFormat()).toBe(
+          ISO_DATETIME_FORMAT + DATETIME_OFFSET_FORMAT,
+        );
+        expect(DateTimeUtil.convertFormat("yyyy-MM-dd HH:mm:ss")).toBe(
+          "yyyy-MM-dd HH:mm:ss",
+        );
+      });
+
+      it("should render iso datetime to specified format", () => {
+        expect(
+          DateTimeUtil.toFormat(
+            "2017-06-13T14:15:12+02:00",
+            DUTCH_DATETIME_FORMAT,
+          ),
+        ).toBe(INPUT_13_06_2017_14_15);
+        expect(DateTimeUtil.toFormat("2017-06-13T14:15:12+02:00", "h:mm")).toBe(
+          "2:15",
+        );
+        expect(
+          DateTimeUtil.toFormat("2017-06-13T19:15:12+02:00", DUTCH_DATE_FORMAT),
+        ).toBe(INPUT_13_06_2017);
+      });
+
+      it("should render specified format to iso datetime", () => {
+        expect(
+          DateTimeUtil.toISO(INPUT_13_06_2017_14_15, DUTCH_DATETIME_FORMAT),
+        ).toBe("2017-06-13T14:15:00+02:00");
+        expect(DateTimeUtil.toISO("13-06-2017 2:15", "dd-MM-yyyy h:mm")).toBe(
+          "2017-06-13T02:15:00+02:00",
+        );
+        expect(DateTimeUtil.toISO(INPUT_13_06_2017, DUTCH_DATE_FORMAT)).toBe(
+          "2017-06-13T00:00:00+02:00",
+        );
+      });
+
+      it("should return invalid date when date entered is not a date", () => {
+        expect(DateTimeUtil.toISO("bla", DUTCH_DATETIME_FORMAT)).toBe(
+          INVALID_DATE,
+        );
+      });
+
+      describe("asserts", () => {
+        it("isValid", () => {
+          expect(
+            DateTimeUtil.isValid("18-10-1980 13:20", DUTCH_DATETIME_FORMAT),
+          ).toBe(true);
+          expect(DateTimeUtil.isValid("bla", DUTCH_DATETIME_FORMAT)).toBe(
+            false,
+          );
+        });
+
+        it("isAfter", () => {
+          expect(
+            DateTimeUtil.isAfter(
+              ISO_1980_10_18T13_20_00_OFFSET,
+              "1980-10-18T13:19:00+02:00",
+            ),
+          ).toBe(true);
+          expect(
+            DateTimeUtil.isAfter(
+              ISO_1980_10_18T13_20_00_OFFSET,
+              ISO_1980_10_18T13_20_00_OFFSET,
+            ),
+          ).toBe(false);
+          expect(
+            DateTimeUtil.isAfter(
+              ISO_1980_10_18T13_20_00_OFFSET,
+              "1980-10-18T13:21:00+02:00",
+            ),
+          ).toBe(false);
+        });
+      });
+
+      test("Calculations", () => {
+        expect(DateTimeUtil.addSeconds(ISO_1980_01_01T13_20_00_OFFSET, 1)).toBe(
+          "1980-01-01T13:20:01+01:00",
+        );
+        expect(DateTimeUtil.addMinutes(ISO_1980_01_01T13_20_00_OFFSET, 1)).toBe(
+          "1980-01-01T13:21:00+01:00",
+        );
+        expect(DateTimeUtil.addHours(ISO_1980_01_01T13_20_00_OFFSET, 1)).toBe(
+          "1980-01-01T14:20:00+01:00",
+        );
+        expect(DateTimeUtil.addDays(ISO_1980_01_01T13_20_00_OFFSET, 1)).toBe(
+          "1980-01-02T13:20:00+01:00",
+        );
+        expect(DateTimeUtil.addWeeks(ISO_1980_01_01T13_20_00_OFFSET, 1)).toBe(
+          "1980-01-08T13:20:00+01:00",
+        );
+        expect(DateTimeUtil.addMonths(ISO_1980_01_01T13_20_00_OFFSET, 1)).toBe(
+          "1980-02-01T13:20:00+01:00",
+        );
+        expect(DateTimeUtil.addYears(ISO_1980_01_01T13_20_00_OFFSET, 1)).toBe(
+          "1981-01-01T13:20:00+01:00",
+        );
+        expect(
+          DateTimeUtil.subtractSeconds(ISO_1980_01_01T13_20_00_OFFSET, 1),
+        ).toBe("1980-01-01T13:19:59+01:00");
+        expect(
+          DateTimeUtil.subtractMinutes(ISO_1980_01_01T13_20_00_OFFSET, 1),
+        ).toBe("1980-01-01T13:19:00+01:00");
+        expect(
+          DateTimeUtil.subtractHours(ISO_1980_01_01T13_20_00_OFFSET, 1),
+        ).toBe("1980-01-01T12:20:00+01:00");
+        expect(
+          DateTimeUtil.subtractDays(ISO_1980_01_01T13_20_00_OFFSET, 1),
+        ).toBe("1979-12-31T13:20:00+01:00");
+        expect(
+          DateTimeUtil.subtractWeeks(ISO_1980_01_01T13_20_00_OFFSET, 1),
+        ).toBe("1979-12-25T13:20:00+01:00");
+        expect(
+          DateTimeUtil.subtractMonths(ISO_1980_01_01T13_20_00_OFFSET, 1),
+        ).toBe("1979-12-01T13:20:00+01:00");
+        expect(
+          DateTimeUtil.subtractYears(ISO_1980_01_01T13_20_00_OFFSET, 1),
+        ).toBe("1979-01-01T13:20:00+01:00");
       });
     });
   });
-  it("getWeek", () => {
-    expect(DateUtil.getWeek(ISO_1980_01_15)).toBe(3);
-  });
 
-  it("getHours", () => {
-    expect(TimeUtil.getHours("13:20:00")).toBe(13);
-    expect(TimestampUtil.getHours(ISO_1980_01_01T13_20_00_000)).toBe(13);
-  });
+  describe("test TimeStampUtil", () => {
+    it("should convert java date time format to date-fns date time format", () => {
+      expect(TimestampUtil.convertFormat()).toBe(ISO_TIMESTAMP_FORMAT);
+      expect(TimestampUtil.convertFormat("yyyy-MM-dd HH:mm:ss.SSS")).toBe(
+        "yyyy-MM-dd HH:mm:ss.SSS",
+      );
+    });
 
-  it("getMinutes", () => {
-    expect(TimeUtil.getMinutes("13:20:00")).toBe(20);
-    expect(TimestampUtil.getMinutes(ISO_1980_01_01T13_20_00_000)).toBe(20);
-  });
+    it("should render iso timestamp to specified format", () => {
+      expect(
+        TimestampUtil.toFormat(
+          "2017-06-13T14:15:12.000",
+          DUTCH_DATETIME_FORMAT,
+        ),
+      ).toBe(INPUT_13_06_2017_14_15);
+      expect(TimestampUtil.toFormat("2017-06-13T14:15:12.000", "h:mm")).toBe(
+        "2:15",
+      );
+      expect(
+        TimestampUtil.toFormat("2017-06-13T23:15:12.000", DUTCH_DATE_FORMAT),
+      ).toBe(INPUT_13_06_2017);
+    });
 
-  it("setSecond", () => {
-    expect(DateUtil.setSecond(ISO_1980_01_01, 22)).toBe(ISO_1980_01_01);
-    expect(TimeUtil.setSecond("13:20:00", 22)).toBe("13:20:22");
-    expect(TimestampUtil.setSecond(ISO_1980_01_01T13_20_00_000, 22)).toBe(
-      "1980-01-01T13:20:22.000",
-    );
-  });
+    it("should render specified format to iso timestamp", () => {
+      expect(
+        TimestampUtil.toISO(INPUT_13_06_2017_14_15, DUTCH_DATETIME_FORMAT),
+      ).toBe("2017-06-13T14:15:00.000");
+      expect(TimestampUtil.toISO("13-06-2017 2:15", "dd-MM-yyyy h:mm")).toBe(
+        "2017-06-13T02:15:00.000",
+      );
+      expect(TimestampUtil.toISO(INPUT_13_06_2017, DUTCH_DATE_FORMAT)).toBe(
+        "2017-06-13T00:00:00.000",
+      );
+    });
 
-  it("setMinute", () => {
-    expect(DateUtil.setMinute(ISO_1980_01_01, 22)).toBe(ISO_1980_01_01);
-    expect(TimeUtil.setMinute("13:20:00", 22)).toBe("13:22:00");
-    expect(TimestampUtil.setMinute(ISO_1980_01_01T13_20_00_000, 22)).toBe(
-      "1980-01-01T13:22:00.000",
-    );
-  });
+    it("should return invalid date when date entered is not a date", () => {
+      expect(TimestampUtil.toISO("bla", DUTCH_DATETIME_FORMAT)).toBe(
+        INVALID_DATE,
+      );
+    });
 
-  it("setHour", () => {
-    expect(DateUtil.setHour(ISO_1980_01_01, 22)).toBe(ISO_1980_01_01);
-    expect(TimeUtil.setHour("13:20:00", 22)).toBe("22:20:00");
-    expect(TimestampUtil.setHour(ISO_1980_01_01T13_20_00_000, 22)).toBe(
-      "1980-01-01T22:20:00.000",
-    );
-  });
+    describe("asserts", () => {
+      it("isValid", () => {
+        expect(
+          TimestampUtil.isValid("18-10-1980 13:20", DUTCH_DATETIME_FORMAT),
+        ).toBe(true);
+        expect(TimestampUtil.isValid("bla", DUTCH_DATETIME_FORMAT)).toBe(false);
+      });
 
-  it("setMonth", () => {
-    expect(DateUtil.setMonth(ISO_1980_01_01, 6)).toBe("1980-07-01");
-    expect(TimeUtil.setMonth("13:20:00", 6)).toBe("13:20:00");
-    expect(TimestampUtil.setMonth(ISO_1980_01_01T13_20_00_000, 6)).toBe(
-      "1980-07-01T13:20:00.000",
-    );
-  });
+      it("isAfter", () => {
+        expect(
+          TimestampUtil.isAfter(
+            ISO_1980_10_18T13_20_00_000,
+            ISO_1980_10_18T13_19_00_000,
+          ),
+        ).toBe(true);
+        expect(
+          TimestampUtil.isAfter(
+            ISO_1980_10_18T13_20_00_000,
+            ISO_1980_10_18T13_20_00_000,
+          ),
+        ).toBe(false);
+        expect(
+          TimestampUtil.isAfter(
+            ISO_1980_10_18T13_20_00_000,
+            ISO_1980_10_18T13_21_00_000,
+          ),
+        ).toBe(false);
+      });
+
+      it("isSameOrAfter", () => {
+        expect(
+          TimestampUtil.isSameOrAfter(
+            ISO_1980_10_18T13_20_00_000,
+            ISO_1980_10_18T13_19_00_000,
+          ),
+        ).toBe(true);
+        expect(
+          TimestampUtil.isSameOrAfter(
+            ISO_1980_10_18T13_20_00_000,
+            ISO_1980_10_18T13_20_00_000,
+          ),
+        ).toBe(true);
+        expect(
+          TimestampUtil.isSameOrAfter(
+            ISO_1980_10_18T13_20_00_000,
+            ISO_1980_10_18T13_21_00_000,
+          ),
+        ).toBe(false);
+      });
+
+      it("isBefore", () => {
+        expect(
+          TimestampUtil.isBefore(
+            ISO_1980_10_18T13_20_00_000,
+            ISO_1980_10_18T13_19_00_000,
+          ),
+        ).toBe(false);
+        expect(
+          TimestampUtil.isBefore(
+            ISO_1980_10_18T13_20_00_000,
+            ISO_1980_10_18T13_20_00_000,
+          ),
+        ).toBe(false);
+        expect(
+          TimestampUtil.isBefore(
+            ISO_1980_10_18T13_20_00_000,
+            ISO_1980_10_18T13_21_00_000,
+          ),
+        ).toBe(true);
+      });
+
+      it("isSameOrBefore", () => {
+        expect(
+          TimestampUtil.isSameOrBefore(
+            ISO_1980_10_18T13_20_00_000,
+            ISO_1980_10_18T13_19_00_000,
+          ),
+        ).toBe(false);
+        expect(
+          TimestampUtil.isSameOrBefore(
+            ISO_1980_10_18T13_20_00_000,
+            ISO_1980_10_18T13_20_00_000,
+          ),
+        ).toBe(true);
+        expect(
+          TimestampUtil.isSameOrBefore(
+            ISO_1980_10_18T13_20_00_000,
+            ISO_1980_10_18T13_21_00_000,
+          ),
+        ).toBe(true);
+      });
+
+      it("isSame", () => {
+        expect(
+          TimestampUtil.isSame(
+            ISO_1980_10_18T13_20_00_000,
+            ISO_1980_10_18T13_19_00_000,
+          ),
+        ).toBe(false);
+        expect(
+          TimestampUtil.isSame(
+            ISO_1980_10_18T13_20_00_000,
+            ISO_1980_10_18T13_20_00_000,
+          ),
+        ).toBe(true);
+        expect(
+          TimestampUtil.isSame(
+            ISO_1980_10_18T13_20_00_000,
+            ISO_1980_10_18T13_21_00_000,
+          ),
+        ).toBe(false);
+      });
 
-  it("setYear", () => {
-    expect(DateUtil.setYear(ISO_1980_01_01, 1986)).toBe("1986-01-01");
-    expect(TimeUtil.setYear("13:20:00", 1986)).toBe("13:20:00");
-    expect(TimestampUtil.setYear(ISO_1980_01_01T13_20_00_000, 1986)).toBe(
-      "1986-01-01T13:20:00.000",
-    );
+      it("isSameDay", () => {
+        expect(
+          TimestampUtil.isSameDay(
+            ISO_1980_10_18T13_20_00_000,
+            "1980-10-19T13:19:00.000",
+          ),
+        ).toBe(false);
+        expect(
+          TimestampUtil.isSameDay(
+            ISO_1980_10_18T13_20_00_000,
+            ISO_1980_10_18T13_19_00_000,
+          ),
+        ).toBe(true);
+      });
+
+      it("isOther", () => {
+        expect(
+          TimestampUtil.isOther(
+            ISO_1980_10_18T13_20_00_000,
+            ISO_1980_10_18T13_19_00_000,
+          ),
+        ).toBe(true);
+        expect(
+          TimestampUtil.isOther(
+            ISO_1980_10_18T13_20_00_000,
+            ISO_1980_10_18T13_20_00_000,
+          ),
+        ).toBe(false);
+        expect(
+          TimestampUtil.isOther(
+            ISO_1980_10_18T13_20_00_000,
+            ISO_1980_10_18T13_21_00_000,
+          ),
+        ).toBe(true);
+      });
+    });
+
+    test("Calculations", () => {
+      expect(TimestampUtil.addSeconds(ISO_1980_01_01T13_20_00_000, 1)).toBe(
+        "1980-01-01T13:20:01.000",
+      );
+      expect(TimestampUtil.addMinutes(ISO_1980_01_01T13_20_00_000, 1)).toBe(
+        "1980-01-01T13:21:00.000",
+      );
+      expect(TimestampUtil.addHours(ISO_1980_01_01T13_20_00_000, 1)).toBe(
+        "1980-01-01T14:20:00.000",
+      );
+      expect(TimestampUtil.addDays(ISO_1980_01_01T13_20_00_000, 1)).toBe(
+        "1980-01-02T13:20:00.000",
+      );
+      expect(TimestampUtil.addWeeks(ISO_1980_01_01T13_20_00_000, 1)).toBe(
+        "1980-01-08T13:20:00.000",
+      );
+      expect(TimestampUtil.addMonths(ISO_1980_01_01T13_20_00_000, 1)).toBe(
+        "1980-02-01T13:20:00.000",
+      );
+      expect(TimestampUtil.addYears(ISO_1980_01_01T13_20_00_000, 1)).toBe(
+        "1981-01-01T13:20:00.000",
+      );
+      expect(
+        TimestampUtil.subtractSeconds(ISO_1980_01_01T13_20_00_000, 1),
+      ).toBe("1980-01-01T13:19:59.000");
+      expect(
+        TimestampUtil.subtractMinutes(ISO_1980_01_01T13_20_00_000, 1),
+      ).toBe("1980-01-01T13:19:00.000");
+      expect(TimestampUtil.subtractHours(ISO_1980_01_01T13_20_00_000, 1)).toBe(
+        "1980-01-01T12:20:00.000",
+      );
+      expect(TimestampUtil.subtractDays(ISO_1980_01_01T13_20_00_000, 1)).toBe(
+        "1979-12-31T13:20:00.000",
+      );
+      expect(TimestampUtil.subtractWeeks(ISO_1980_01_01T13_20_00_000, 1)).toBe(
+        "1979-12-25T13:20:00.000",
+      );
+      expect(TimestampUtil.subtractMonths(ISO_1980_01_01T13_20_00_000, 1)).toBe(
+        "1979-12-01T13:20:00.000",
+      );
+      expect(TimestampUtil.subtractYears(ISO_1980_01_01T13_20_00_000, 1)).toBe(
+        "1979-01-01T13:20:00.000",
+      );
+    });
+
+    test("Individual getters and setters", () => {
+      expect(TimestampUtil.getHours(ISO_1980_01_01T13_20_00_000)).toBe(13);
+      expect(TimestampUtil.getMinutes(ISO_1980_01_01T13_20_00_000)).toBe(20);
+      expect(TimestampUtil.setSecond(ISO_1980_01_01T13_20_00_000, 22)).toBe(
+        "1980-01-01T13:20:22.000",
+      );
+      expect(TimestampUtil.setMinute(ISO_1980_01_01T13_20_00_000, 22)).toBe(
+        "1980-01-01T13:22:00.000",
+      );
+      expect(TimestampUtil.setHour(ISO_1980_01_01T13_20_00_000, 22)).toBe(
+        "1980-01-01T22:20:00.000",
+      );
+      expect(TimestampUtil.setMonth(ISO_1980_01_01T13_20_00_000, 6)).toBe(
+        "1980-07-01T13:20:00.000",
+      );
+      expect(TimestampUtil.setYear(ISO_1980_01_01T13_20_00_000, 1986)).toBe(
+        "1986-01-01T13:20:00.000",
+      );
+    });
   });
 });