chrono-node 2.6.6 → 2.7.1

package/test/ru/ru_relative.test.ts

@@ -5,25 +5,37 @@ test("Test - 'This' expressions", () => {
     testSingleCase(chrono.ru, "на этой неделе", new Date(2017, 11 - 1, 19, 12), (result, text) => {
         expect(result.index).toBe(0);
         expect(result.text).toBe(text);
-        expect(result.start).toBeDate(new Date(2017, 11 - 1, 19, 12));
+        expect(result.start.get("year")).toBe(2017);
+        expect(result.start.get("month")).toBe(11);
+        expect(result.start.get("day")).toBe(19);
+        expect(result.start.get("hour")).toBe(12);
     });
 
     testSingleCase(chrono.ru, "в этом месяце", new Date(2017, 11 - 1, 19, 12), (result, text) => {
         expect(result.index).toBe(0);
         expect(result.text).toBe(text);
-        expect(result.start).toBeDate(new Date(2017, 11 - 1, 1, 12));
+        expect(result.start.get("year")).toBe(2017);
+        expect(result.start.get("month")).toBe(11);
+        expect(result.start.get("day")).toBe(1);
+        expect(result.start.get("hour")).toBe(12);
     });
 
     testSingleCase(chrono.ru, "в этом месяце", new Date(2017, 11 - 1, 1, 12), (result, text) => {
         expect(result.index).toBe(0);
         expect(result.text).toBe(text);
-        expect(result.start).toBeDate(new Date(2017, 11 - 1, 1, 12));
+        expect(result.start.get("year")).toBe(2017);
+        expect(result.start.get("month")).toBe(11);
+        expect(result.start.get("day")).toBe(1);
+        expect(result.start.get("hour")).toBe(12);
     });
 
     testSingleCase(chrono.ru, "в этом году", new Date(2017, 11 - 1, 19, 12), (result, text) => {
         expect(result.index).toBe(0);
         expect(result.text).toBe(text);
-        expect(result.start).toBeDate(new Date(2017, 1 - 1, 1, 12));
+        expect(result.start.get("year")).toBe(2017);
+        expect(result.start.get("month")).toBe(1);
+        expect(result.start.get("day")).toBe(1);
+        expect(result.start.get("hour")).toBe(12);
     });
 });
 
@@ -31,19 +43,28 @@ test("Test - Past relative expressions", () => {
     testSingleCase(chrono.ru, "на прошлой неделе", new Date(2016, 10 - 1, 1, 12), (result, text) => {
         expect(result.index).toBe(0);
         expect(result.text).toBe(text);
-        expect(result.start).toBeDate(new Date(2016, 9 - 1, 24, 12));
+        expect(result.start.get("year")).toBe(2016);
+        expect(result.start.get("month")).toBe(9);
+        expect(result.start.get("day")).toBe(24);
+        expect(result.start.get("hour")).toBe(12);
     });
 
     testSingleCase(chrono.ru, "в прошлом месяце", new Date(2016, 10 - 1, 1, 12), (result, text) => {
         expect(result.index).toBe(0);
         expect(result.text).toBe(text);
-        expect(result.start).toBeDate(new Date(2016, 9 - 1, 1, 12));
+        expect(result.start.get("year")).toBe(2016);
+        expect(result.start.get("month")).toBe(9);
+        expect(result.start.get("day")).toBe(1);
+        expect(result.start.get("hour")).toBe(12);
     });
 
     testSingleCase(chrono.ru, "в прошлом году", new Date(2016, 10 - 1, 1, 12), (result, text) => {
         expect(result.index).toBe(0);
         expect(result.text).toBe(text);
-        expect(result.start).toBeDate(new Date(2015, 10 - 1, 1, 12));
+        expect(result.start.get("year")).toBe(2015);
+        expect(result.start.get("month")).toBe(10);
+        expect(result.start.get("day")).toBe(1);
+        expect(result.start.get("hour")).toBe(12);
     });
 });
 
