chrono-node 2.8.3 → 2.8.5

package/test/it/it_weekday.test.ts

@@ -0,0 +1,37 @@
+import * as chrono from "../../src/";
+import { testSingleCase } from "../test_util";
+
+test("Test - Single Expression", function () {
+    testSingleCase(chrono.it, "Lunedì", new Date(2012, 7, 9), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("Lunedì");
+
+        expect(result.start).not.toBeNull();
+        expect(result.start.get("year")).toBe(2012);
+        expect(result.start.get("month")).toBe(8);
+        expect(result.start.get("day")).toBe(6);
+        expect(result.start.get("weekday")).toBe(1);
+    });
+
+    testSingleCase(chrono.it, "Giovedì", new Date(2012, 7, 9), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("Giovedì");
+
+        expect(result.start).not.toBeNull();
+        expect(result.start.get("year")).toBe(2012);
+        expect(result.start.get("month")).toBe(8);
+        expect(result.start.get("day")).toBe(9);
+        expect(result.start.get("weekday")).toBe(4);
+    });
+
+    testSingleCase(chrono.it, "Domenica", new Date(2012, 7, 9), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("Domenica");
+
+        expect(result.start).not.toBeNull();
+        expect(result.start.get("year")).toBe(2012);
+        expect(result.start.get("month")).toBe(8);
+        expect(result.start.get("day")).toBe(12);
+        expect(result.start.get("weekday")).toBe(0);
+    });
+});

package/test/ja/ja_time_exp.test.ts

@@ -1,5 +1,6 @@
 import * as chrono from "../../src";
-import { testSingleCase } from "../test_util";
+import { testSingleCase, testUnexpectedResult } from "../test_util";
+import { Meridiem } from "../../src";
 
 test("Test - Single Expression", function () {
     testSingleCase(chrono.ja, "私は午前6時13分に起きた", new Date(2012, 7, 10), (result) => {
@@ -165,28 +166,34 @@ test("Test - Date + Time Expression", function () {
 });
 
 test("Test - Time Expression's Meridiem imply", function () {
-    testSingleCase(chrono.ja, "午後1時から3時", new Date(2012, 7, 10), (result) => {
-        expect(result.index).toBe(0);
-        expect(result.text).toBe("午後1時から3時");
+    testSingleCase(chrono.ja, "午後1時30分から3時10分", new Date(2012, 7, 10), (result) => {
+        expect(result.start.get("hour")).toBe(13);
+        expect(result.start.get("minute")).toBe(30);
+        expect(result.start.get("second")).toBe(0);
+        expect(result.start.get("meridiem")).toBe(Meridiem.PM);
+        expect(result.start.isCertain("meridiem")).toBe(true);
+        expect(result.start).toBeDate(new Date(2012, 8 - 1, 10, 13, 30));
 
-        expect(result.start.get("year")).toBe(2012);
-        expect(result.start.get("month")).toBe(8);
-        expect(result.start.get("day")).toBe(10);
+        expect(result.end.get("hour")).toBe(15);
+        expect(result.end.get("minute")).toBe(10);
+        expect(result.end.get("second")).toBe(0);
+        expect(result.end.get("meridiem")).toBe(Meridiem.PM);
+        expect(result.end).toBeDate(new Date(2012, 8 - 1, 10, 15, 10));
+    });
+
+    testSingleCase(chrono.ja, "1時20分P.M.から3時", new Date(2012, 7, 10), (result) => {
         expect(result.start.get("hour")).toBe(13);
-        expect(result.start.get("minute")).toBe(0);
+        expect(result.start.get("minute")).toBe(20);
         expect(result.start.get("second")).toBe(0);
-        expect(result.start.get("millisecond")).toBe(0);
-        expect(result.start.get("meridiem")).toBe(1);
+        expect(result.start.get("meridiem")).toBe(Meridiem.PM);
         expect(result.start.isCertain("meridiem")).toBe(true);
+        expect(result.start).toBeDate(new Date(2012, 8 - 1, 10, 13, 20));
 
-        expect(result.end.get("year")).toBe(2012);
-        expect(result.end.get("month")).toBe(8);
-        expect(result.end.get("day")).toBe(10);
         expect(result.end.get("hour")).toBe(15);
         expect(result.end.get("minute")).toBe(0);
         expect(result.end.get("second")).toBe(0);
-        expect(result.end.get("millisecond")).toBe(0);
-        expect(result.start.get("meridiem")).toBe(1);
+        expect(result.end.get("meridiem")).toBe(Meridiem.PM);
+        expect(result.end).toBeDate(new Date(2012, 8 - 1, 10, 15, 0));
     });
 
     testSingleCase(chrono.ja, "午後６時半－１１時", new Date(2012, 7, 10), (result) => {
@@ -196,16 +203,44 @@ test("Test - Time Expression's Meridiem imply", function () {
         expect(result.start).not.toBeNull();
         expect(result.start.get("hour")).toBe(18);
         expect(result.start.get("minute")).toBe(30);
-        expect(result.start.get("meridiem")).toBe(1);
-
-        const resultDate = result.start.date();
-        const expectDate = new Date(2012, 7, 10, 18, 30);
-        expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime());
+        expect(result.start.get("meridiem")).toBe(Meridiem.PM);
+        expect(result.start).toBeDate(new Date(2012, 8 - 1, 10, 18, 30));
 
         expect(result.end).not.toBeNull();
         expect(result.end.get("hour")).toBe(23);
         expect(result.end.get("minute")).toBe(0);
-        expect(result.end.get("meridiem")).toBe(1);
+        expect(result.end.get("meridiem")).toBe(Meridiem.PM);
+        expect(result.end).toBeDate(new Date(2012, 8 - 1, 10, 23, 0));
+    });
+
+    testSingleCase(chrono.ja, "午後１１時半－１時", new Date(2012, 8 - 1, 10), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("午後１１時半－１時");
+
+        expect(result.start.get("hour")).toBe(23);
+        expect(result.start.get("minute")).toBe(30);
+        expect(result.start.get("meridiem")).toBe(Meridiem.PM);
+        expect(result.start).toBeDate(new Date(2012, 8 - 1, 10, 23, 30));
+
+        expect(result.end.get("hour")).toBe(1);
+        expect(result.end.get("minute")).toBe(0);
+        expect(result.end.get("meridiem")).toBe(Meridiem.AM);
+        expect(result.end).toBeDate(new Date(2012, 8 - 1, 11, 1, 0));
+    });
+
+    testSingleCase(chrono.ja, "23時20分から2時", new Date(2012, 8 - 1, 10), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("23時20分から2時");
+
+        expect(result.start.get("hour")).toBe(23);
+        expect(result.start.get("minute")).toBe(20);
+        expect(result.start.get("meridiem")).toBe(Meridiem.PM);
+        expect(result.start).toBeDate(new Date(2012, 8 - 1, 10, 23, 20));
+
+        expect(result.end.get("hour")).toBe(2);
+        expect(result.end.get("minute")).toBe(0);
+        expect(result.end.get("meridiem")).toBe(Meridiem.AM);
+        expect(result.end).toBeDate(new Date(2012, 8 - 1, 11, 2, 0));
     });
 });
 
@@ -242,3 +277,29 @@ test("Test - Random date + time expression", function () {
         expect(result.start.get("hour")).toBe(12);
     });
 });
+
+test("Test - Incorrect time expressions", () => {
+    testUnexpectedResult(chrono.ja, "午後１3時");
+
+    testUnexpectedResult(chrono.ja, "25時");
+
+    testUnexpectedResult(chrono.ja, "5時70分");
+
+    testUnexpectedResult(chrono.ja, "5時30分65秒");
+
+    testUnexpectedResult(chrono.ja, "23時-25時");
+
+    testUnexpectedResult(chrono.ja, "3時-5時70分");
+
+    testUnexpectedResult(chrono.ja, "3時-5時30分65秒");
+});
+
+test("Test - Non time expressions", () => {
+    testUnexpectedResult(chrono.ja, "1");
+    testUnexpectedResult(chrono.ja, "12");
+    testUnexpectedResult(chrono.ja, "12a");
+
+    testUnexpectedResult(chrono.ja, "1時間");
+
+    testUnexpectedResult(chrono.ja, "25時間");
+});

package/test/result.test.ts

@@ -1,7 +1,7 @@
 import { ParsingComponents, ParsingResult, ReferenceWithTimezone } from "../src/results";
 
 test("Test - Create & manipulate parsing components", () => {
-    const reference = new ReferenceWithTimezone(new Date());
+    const reference = ReferenceWithTimezone.fromDate(new Date());
     const components = new ParsingComponents(reference, { year: 2014, month: 11, day: 24 });
 
     expect(components.get("year")).toBe(2014);
@@ -38,6 +38,30 @@ test("Test - Create & manipulate parsing components", () => {
     expect(components.toString()).toContain("custom/testing_component_tag");
 });
 
+test("Test - Creating component from reference date (and duration)", () => {
+    {
+        const reference = ReferenceWithTimezone.fromDate(new Date("Sat, Aug 27 2022 12:52:11"));
+        const components = ParsingComponents.createRelativeFromReference(reference);
+        expect(components.date()).toStrictEqual(new Date("Sat, Aug 27 2022 12:52:11"));
+        expect(components.isCertain("day")).toBe(true);
+        expect(components.isCertain("hour")).toBe(true);
+    }
+    {
+        const reference = ReferenceWithTimezone.fromDate(new Date("Sat, Aug 27 2022 12:52:11"));
+        const components = ParsingComponents.createRelativeFromReference(reference, { day: 3 });
+        expect(components.date()).toStrictEqual(new Date("Sat, Aug 30 2022 12:52:11"));
+        expect(components.isCertain("day")).toBe(true);
+        expect(components.isCertain("hour")).toBe(false);
+    }
+    {
+        const reference = ReferenceWithTimezone.fromDate(new Date("Sat, Aug 27 2022 12:52:11"));
+        const components = ParsingComponents.createRelativeFromReference(reference, { day: 1, hour: 3 });
+        expect(components.date()).toStrictEqual(new Date("Sat, Aug 28 2022 15:52:11"));
+        expect(components.isCertain("day")).toBe(true);
+        expect(components.isCertain("hour")).toBe(true);
+    }
+});
+
 test("Test - Create & manipulate parsing results", () => {
     const reference = new ReferenceWithTimezone(new Date());
     const text = "1 - 2 hour later";
@@ -178,24 +202,74 @@ test("Test - Checking non-existing date during DST skip", () => {
 
 test("Test - Getting timezone adjust date from references", () => {
     {
-        const reference = new ReferenceWithTimezone({
+        const reference = ReferenceWithTimezone.fromInput({
             instant: new Date("Wed Jun 09 2021 07:21:32 GMT+0900 (JST)"),
             timezone: 9 * 60,
         });
         expect(reference.getDateWithAdjustedTimezone()).toStrictEqual(new Date(2021, 6 - 1, 9, 7, 21, 32));
     }
     {
-        const reference = new ReferenceWithTimezone({
+        const reference = ReferenceWithTimezone.fromInput({
             instant: new Date("Wed Jun 09 2021 07:21:32 GMT+0900 (JST)"),
             timezone: "JST",
         });
         expect(reference.getDateWithAdjustedTimezone()).toStrictEqual(new Date(2021, 6 - 1, 9, 7, 21, 32));
     }
     {
-        const reference = new ReferenceWithTimezone({
+        const reference = ReferenceWithTimezone.fromInput({
             instant: new Date("Wed Jun 09 2021 07:21:32 GMT-0500 (CDT)"),
             timezone: "CDT",
         });
         expect(reference.getDateWithAdjustedTimezone()).toStrictEqual(new Date(2021, 6 - 1, 9, 7, 21, 32));
     }
 });
+
+test("Test - ParsingComponents.addDurationAsImplied", () => {
+    {
+        const reference = ReferenceWithTimezone.fromDate(new Date("Sat, Aug 27 2022 12:52:11"));
+        const components = ParsingComponents.createRelativeFromReference(reference);
+        components.addDurationAsImplied({ hour: 3 });
+
+        expect(components.date()).toStrictEqual(new Date("Sat, Aug 27 2022 15:52:11"));
+        expect(components.isCertain("second")).toBe(false);
+        expect(components.isCertain("minute")).toBe(false);
+        expect(components.isCertain("hour")).toBe(false);
+    }
+    {
+        const reference = ReferenceWithTimezone.fromDate(new Date("Sat, Aug 27 2022 12:52:11"));
+        const components = ParsingComponents.createRelativeFromReference(reference);
+        components.addDurationAsImplied({ day: 3 });
+        expect(components.date()).toStrictEqual(new Date("Sat, Aug 30 2022 12:52:11"));
+        expect(components.isCertain("day")).toBe(false);
+        expect(components.isCertain("weekday")).toBe(false);
+        expect(components.isCertain("month")).toBe(false);
+        expect(components.isCertain("year")).toBe(false);
+    }
+});
+
+test("Test - ParsingComponents.addDurationAsImplied on different timezones", () => {
+    {
+        // Thu Feb 27 2025 17:00:00 GMT+0000
+        // Fri Feb 28 2025 02:00:00 GMT+0900 (JST)
+        const refInstant = new Date("Thu Feb 27 2025 17:00:00 GMT+0000");
+        const reference = ReferenceWithTimezone.fromInput({ instant: refInstant, timezone: "JST" });
+        const components = ParsingComponents.createRelativeFromReference(reference);
+        components.addDurationAsImplied({ hour: 3 });
+        expect(components.date()).toStrictEqual(new Date("Fri Feb 28 2025 05:00:00 GMT+0900 (JST)"));
+
+        components.addDurationAsImplied({ day: 3 });
+        expect(components.date()).toStrictEqual(new Date("Mon Mar 3 2025 05:00:00 GMT+0900 (JST)"));
+    }
+    {
+        // Thu Feb 27 2025 17:00:00 GMT+0000
+        // Thu Feb 27 2025 09:00:00 GMT-0800 (PST)
+        const refInstant = new Date("Thu Feb 27 2025 17:00:00 GMT+0000");
+        const reference = ReferenceWithTimezone.fromInput({ instant: refInstant, timezone: "PST" });
+        const components = ParsingComponents.createRelativeFromReference(reference);
+        components.addDurationAsImplied({ hour: 3 });
+        expect(components.date()).toStrictEqual(new Date("Thu Feb 27 2025 12:00:00 GMT-0800 (PST)"));
+
+        components.addDurationAsImplied({ day: 3 });
+        expect(components.date()).toStrictEqual(new Date("Mon Mar 2 2025 12:00:00 GMT-0800 (PST)"));
+    }
+});

package/test/sv/sv_casual.test.ts

@@ -0,0 +1,87 @@
+import * as chrono from "../../src/locales/sv";
+import { testSingleCase } from "../test_util";
+
+test("Test - Single Expression", function () {
+    testSingleCase(chrono, "idag", new Date(2012, 7, 10), (result) => {
+        expect(result.start.get("year")).toBe(2012);
+        expect(result.start.get("month")).toBe(8);
+        expect(result.start.get("day")).toBe(10);
+    });
+
+    testSingleCase(chrono, "imorgon", new Date(2012, 7, 10), (result) => {
+        expect(result.start.get("year")).toBe(2012);
+        expect(result.start.get("month")).toBe(8);
+        expect(result.start.get("day")).toBe(11);
+    });
+
+    testSingleCase(chrono, "igår", new Date(2012, 7, 10), (result) => {
+        expect(result.start.get("year")).toBe(2012);
+        expect(result.start.get("month")).toBe(8);
+        expect(result.start.get("day")).toBe(9);
+    });
+
+    testSingleCase(chrono, "förrgår", new Date(2012, 7, 10), (result) => {
+        expect(result.start.get("year")).toBe(2012);
+        expect(result.start.get("month")).toBe(8);
+        expect(result.start.get("day")).toBe(8);
+    });
+});
+
+test("Test - Combined Expression", function () {
+    testSingleCase(chrono, "idag på morgonen", new Date(2012, 7, 10), (result) => {
+        expect(result.start.get("year")).toBe(2012);
+        expect(result.start.get("month")).toBe(8);
+        expect(result.start.get("day")).toBe(10);
+        expect(result.start.get("hour")).toBe(6);
+    });
+
+    testSingleCase(chrono, "idag på förmiddagen", new Date(2012, 7, 10), (result) => {
+        expect(result.start.get("year")).toBe(2012);
+        expect(result.start.get("month")).toBe(8);
+        expect(result.start.get("day")).toBe(10);
+        expect(result.start.get("hour")).toBe(9);
+    });
+
+    testSingleCase(chrono, "idag på middagen", new Date(2012, 7, 10), (result) => {
+        expect(result.start.get("year")).toBe(2012);
+        expect(result.start.get("month")).toBe(8);
+        expect(result.start.get("day")).toBe(10);
+        expect(result.start.get("hour")).toBe(12);
+    });
+
+    testSingleCase(chrono, "idag på eftermiddagen", new Date(2012, 7, 10), (result) => {
+        expect(result.start.get("year")).toBe(2012);
+        expect(result.start.get("month")).toBe(8);
+        expect(result.start.get("day")).toBe(10);
+        expect(result.start.get("hour")).toBe(15);
+    });
+
+    testSingleCase(chrono, "idag på kvällen", new Date(2012, 7, 10), (result) => {
+        expect(result.start.get("year")).toBe(2012);
+        expect(result.start.get("month")).toBe(8);
+        expect(result.start.get("day")).toBe(10);
+        expect(result.start.get("hour")).toBe(20);
+    });
+
+    testSingleCase(chrono, "idag på natten", new Date(2012, 7, 10), (result) => {
+        expect(result.start.get("year")).toBe(2012);
+        expect(result.start.get("month")).toBe(8);
+        expect(result.start.get("day")).toBe(10);
+        expect(result.start.get("hour")).toBe(2);
+    });
+
+    testSingleCase(chrono, "idag vid midnatt", new Date(2012, 7, 10), (result) => {
+        expect(result.start.get("year")).toBe(2012);
+        expect(result.start.get("month")).toBe(8);
+        expect(result.start.get("day")).toBe(10);
+        expect(result.start.get("hour")).toBe(0);
+    });
+
+    // Denna funktionalitet behöver ytterligare utveckling
+    // testSingleCase(chrono, "imorgon kväll", new Date(2012, 7, 10), (result) => {
+    //     expect(result.start.get("year")).toBe(2012);
+    //     expect(result.start.get("month")).toBe(8);
+    //     expect(result.start.get("day")).toBe(11);
+    //     expect(result.start.get("hour")).toBe(20);
+    // });
+});

package/test/sv/sv_month_name_little_endian.test.ts

@@ -0,0 +1,48 @@
+import * as chrono from "../../src/locales/sv";
+import { testSingleCase, testUnexpectedResult } from "../test_util";
+
+test("Test - Single expression", function () {
+    testSingleCase(chrono, "den 15 augusti", new Date(2012, 7, 10), (result) => {
+        expect(result.start.get("year")).toBe(2012);
+        expect(result.start.get("month")).toBe(8);
+        expect(result.start.get("day")).toBe(15);
+    });
+
+    testSingleCase(chrono, "15 augusti 2012", new Date(2012, 7, 10), (result) => {
+        expect(result.start.get("year")).toBe(2012);
+        expect(result.start.get("month")).toBe(8);
+        expect(result.start.get("day")).toBe(15);
+    });
+
+    testSingleCase(chrono, "15 aug 2012", new Date(2012, 7, 10), (result) => {
+        expect(result.start.get("year")).toBe(2012);
+        expect(result.start.get("month")).toBe(8);
+        expect(result.start.get("day")).toBe(15);
+    });
+});
+
+test("Test - Range expression", function () {
+    testSingleCase(chrono, "15-16 augusti", new Date(2012, 7, 10), (result) => {
+        expect(result.start.get("year")).toBe(2012);
+        expect(result.start.get("month")).toBe(8);
+        expect(result.start.get("day")).toBe(15);
+
+        expect(result.end.get("year")).toBe(2012);
+        expect(result.end.get("month")).toBe(8);
+        expect(result.end.get("day")).toBe(16);
+    });
+
+    testSingleCase(chrono, "15 till 16 augusti", new Date(2012, 7, 10), (result) => {
+        expect(result.start.get("year")).toBe(2012);
+        expect(result.start.get("month")).toBe(8);
+        expect(result.start.get("day")).toBe(15);
+
+        expect(result.end.get("year")).toBe(2012);
+        expect(result.end.get("month")).toBe(8);
+        expect(result.end.get("day")).toBe(16);
+    });
+});
+
+test("Test - Impossible Dates", function () {
+    testUnexpectedResult(chrono, "32 augusti", new Date(2012, 7, 10));
+});

package/test/sv/sv_time_units_casual_relative.test.ts

@@ -0,0 +1,143 @@
+import * as chrono from "../../src";
+import { testSingleCase, testUnexpectedResult } from "../test_util";
+import SVTimeUnitCasualRelativeFormatParser from "../../src/locales/sv/parsers/SVTimeUnitCasualRelativeFormatParser";
+
+test("Test - Positive time units", () => {
+    testSingleCase(chrono.sv, "nästa 2 veckor", new Date(2016, 10 - 1, 1, 12), (result, text) => {
+        expect(result.text).toBe(text);
+        expect(result.start.get("year")).toBe(2016);
+        expect(result.start.get("month")).toBe(10);
+        expect(result.start.get("day")).toBe(15);
+    });
+
+    testSingleCase(chrono.sv, "nästa 2 dagar", new Date(2016, 10 - 1, 1, 12), (result, text) => {
+        expect(result.text).toBe(text);
+        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.sv, "nästa två år", new Date(2016, 10 - 1, 1, 12), (result, text) => {
+        expect(result.text).toBe(text);
+        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.sv, "nästa 2 veckor 3 dagar", new Date(2016, 10 - 1, 1, 12), (result, text) => {
+        expect(result.text).toBe(text);
+        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.sv, "efter ett år", new Date(2016, 10 - 1, 1, 12), (result, text) => {
+        expect(result.text).toBe(text);
+        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);
+    });
+
+    testSingleCase(chrono.sv, "efter en timme", new Date(2016, 10 - 1, 1, 15), (result, text) => {
+        expect(result.text).toBe(text);
+        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(16);
+    });
+});
+
+test("Test - Negative time units", () => {
+    testSingleCase(chrono.sv, "förra 2 veckor", new Date(2016, 10 - 1, 1, 12), (result, text) => {
+        expect(result.text).toBe(text);
+        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.sv, "förra två veckor", new Date(2016, 10 - 1, 1, 12), (result, text) => {
+        expect(result.text).toBe(text);
+        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.sv, "passerade 2 dagar", new Date(2016, 10 - 1, 1, 12), (result, text) => {
+        expect(result.text).toBe(text);
+        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);
+    });
+
+    testSingleCase(chrono.sv, "+2 månader, 5 dagar", new Date(2016, 10 - 1, 1, 12), (result, text) => {
+        expect(result.text).toBe(text);
+        expect(result.start.get("year")).toBe(2016);
+        expect(result.start.get("month")).toBe(12);
+        expect(result.start.get("day")).toBe(6);
+        expect(result.start.get("hour")).toBe(12);
+    });
+});
+
+test("Test - Plus '+' sign", () => {
+    testSingleCase(chrono.sv.casual, "+15 minuter", new Date(2012, 7 - 1, 10, 12, 14), (result, text) => {
+        expect(result.text).toBe(text);
+        expect(result.start.get("hour")).toBe(12);
+        expect(result.start.get("minute")).toBe(29);
+
+        expect(result.start).toBeDate(new Date(2012, 7 - 1, 10, 12, 29));
+    });
+
+    testSingleCase(chrono.sv.casual, "+15min", new Date(2012, 7 - 1, 10, 12, 14), (result, text) => {
+        expect(result.text).toBe(text);
+        expect(result.start.get("hour")).toBe(12);
+        expect(result.start.get("minute")).toBe(29);
+
+        expect(result.start).toBeDate(new Date(2012, 7 - 1, 10, 12, 29));
+    });
+
+    testSingleCase(chrono.sv.casual, "+1 dag 2 timmar", new Date(2012, 7 - 1, 10, 12, 14), (result, text) => {
+        expect(result.text).toBe(text);
+        expect(result.start.get("day")).toBe(11);
+        expect(result.start.get("hour")).toBe(14);
+        expect(result.start.get("minute")).toBe(14);
+
+        expect(result.start).toBeDate(new Date(2012, 7 - 1, 11, 14, 14));
+    });
+
+    testSingleCase(chrono.sv.casual, "+1min", new Date(2012, 7 - 1, 10, 12, 14), (result, text) => {
+        expect(result.text).toBe(text);
+        expect(result.start.get("hour")).toBe(12);
+        expect(result.start.get("minute")).toBe(15);
+
+        expect(result.start).toBeDate(new Date(2012, 7 - 1, 10, 12, 15));
+    });
+});
+
+test("Test - Minus '-' sign", () => {
+    testSingleCase(chrono.sv.casual, "-3år", new Date(2015, 7 - 1, 10, 12, 14), (result, text) => {
+        expect(result.text).toBe(text);
+        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);
+
+        expect(result.start).toBeDate(new Date(2012, 7 - 1, 10, 12, 14));
+    });
+
+    testSingleCase(chrono.sv, "-2tim5min", new Date(2016, 10 - 1, 1, 12), (result, text) => {
+        expect(result.text).toBe(text);
+        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(9);
+        expect(result.start.get("minute")).toBe(55);
+    });
+});

package/test/sv/sv_weekday.test.ts

@@ -0,0 +1,68 @@
+import * as chrono from "../../src/locales/sv";
+import { testSingleCase } from "../test_util";
+
+test("Test - Single Expression", function () {
+    testSingleCase(chrono, "måndag", new Date(2012, 7, 9), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("måndag");
+
+        expect(result.start).not.toBeNull();
+        expect(result.start.get("year")).toBe(2012);
+        expect(result.start.get("month")).toBe(8);
+        expect(result.start.get("day")).toBe(6);
+        expect(result.start.get("weekday")).toBe(1);
+    });
+
+    testSingleCase(chrono, "på måndag", new Date(2012, 7, 9), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("på måndag");
+
+        expect(result.start).not.toBeNull();
+        expect(result.start.get("year")).toBe(2012);
+        expect(result.start.get("month")).toBe(8);
+        expect(result.start.get("day")).toBe(6);
+        expect(result.start.get("weekday")).toBe(1);
+    });
+});
+
+test("Test - Next/Last Week Expression", function () {
+    testSingleCase(chrono, "nästa måndag", new Date(2012, 7, 9), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("nästa måndag");
+
+        expect(result.start).not.toBeNull();
+        expect(result.start.get("year")).toBe(2012);
+        expect(result.start.get("month")).toBe(8);
+        expect(result.start.get("day")).toBe(13);
+        expect(result.start.get("weekday")).toBe(1);
+    });
+
+    testSingleCase(chrono, "förra måndag", new Date(2012, 7, 9), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("förra måndag");
+
+        expect(result.start).not.toBeNull();
+        expect(result.start.get("year")).toBe(2012);
+        expect(result.start.get("month")).toBe(8);
+        expect(result.start.get("day")).toBe(6);
+        expect(result.start.get("weekday")).toBe(1);
+    });
+});
+
+test("Test - Weekday variations", function () {
+    testSingleCase(chrono, "söndag", new Date(2012, 7, 9), (result) => {
+        expect(result.start.get("weekday")).toBe(0);
+    });
+
+    testSingleCase(chrono, "tisdag", new Date(2012, 7, 9), (result) => {
+        expect(result.start.get("weekday")).toBe(2);
+    });
+
+    testSingleCase(chrono, "fredag", new Date(2012, 7, 9), (result) => {
+        expect(result.start.get("weekday")).toBe(5);
+    });
+
+    testSingleCase(chrono, "lördag", new Date(2012, 7, 9), (result) => {
+        expect(result.start.get("weekday")).toBe(6);
+    });
+});