@@ -51,24 +72,36 @@ test("Test - Future relative expressions", () => {
     testSingleCase(chrono.ru, "на следующей неделе", new Date(2016, 10 - 1, 1, 12), (result, text) => {
         expect(result.index).toBe(0);
         expect(result.text).toBe(text);
-        expect(result.start).toBeDate(new Date(2016, 10 - 1, 8, 12));
+        expect(result.start.get("year")).toBe(2016);
+        expect(result.start.get("month")).toBe(10);
+        expect(result.start.get("day")).toBe(8);
+        expect(result.start.get("hour")).toBe(12);
     });
 
     testSingleCase(chrono.ru, "в следующем месяце", new Date(2016, 10 - 1, 1, 12), (result, text) => {
         expect(result.index).toBe(0);
         expect(result.text).toBe(text);
-        expect(result.start).toBeDate(new Date(2016, 11 - 1, 1, 12));
+        expect(result.start.get("year")).toBe(2016);
+        expect(result.start.get("month")).toBe(11);
+        expect(result.start.get("day")).toBe(1);
+        expect(result.start.get("hour")).toBe(12);
     });
 
     testSingleCase(chrono.ru, "в следующем квартале", new Date(2016, 10 - 1, 1, 12), (result, text) => {
         expect(result.index).toBe(0);
         expect(result.text).toBe(text);
-        expect(result.start).toBeDate(new Date(2017, 1 - 1, 1, 12));
+        expect(result.start.get("year")).toBe(2017);
+        expect(result.start.get("month")).toBe(1);
+        expect(result.start.get("day")).toBe(1);
+        expect(result.start.get("hour")).toBe(12);
     });
 
     testSingleCase(chrono.ru, "в следующем году", new Date(2016, 10 - 1, 1, 12), (result, text) => {
         expect(result.index).toBe(0);
         expect(result.text).toBe(text);
-        expect(result.start).toBeDate(new Date(2017, 10 - 1, 1, 12));
+        expect(result.start.get("year")).toBe(2017);
+        expect(result.start.get("month")).toBe(10);
+        expect(result.start.get("day")).toBe(1);
+        expect(result.start.get("hour")).toBe(12);
     });
 });

package/test/ru/ru_time_units_casual_relative.test.ts

@@ -5,93 +5,143 @@ test("Test - Positive time units", () => {
     testSingleCase(chrono.ru, "следующие 2 недели", new Date(2016, 10 - 1, 1, 12), (result, text) => {
         expect(result.index).toBe(0);
         expect(result.text).toBe(text);
-        expect(result.start).toBeDate(new Date(2016, 10 - 1, 15, 12));
+        expect(result.start.get("year")).toBe(2016);
+        expect(result.start.get("month")).toBe(10);
+        expect(result.start.get("day")).toBe(15);
+        expect(result.start.get("hour")).toBe(12);
     });
 
     testSingleCase(chrono.ru, "следующие 2 дня", new Date(2016, 10 - 1, 1, 12), (result, text) => {
         expect(result.index).toBe(0);
         expect(result.text).toBe(text);
-        expect(result.start).toBeDate(new Date(2016, 10 - 1, 3, 12));
+        expect(result.start.get("year")).toBe(2016);
+        expect(result.start.get("month")).toBe(10);
+        expect(result.start.get("day")).toBe(3);
+        expect(result.start.get("hour")).toBe(12);
     });
 
     testSingleCase(chrono.ru, "следующие два года", new Date(2016, 10 - 1, 1, 12), (result, text) => {
         expect(result.index).toBe(0);
         expect(result.text).toBe(text);
-        expect(result.start).toBeDate(new Date(2018, 10 - 1, 1, 12));
+        expect(result.start.get("year")).toBe(2018);
+        expect(result.start.get("month")).toBe(10);
+        expect(result.start.get("day")).toBe(1);
+        expect(result.start.get("hour")).toBe(12);
     });
 
     testSingleCase(chrono.ru, "следующие 2 недели 3 дня", new Date(2016, 10 - 1, 1, 12), (result, text) => {
         expect(result.index).toBe(0);
         expect(result.text).toBe(text);
-        expect(result.start).toBeDate(new Date(2016, 10 - 1, 18, 12));
+        expect(result.start.get("year")).toBe(2016);
+        expect(result.start.get("month")).toBe(10);
+        expect(result.start.get("day")).toBe(18);
+        expect(result.start.get("hour")).toBe(12);
     });
 
     testSingleCase(chrono.ru, "через пару минут", new Date(2016, 10 - 1, 1, 12), (result, text) => {
         expect(result.index).toBe(0);
         expect(result.text).toBe(text);
-        expect(result.start).toBeDate(new Date(2016, 10 - 1, 1, 12, 2));
+        expect(result.start.get("year")).toBe(2016);
+        expect(result.start.get("month")).toBe(10);
+        expect(result.start.get("day")).toBe(1);
+        expect(result.start.get("hour")).toBe(12);
+        expect(result.start.get("minute")).toBe(2);
     });
 
     testSingleCase(chrono.ru, "через полчаса", new Date(2016, 10 - 1, 1, 12), (result, text) => {
         expect(result.index).toBe(0);
         expect(result.text).toBe(text);
-        expect(result.start).toBeDate(new Date(2016, 10 - 1, 1, 12, 30));
+        expect(result.start.get("year")).toBe(2016);
+        expect(result.start.get("month")).toBe(10);
+        expect(result.start.get("day")).toBe(1);
+        expect(result.start.get("hour")).toBe(12);
+        expect(result.start.get("minute")).toBe(30);
     });
 
     testSingleCase(chrono.ru, "через 2 часа", new Date(2016, 10 - 1, 1, 12), (result, text) => {
         expect(result.index).toBe(0);
         expect(result.text).toBe(text);
-        expect(result.start).toBeDate(new Date(2016, 10 - 1, 1, 14));
+        expect(result.start.get("year")).toBe(2016);
+        expect(result.start.get("month")).toBe(10);
+        expect(result.start.get("day")).toBe(1);
+        expect(result.start.get("hour")).toBe(14);
     });
 
     testSingleCase(chrono.ru, "спустя 2 часа", new Date(2016, 10 - 1, 1, 12), (result, text) => {
         expect(result.index).toBe(0);
         expect(result.text).toBe(text);
-        expect(result.start).toBeDate(new Date(2016, 10 - 1, 1, 14));
+        expect(result.start.get("year")).toBe(2016);
+        expect(result.start.get("month")).toBe(10);
+        expect(result.start.get("day")).toBe(1);
+        expect(result.start.get("hour")).toBe(14);
     });
 
     testSingleCase(chrono.ru, "через три месяца", new Date(2016, 10 - 1, 1, 12), (result, text) => {
         expect(result.index).toBe(0);
         expect(result.text).toBe(text);
-        expect(result.start).toBeDate(new Date(2017, 1 - 1, 1, 12));
+        expect(result.start.get("year")).toBe(2017);
+        expect(result.start.get("month")).toBe(1);
+        expect(result.start.get("day")).toBe(1);
+        expect(result.start.get("hour")).toBe(12);
     });
 
     testSingleCase(chrono.ru, "через неделю", new Date(2016, 10 - 1, 1, 12), (result, text) => {
         expect(result.index).toBe(0);
         expect(result.text).toBe(text);
-        expect(result.start).toBeDate(new Date(2016, 10 - 1, 8, 12));
+        expect(result.start.get("year")).toBe(2016);
+        expect(result.start.get("month")).toBe(10);
+        expect(result.start.get("day")).toBe(8);
+        expect(result.start.get("hour")).toBe(12);
     });
 
     testSingleCase(chrono.ru, "через месяц", new Date(2016, 10 - 1, 1, 12), (result, text) => {
         expect(result.index).toBe(0);
         expect(result.text).toBe(text);
-        expect(result.start).toBeDate(new Date(2016, 11 - 1, 1, 12));
-    });
-
-    testSingleCase(chrono.ru, "через год", new Date(2020, 11 - 1, 22, 12, 11, 32, 6), (result, text) => {
-        expect(result.index).toBe(0);
-        expect(result.text).toBe(text);
-        expect(result.start).toBeDate(new Date(2021, 11 - 1, 22, 12, 11, 32, 6));
-    });
-
-    testSingleCase(chrono.ru, "спустя год", new Date(2020, 11 - 1, 22, 12, 11, 32, 6), (result, text) => {
-        expect(result.index).toBe(0);
-        expect(result.text).toBe(text);
-        expect(result.start).toBeDate(new Date(2021, 11 - 1, 22, 12, 11, 32, 6));
-    });
+        expect(result.start.get("year")).toBe(2016);
+        expect(result.start.get("month")).toBe(11);
+        expect(result.start.get("day")).toBe(1);
+        expect(result.start.get("hour")).toBe(12);
+    });
+
+    testSingleCase(
+        chrono.ru,
+        "через год",
+        { instant: new Date("2020-11-22T03:11:02.006"), timezone: "GMT" },
+        (result, text) => {
+            expect(result.index).toBe(0);
+            expect(result.text).toBe(text);
+            expect(result.start).toBeDate(new Date("2021-11-22T03:11:02.006"));
+        }
+    );
+    testSingleCase(
+        chrono.ru,
+        "через год",
+        { instant: new Date("2020-11-22T12:11:32.006"), timezone: "GMT" },
+        (result, text) => {
+            expect(result.index).toBe(0);
+            expect(result.text).toBe(text);
+            expect(result.start).toBeDate(new Date("2021-11-22T12:11:32.006"));
+        }
+    );
 });
 
 test("Test - Negative time units", () => {
     testSingleCase(chrono.ru, "прошлые 2 недели", new Date(2016, 10 - 1, 1, 12), (result, text) => {
         expect(result.index).toBe(0);
         expect(result.text).toBe(text);
-        expect(result.start).toBeDate(new Date(2016, 9 - 1, 17, 12));
+        expect(result.start.get("year")).toBe(2016);
+        expect(result.start.get("month")).toBe(9);
+        expect(result.start.get("day")).toBe(17);
+        expect(result.start.get("hour")).toBe(12);
     });
 
     testSingleCase(chrono.ru, "прошлые два дня", new Date(2016, 10 - 1, 1, 12), (result, text) => {
         expect(result.index).toBe(0);
         expect(result.text).toBe(text);
-        expect(result.start).toBeDate(new Date(2016, 9 - 1, 29, 12));
+        expect(result.start.get("year")).toBe(2016);
+        expect(result.start.get("month")).toBe(9);
+        expect(result.start.get("day")).toBe(29);
+        expect(result.start.get("hour")).toBe(12);
     });
 });
 
@@ -99,19 +149,31 @@ test("Test - Plus '+' sign", () => {
     testSingleCase(chrono.ru.casual, "+15 минут", new Date(2012, 7 - 1, 10, 12, 14), (result, text) => {
         expect(result.index).toBe(0);
         expect(result.text).toBe(text);
-        expect(result.start).toBeDate(new Date(2012, 7 - 1, 10, 12, 29));
+        expect(result.start.get("year")).toBe(2012);
+        expect(result.start.get("month")).toBe(7);
+        expect(result.start.get("day")).toBe(10);
+        expect(result.start.get("hour")).toBe(12);
+        expect(result.start.get("minute")).toBe(29);
     });
 
     testSingleCase(chrono.ru.casual, "+15мин", new Date(2012, 7 - 1, 10, 12, 14), (result, text) => {
         expect(result.index).toBe(0);
         expect(result.text).toBe(text);
-        expect(result.start).toBeDate(new Date(2012, 7 - 1, 10, 12, 29));
+        expect(result.start.get("year")).toBe(2012);
+        expect(result.start.get("month")).toBe(7);
+        expect(result.start.get("day")).toBe(10);
+        expect(result.start.get("hour")).toBe(12);
+        expect(result.start.get("minute")).toBe(29);
     });
 
     testSingleCase(chrono.ru.casual, "+1 день 2 часа", new Date(2012, 7 - 1, 10, 12, 14), (result, text) => {
         expect(result.index).toBe(0);
         expect(result.text).toBe(text);
-        expect(result.start).toBeDate(new Date(2012, 7 - 1, 11, 14, 14));
+        expect(result.start.get("year")).toBe(2012);
+        expect(result.start.get("month")).toBe(7);
+        expect(result.start.get("day")).toBe(11);
+        expect(result.start.get("hour")).toBe(14);
+        expect(result.start.get("minute")).toBe(14);
     });
 });
 
@@ -119,6 +181,10 @@ test("Test - Minus '-' sign", () => {
     testSingleCase(chrono.ru.casual, "-3 года", new Date(2015, 7 - 1, 10, 12, 14), (result, text) => {
         expect(result.index).toBe(0);
         expect(result.text).toBe(text);
-        expect(result.start).toBeDate(new Date(2012, 7 - 1, 10, 12, 14));
+        expect(result.start.get("year")).toBe(2012);
+        expect(result.start.get("month")).toBe(7);
+        expect(result.start.get("day")).toBe(10);
+        expect(result.start.get("hour")).toBe(12);
+        expect(result.start.get("minute")).toBe(14);
     });
 });

package/test/system.test.ts

@@ -5,6 +5,7 @@ import UnlikelyFormatFilter from "../src/common/refiners/UnlikelyFormatFilter";
 import SlashDateFormatParser from "../src/common/parsers/SlashDateFormatParser";
 import ENWeekdayParser from "../src/locales/en/parsers/ENWeekdayParser";
 import ENTimeUnitCasualRelativeFormatParser from "../src/locales/en/parsers/ENTimeUnitCasualRelativeFormatParser";
+import { ParsingComponents } from "../src/";
 
 //-------------------------------------
 
@@ -124,6 +125,42 @@ test("Test - Add custom refiner example", () => {
     });
 });
 
+test("Test - Add custom parser with tags example", () => {
+    const custom = chrono.casual.clone();
+    custom.parsers.push({
+        pattern: () => {
+            return /\bChristmas\b/i;
+        },
+        extract: (context) => {
+            return context
+                .createParsingComponents({
+                    day: 25,
+                    month: 12,
+                })
+                .addTag("parser/ChristmasDayParser");
+        },
+    });
+
+    testSingleCase(custom, "Doing something tomorrow", (result) => {
+        expect(result.text).toBe("tomorrow");
+        expect(result.tags()).toContain("parser/ENCasualDateParser");
+    });
+
+    testSingleCase(custom, "I'll arrive at 2.30AM on Christmas", (result) => {
+        expect(result.text).toBe("at 2.30AM on Christmas");
+        expect(result.tags()).toContain("parser/ChristmasDayParser");
+        expect(result.tags()).toContain("parser/ENTimeExpressionParser");
+    });
+
+    testSingleCase(custom, "I'll arrive at Christmas night", (result) => {
+        expect(result.text).toBe("Christmas night");
+        expect(result.tags()).toContain("parser/ChristmasDayParser");
+        expect(result.tags()).toContain("parser/ENCasualTimeParser");
+    });
+
+    // TODO: Check if the merge date range combine tags correctly
+});
+
 test("Test - Remove a parser example", () => {
     const custom = chrono.en.strict.clone();
     custom.parsers = custom.parsers.filter((r) => !(r instanceof SlashDateFormatParser));

package/test/uk/uk_relative.test.ts

@@ -5,25 +5,37 @@ test("Test - 'This' expressions", () => {
     testSingleCase(chrono.uk, "на цьому тижні", new Date(2017, 11 - 1, 19, 12), (result, text) => {
         expect(result.index).toBe(0);
         expect(result.text).toBe(text);
-        expect(result.start).toBeDate(new Date(2017, 11 - 1, 19, 12));
+        expect(result.start.get("year")).toBe(2017);
+        expect(result.start.get("month")).toBe(11);
+        expect(result.start.get("day")).toBe(19);
+        expect(result.start.get("hour")).toBe(12);
     });
 
     testSingleCase(chrono.uk, "у цьому місяці", new Date(2017, 11 - 1, 19, 12), (result, text) => {
         expect(result.index).toBe(0);
         expect(result.text).toBe(text);
-        expect(result.start).toBeDate(new Date(2017, 11 - 1, 1, 12));
+        expect(result.start.get("year")).toBe(2017);
+        expect(result.start.get("month")).toBe(11);
+        expect(result.start.get("day")).toBe(1);
+        expect(result.start.get("hour")).toBe(12);
     });
 
     testSingleCase(chrono.uk, "цього місяця", new Date(2017, 11 - 1, 1, 12), (result, text) => {
         expect(result.index).toBe(0);
         expect(result.text).toBe(text);
-        expect(result.start).toBeDate(new Date(2017, 11 - 1, 1, 12));
+        expect(result.start.get("year")).toBe(2017);
+        expect(result.start.get("month")).toBe(11);
+        expect(result.start.get("day")).toBe(1);
+        expect(result.start.get("hour")).toBe(12);
     });
 
     testSingleCase(chrono.uk, "у цьому році", new Date(2017, 11 - 1, 19, 12), (result, text) => {
         expect(result.index).toBe(0);
         expect(result.text).toBe(text);
-        expect(result.start).toBeDate(new Date(2017, 1 - 1, 1, 12));
+        expect(result.start.get("year")).toBe(2017);
+        expect(result.start.get("month")).toBe(1);
+        expect(result.start.get("day")).toBe(1);
+        expect(result.start.get("hour")).toBe(12);
     });
 });
 
@@ -31,19 +43,28 @@ test("Test - Past relative expressions", () => {
     testSingleCase(chrono.uk, "на минулому тижні", new Date(2016, 10 - 1, 1, 12), (result, text) => {
         expect(result.index).toBe(0);
         expect(result.text).toBe(text);
-        expect(result.start).toBeDate(new Date(2016, 9 - 1, 24, 12));
+        expect(result.start.get("year")).toBe(2016);
+        expect(result.start.get("month")).toBe(9);
+        expect(result.start.get("day")).toBe(24);
+        expect(result.start.get("hour")).toBe(12);
     });
 
     testSingleCase(chrono.uk, "минулого місяця", new Date(2016, 10 - 1, 1, 12), (result, text) => {
         expect(result.index).toBe(0);
         expect(result.text).toBe(text);
-        expect(result.start).toBeDate(new Date(2016, 9 - 1, 1, 12));
+        expect(result.start.get("year")).toBe(2016);
+        expect(result.start.get("month")).toBe(9);
+        expect(result.start.get("day")).toBe(1);
+        expect(result.start.get("hour")).toBe(12);
     });
 
     testSingleCase(chrono.uk, "у минулому році", new Date(2016, 10 - 1, 1, 12), (result, text) => {
         expect(result.index).toBe(0);
         expect(result.text).toBe(text);
-        expect(result.start).toBeDate(new Date(2015, 10 - 1, 1, 12));
+        expect(result.start.get("year")).toBe(2015);
+        expect(result.start.get("month")).toBe(10);
+        expect(result.start.get("day")).toBe(1);
+        expect(result.start.get("hour")).toBe(12);
     });
 });
 
@@ -51,24 +72,36 @@ test("Test - Future relative expressions", () => {
     testSingleCase(chrono.uk, "на наступному тижні", new Date(2016, 10 - 1, 1, 12), (result, text) => {
         expect(result.index).toBe(0);
         expect(result.text).toBe(text);
-        expect(result.start).toBeDate(new Date(2016, 10 - 1, 8, 12));
+        expect(result.start.get("year")).toBe(2016);
+        expect(result.start.get("month")).toBe(10);
+        expect(result.start.get("day")).toBe(8);
+        expect(result.start.get("hour")).toBe(12);
     });
 
     testSingleCase(chrono.uk, "наступного місяця", new Date(2016, 10 - 1, 1, 12), (result, text) => {
         expect(result.index).toBe(0);
         expect(result.text).toBe(text);
-        expect(result.start).toBeDate(new Date(2016, 11 - 1, 1, 12));
+        expect(result.start.get("year")).toBe(2016);
+        expect(result.start.get("month")).toBe(11);
+        expect(result.start.get("day")).toBe(1);
+        expect(result.start.get("hour")).toBe(12);
     });
 
     testSingleCase(chrono.uk, "в наступному кварталі", new Date(2016, 10 - 1, 1, 12), (result, text) => {
         expect(result.index).toBe(0);
         expect(result.text).toBe(text);
-        expect(result.start).toBeDate(new Date(2017, 1 - 1, 1, 12));
+        expect(result.start.get("year")).toBe(2017);
+        expect(result.start.get("month")).toBe(1);
+        expect(result.start.get("day")).toBe(1);
+        expect(result.start.get("hour")).toBe(12);
     });
 
     testSingleCase(chrono.uk, "наступного року", new Date(2016, 10 - 1, 1, 12), (result, text) => {
         expect(result.index).toBe(0);
         expect(result.text).toBe(text);
-        expect(result.start).toBeDate(new Date(2017, 10 - 1, 1, 12));
+        expect(result.start.get("year")).toBe(2017);
+        expect(result.start.get("month")).toBe(10);
+        expect(result.start.get("day")).toBe(1);
+        expect(result.start.get("hour")).toBe(12);
     });
 });

package/test/uk/uk_time_units_casual_relative.test.ts

@@ -5,25 +5,37 @@ test("Test - Positive time units", () => {
     testSingleCase(chrono.uk, "наступні 2 тижні", new Date(2016, 10 - 1, 1, 12), (result, text) => {
         expect(result.index).toBe(0);
         expect(result.text).toBe(text);
-        expect(result.start).toBeDate(new Date(2016, 10 - 1, 15, 12));
+        expect(result.start.get("year")).toBe(2016);
+        expect(result.start.get("month")).toBe(10);
+        expect(result.start.get("day")).toBe(15);
+        expect(result.start.get("hour")).toBe(12);
     });
 
     testSingleCase(chrono.uk, "наступні 2 дні", new Date(2016, 10 - 1, 1, 12), (result, text) => {
         expect(result.index).toBe(0);
         expect(result.text).toBe(text);
-        expect(result.start).toBeDate(new Date(2016, 10 - 1, 3, 12));
+        expect(result.start.get("year")).toBe(2016);
+        expect(result.start.get("month")).toBe(10);
+        expect(result.start.get("day")).toBe(3);
+        expect(result.start.get("hour")).toBe(12);
     });
 
     testSingleCase(chrono.uk, "наступні два роки", new Date(2016, 10 - 1, 1, 12), (result, text) => {
         expect(result.index).toBe(0);
         expect(result.text).toBe(text);
-        expect(result.start).toBeDate(new Date(2018, 10 - 1, 1, 12));
+        expect(result.start.get("year")).toBe(2018);
+        expect(result.start.get("month")).toBe(10);
+        expect(result.start.get("day")).toBe(1);
+        expect(result.start.get("hour")).toBe(12);
     });
 
     testSingleCase(chrono.uk, "наступні 2 тижні 3 дні", new Date(2016, 10 - 1, 1, 12), (result, text) => {
         expect(result.index).toBe(0);
         expect(result.text).toBe(text);
-        expect(result.start).toBeDate(new Date(2016, 10 - 1, 18, 12));
+        expect(result.start.get("year")).toBe(2016);
+        expect(result.start.get("month")).toBe(10);
+        expect(result.start.get("day")).toBe(18);
+        expect(result.start.get("hour")).toBe(12);
     });
 
     testSingleCase(chrono.uk, "через декілька хвилин", new Date(2016, 10 - 1, 1, 12), (result, text) => {
@@ -41,25 +53,37 @@ test("Test - Positive time units", () => {
     testSingleCase(chrono.uk, "через 2 години", new Date(2016, 10 - 1, 1, 12), (result, text) => {
         expect(result.index).toBe(0);
         expect(result.text).toBe(text);
-        expect(result.start).toBeDate(new Date(2016, 10 - 1, 1, 14));
+        expect(result.start.get("year")).toBe(2016);
+        expect(result.start.get("month")).toBe(10);
+        expect(result.start.get("day")).toBe(1);
+        expect(result.start.get("hour")).toBe(14);
     });
 
     testSingleCase(chrono.uk, "через три місяці", new Date(2016, 10 - 1, 1, 12), (result, text) => {
         expect(result.index).toBe(0);
         expect(result.text).toBe(text);
-        expect(result.start).toBeDate(new Date(2017, 1 - 1, 1, 12));
+        expect(result.start.get("year")).toBe(2017);
+        expect(result.start.get("month")).toBe(1);
+        expect(result.start.get("day")).toBe(1);
+        expect(result.start.get("hour")).toBe(12);
     });
 
     testSingleCase(chrono.uk, "через тиждень", new Date(2016, 10 - 1, 1, 12), (result, text) => {
         expect(result.index).toBe(0);
         expect(result.text).toBe(text);
-        expect(result.start).toBeDate(new Date(2016, 10 - 1, 8, 12));
+        expect(result.start.get("year")).toBe(2016);
+        expect(result.start.get("month")).toBe(10);
+        expect(result.start.get("day")).toBe(8);
+        expect(result.start.get("hour")).toBe(12);
     });
 
     testSingleCase(chrono.uk, "через місяць", new Date(2016, 10 - 1, 1, 12), (result, text) => {
         expect(result.index).toBe(0);
         expect(result.text).toBe(text);
-        expect(result.start).toBeDate(new Date(2016, 11 - 1, 1, 12));
+        expect(result.start.get("year")).toBe(2016);
+        expect(result.start.get("month")).toBe(11);
+        expect(result.start.get("day")).toBe(1);
+        expect(result.start.get("hour")).toBe(12);
     });
 
     testSingleCase(chrono.uk, "через рік", new Date(2020, 11 - 1, 22, 12, 11, 32, 6), (result, text) => {
@@ -73,13 +97,19 @@ test("Test - Negative time units", () => {
     testSingleCase(chrono.uk, "минулі 2 тижні", new Date(2016, 10 - 1, 1, 12), (result, text) => {
         expect(result.index).toBe(0);
         expect(result.text).toBe(text);
-        expect(result.start).toBeDate(new Date(2016, 9 - 1, 17, 12));
+        expect(result.start.get("year")).toBe(2016);
+        expect(result.start.get("month")).toBe(9);
+        expect(result.start.get("day")).toBe(17);
+        expect(result.start.get("hour")).toBe(12);
     });
 
     testSingleCase(chrono.uk, "минулі два дні", new Date(2016, 10 - 1, 1, 12), (result, text) => {
         expect(result.index).toBe(0);
         expect(result.text).toBe(text);
-        expect(result.start).toBeDate(new Date(2016, 9 - 1, 29, 12));
+        expect(result.start.get("year")).toBe(2016);
+        expect(result.start.get("month")).toBe(9);
+        expect(result.start.get("day")).toBe(29);
+        expect(result.start.get("hour")).toBe(12);
     });
 });