Refactor time splitter, support computing of dates for time entries

2024-04-16 23:21:34 +02:00
parent 2cdfa2e948
commit bd775bec45
7 changed files with 1006 additions and 534 deletions
--- a/tests/NodaTimeSplitterTest.php
+++ b/tests/NodaTimeSplitterTest.php
@ -24,8 +24,23 @@ final class NodaTimeSplitterTest extends TestCase {
     */
    public function testSplitSimpleDatesGerman():void {

+        $output = NodaTimeSplitter::attempt_splitting("2. Januar 2020");
+        self::assertNotEmpty($output);
+        self::assertEquals($output->toOldFormat(), [
+            0 => "2020",
+            1 => "2020",
+            2 => "01",
+            3 => "02",
+            4 => "+",
+            5 => "",
+        ]);
+        self::assertEquals($output->toTimeName(), "02.01.2020");
+        self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 2020);
+
+
        $output = NodaTimeSplitter::attempt_splitting("02.1.25 v. Chr");
-        self::assertEquals($output, [
+        self::assertNotEmpty($output);
+        self::assertEquals($output->toOldFormat(), [
            0 => "-25",
            1 => "-25",
            2 => "01",
@ -33,11 +48,12 @@ final class NodaTimeSplitterTest extends TestCase {
            4 => "-",
            5 => "",
        ]);
-        self::assertEquals(NodaTimeSplitter::timePartsToTimeName($output), "02.01.25 v. Chr.");
+        self::assertEquals($output->toTimeName(), "02.01.25 v. Chr.");
        self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 25);

        $output = NodaTimeSplitter::attempt_splitting("2.01.25 v. Chr");
-        self::assertEquals($output, [
+        self::assertNotEmpty($output);
+        self::assertEquals($output->toOldFormat(), [
            0 => "-25",
            1 => "-25",
            2 => "01",
@ -45,11 +61,12 @@ final class NodaTimeSplitterTest extends TestCase {
            4 => "-",
            5 => "",
        ]);
-        self::assertEquals(NodaTimeSplitter::timePartsToTimeName($output), "02.01.25 v. Chr.");
+        self::assertEquals($output->toTimeName(), "02.01.25 v. Chr.");
        self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 25);

        $output = NodaTimeSplitter::attempt_splitting("02.01.25 v. Chr");
-        self::assertEquals($output, [
+        self::assertNotEmpty($output);
+        self::assertEquals($output->toOldFormat(), [
            0 => "-25",
            1 => "-25",
            2 => "01",
@ -57,11 +74,12 @@ final class NodaTimeSplitterTest extends TestCase {
            4 => "-",
            5 => "",
        ]);
-        self::assertEquals(NodaTimeSplitter::timePartsToTimeName($output), "02.01.25 v. Chr.");
+        self::assertEquals($output->toTimeName(), "02.01.25 v. Chr.");
        self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 25);

        $output = NodaTimeSplitter::attempt_splitting("2.1.25 v. Chr");
-        self::assertEquals($output, [
+        self::assertNotEmpty($output);
+        self::assertEquals($output->toOldFormat(), [
            0 => "-25",
            1 => "-25",
            2 => "01",
@ -69,11 +87,12 @@ final class NodaTimeSplitterTest extends TestCase {
            4 => "-",
            5 => "",
        ]);
-        self::assertEquals(NodaTimeSplitter::timePartsToTimeName($output), "02.01.25 v. Chr.");
+        self::assertEquals($output->toTimeName(), "02.01.25 v. Chr.");
        self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 25);

        $output = NodaTimeSplitter::attempt_splitting("2.1.2020");
-        self::assertEquals($output, [
+        self::assertNotEmpty($output);
+        self::assertEquals($output->toOldFormat(), [
            0 => "2020",
            1 => "2020",
            2 => "01",
@ -81,11 +100,12 @@ final class NodaTimeSplitterTest extends TestCase {
            4 => "+",
            5 => "",
        ]);
-        self::assertEquals(NodaTimeSplitter::timePartsToTimeName($output), "02.01.2020");
+        self::assertEquals($output->toTimeName(), "02.01.2020");
        self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 2020);

        $output = NodaTimeSplitter::attempt_splitting("02.01.2020");
-        self::assertEquals($output, [
+        self::assertNotEmpty($output);
+        self::assertEquals($output->toOldFormat(), [
            0 => "2020",
            1 => "2020",
            2 => "01",
@ -93,23 +113,12 @@ final class NodaTimeSplitterTest extends TestCase {
            4 => "+",
            5 => "",
        ]);
-        self::assertEquals(NodaTimeSplitter::timePartsToTimeName($output), "02.01.2020");
-        self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 2020);
-
-        $output = NodaTimeSplitter::attempt_splitting("2. Januar 2020");
-        self::assertEquals($output, [
-            0 => "2020",
-            1 => "2020",
-            2 => "01",
-            3 => "02",
-            4 => "+",
-            5 => "",
-        ]);
-        self::assertEquals(NodaTimeSplitter::timePartsToTimeName($output), "02.01.2020");
+        self::assertEquals($output->toTimeName(), "02.01.2020");
        self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 2020);

        $output = NodaTimeSplitter::attempt_splitting("1920-1929");
-        self::assertEquals($output, [
+        self::assertNotEmpty($output);
+        self::assertEquals($output->toOldFormat(), [
            0 => "1920",
            1 => "1929",
            2 => "00",
@ -117,11 +126,12 @@ final class NodaTimeSplitterTest extends TestCase {
            4 => "+",
            5 => "",
        ]);
-        self::assertEquals(NodaTimeSplitter::timePartsToTimeName($output), "1920-1929");
+        self::assertEquals($output->toTimeName(), "1920-1929");
        self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 1925);

        $output = NodaTimeSplitter::attempt_splitting("20er");
-        self::assertEquals($output, [
+        self::assertNotEmpty($output);
+        self::assertEquals($output->toOldFormat(), [
            0 => "1920",
            1 => "1929",
            2 => "00",
@ -129,11 +139,12 @@ final class NodaTimeSplitterTest extends TestCase {
            4 => "+",
            5 => "",
        ]);
-        self::assertEquals(NodaTimeSplitter::timePartsToTimeName($output), "1920-1929");
+        self::assertEquals($output->toTimeName(), "1920-1929");
        self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 1925);

        $output = NodaTimeSplitter::attempt_splitting("1920-1929");
-        self::assertEquals($output, [
+        self::assertNotEmpty($output);
+        self::assertEquals($output->toOldFormat(), [
            0 => "1920",
            1 => "1929",
            2 => "00",
@ -141,11 +152,12 @@ final class NodaTimeSplitterTest extends TestCase {
            4 => "+",
            5 => "",
        ]);
-        self::assertEquals(NodaTimeSplitter::timePartsToTimeName($output), "1920-1929");
+        self::assertEquals($output->toTimeName(), "1920-1929");
        self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 1925);

        $output = NodaTimeSplitter::attempt_splitting("1920er Jahre");
-        self::assertEquals($output, [
+        self::assertNotEmpty($output);
+        self::assertEquals($output->toOldFormat(), [
            0 => "1920",
            1 => "1929",
            2 => "00",
@ -153,11 +165,12 @@ final class NodaTimeSplitterTest extends TestCase {
            4 => "+",
            5 => "",
        ]);
-        self::assertEquals(NodaTimeSplitter::timePartsToTimeName($output), "1920-1929");
+        self::assertEquals($output->toTimeName(), "1920-1929");
        self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 1925);

        $output = NodaTimeSplitter::attempt_splitting("Vor Dezember 2020");
-        self::assertEquals($output, [
+        self::assertNotEmpty($output);
+        self::assertEquals($output->toOldFormat(), [
            0 => "?",
            1 => "2020",
            2 => "12",
@ -165,11 +178,12 @@ final class NodaTimeSplitterTest extends TestCase {
            4 => "+",
            5 => "Vor",
        ]);
-        self::assertEquals(NodaTimeSplitter::timePartsToTimeName($output), "Vor Dezember 2020");
+        self::assertEquals($output->toTimeName(), "Vor Dezember 2020");
        self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 2020);

        $output = NodaTimeSplitter::attempt_splitting("Vor 2020");
-        self::assertEquals($output, [
+        self::assertNotEmpty($output);
+        self::assertEquals($output->toOldFormat(), [
            0 => "?",
            1 => "2019",
            2 => "00",
@ -177,11 +191,12 @@ final class NodaTimeSplitterTest extends TestCase {
            4 => "+",
            5 => "Vor",
        ]);
-        self::assertEquals(NodaTimeSplitter::timePartsToTimeName($output), "Vor 2020");
+        self::assertEquals($output->toTimeName(), "Vor 2020");
        self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 2020);

        $output = NodaTimeSplitter::attempt_splitting("Nach Januar 2020");
-        self::assertEquals($output, [
+        self::assertNotEmpty($output);
+        self::assertEquals($output->toOldFormat(), [
            0 => "2020",
            1 => "?",
            2 => "01",
@ -189,11 +204,12 @@ final class NodaTimeSplitterTest extends TestCase {
            4 => "+",
            5 => "Nach",
        ]);
-        self::assertEquals(NodaTimeSplitter::timePartsToTimeName($output), "Nach Januar 2020");
+        self::assertEquals($output->toTimeName(), "Nach Januar 2020");
        self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 2020);

        $output = NodaTimeSplitter::attempt_splitting("Januar 2020");
-        self::assertEquals($output, [
+        self::assertNotEmpty($output);
+        self::assertEquals($output->toOldFormat(), [
            0 => "2020",
            1 => "2020",
            2 => "01",
@ -201,11 +217,12 @@ final class NodaTimeSplitterTest extends TestCase {
            4 => "+",
            5 => "",
        ]);
-        self::assertEquals(NodaTimeSplitter::timePartsToTimeName($output), "Januar 2020");
+        self::assertEquals($output->toTimeName(), "Januar 2020");
        self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 2020);

        $output = NodaTimeSplitter::attempt_splitting("Januar 1217");
-        self::assertEquals($output, [
+        self::assertNotEmpty($output);
+        self::assertEquals($output->toOldFormat(), [
            0 => "1217",
            1 => "1217",
            2 => "01",
@ -214,11 +231,12 @@ final class NodaTimeSplitterTest extends TestCase {
            5 => "",
        ]);

-        self::assertEquals(NodaTimeSplitter::timePartsToTimeName($output), "Januar 1217");
+        self::assertEquals($output->toTimeName(), "Januar 1217");
        self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 1217);

        $output = NodaTimeSplitter::attempt_splitting("Januar 1520");
-        self::assertEquals($output, [
+        self::assertNotEmpty($output);
+        self::assertEquals($output->toOldFormat(), [
            0 => "1520",
            1 => "1520",
            2 => "01",
@ -227,11 +245,12 @@ final class NodaTimeSplitterTest extends TestCase {
            5 => "",
        ]);

-        self::assertEquals(NodaTimeSplitter::timePartsToTimeName($output), "Januar 1520");
+        self::assertEquals($output->toTimeName(), "Januar 1520");
        self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 1520);

        $output = NodaTimeSplitter::attempt_splitting("Januar 1001");
-        self::assertEquals($output, [
+        self::assertNotEmpty($output);
+        self::assertEquals($output->toOldFormat(), [
            0 => "1001",
            1 => "1001",
            2 => "01",
@ -240,11 +259,12 @@ final class NodaTimeSplitterTest extends TestCase {
            5 => "",
        ]);

-        self::assertEquals(NodaTimeSplitter::timePartsToTimeName($output), "Januar 1001");
+        self::assertEquals($output->toTimeName(), "Januar 1001");
        self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 1001);

        $output = NodaTimeSplitter::attempt_splitting("Januar 2780");
-        self::assertEquals($output, [
+        self::assertNotEmpty($output);
+        self::assertEquals($output->toOldFormat(), [
            0 => "2780",
            1 => "2780",
            2 => "01",
@ -253,11 +273,12 @@ final class NodaTimeSplitterTest extends TestCase {
            5 => "",
        ]);

-        self::assertEquals(NodaTimeSplitter::timePartsToTimeName($output), "Januar 2780");
+        self::assertEquals($output->toTimeName(), "Januar 2780");
        self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 2780);

        $output = NodaTimeSplitter::attempt_splitting("Nach 60er Jahre");
-        self::assertEquals($output, [
+        self::assertNotEmpty($output);
+        self::assertEquals($output->toOldFormat(), [
            0 => "1970",
            1 => "?",
            2 => "00",
@ -265,11 +286,12 @@ final class NodaTimeSplitterTest extends TestCase {
            4 => "+",
            5 => "Nach",
        ]);
-        self::assertEquals(NodaTimeSplitter::timePartsToTimeName($output), "Nach 1969");
+        self::assertEquals($output->toTimeName(), "Nach 1969");
        self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 1969);

        $output = NodaTimeSplitter::attempt_splitting("Nach 2020");
-        self::assertEquals($output, [
+        self::assertNotEmpty($output);
+        self::assertEquals($output->toOldFormat(), [
            0 => "2021",
            1 => "?",
            2 => "00",
@ -277,23 +299,25 @@ final class NodaTimeSplitterTest extends TestCase {
            4 => "+",
            5 => "Nach",
        ]);
-        self::assertEquals(NodaTimeSplitter::timePartsToTimeName($output), "Nach 2020");
+        self::assertEquals($output->toTimeName(), "Nach 2020");
        self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 2020);

        $output = NodaTimeSplitter::attempt_splitting("Bis Januar 2020");
-        self::assertEquals($output, [
+        self::assertNotEmpty($output);
+        self::assertEquals($output->toOldFormat(), [
            0 => "?",
            1 => "2020",
            2 => "01",
            3 => "00",
            4 => "+",
-            5 => "",
+            5 => "Bis",
        ]);
-        self::assertEquals(NodaTimeSplitter::timePartsToTimeName($output), "Bis Januar 2020");
+        self::assertEquals($output->toTimeName(), "Bis Januar 2020");
        self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 2020);

        $output = NodaTimeSplitter::attempt_splitting("Januar 2020");
-        self::assertEquals($output, [
+        self::assertNotEmpty($output);
+        self::assertEquals($output->toOldFormat(), [
            0 => "2020",
            1 => "2020",
            2 => "01",
@ -301,12 +325,13 @@ final class NodaTimeSplitterTest extends TestCase {
            4 => "+",
            5 => "",
        ]);
-        self::assertEquals(NodaTimeSplitter::timePartsToTimeName($output), "Januar 2020");
+        self::assertEquals($output->toTimeName(), "Januar 2020");
        self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 2020);

        // Intl' month: 2020-01
        $output = NodaTimeSplitter::attempt_splitting("2020-01");
-        self::assertEquals($output, [
+        self::assertNotEmpty($output);
+        self::assertEquals($output->toOldFormat(), [
            0 => "2020",
            1 => "2020",
            2 => "01",
@ -314,11 +339,12 @@ final class NodaTimeSplitterTest extends TestCase {
            4 => "+",
            5 => "",
        ]);
-        self::assertEquals(NodaTimeSplitter::timePartsToTimeName($output), "Januar 2020");
+        self::assertEquals($output->toTimeName(), "Januar 2020");
        self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 2020);

        $output = NodaTimeSplitter::attempt_splitting("Januar 2020 v. Chr.");
-        self::assertEquals($output, [
+        self::assertNotEmpty($output);
+        self::assertEquals($output->toOldFormat(), [
            0 => "-2020",
            1 => "-2020",
            2 => "01",
@ -326,12 +352,13 @@ final class NodaTimeSplitterTest extends TestCase {
            4 => "-",
            5 => "",
        ]);
-        self::assertEquals(NodaTimeSplitter::timePartsToTimeName($output), "Januar 2020 v. Chr.");
+        self::assertEquals($output->toTimeName(), "Januar 2020 v. Chr.");
        self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 2020);

        // 5-Digit timespans BCE
        $output = NodaTimeSplitter::attempt_splitting("40000-25000 vor Christus");
-        self::assertEquals($output, [
+        self::assertNotEmpty($output);
+        self::assertEquals($output->toOldFormat(), [
            0 => "-40000",
            1 => "-25000",
            2 => "00",
@ -339,12 +366,13 @@ final class NodaTimeSplitterTest extends TestCase {
            4 => "-",
            5 => "",
        ]);
-        self::assertEquals(NodaTimeSplitter::timePartsToTimeName($output), "40000-25000 v. Chr.");
+        self::assertEquals($output->toTimeName(), "40000-25000 v. Chr.");
        self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 32500);

        // 5-Digit timespans BCE
        $output = NodaTimeSplitter::attempt_splitting("40000-25000 v.C.");
-        self::assertEquals($output, [
+        self::assertNotEmpty($output);
+        self::assertEquals($output->toOldFormat(), [
            0 => "-40000",
            1 => "-25000",
            2 => "00",
@ -352,11 +380,12 @@ final class NodaTimeSplitterTest extends TestCase {
            4 => "-",
            5 => "",
        ]);
-        self::assertEquals(NodaTimeSplitter::timePartsToTimeName($output), "40000-25000 v. Chr.");
+        self::assertEquals($output->toTimeName(), "40000-25000 v. Chr.");
        self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 32500);

        $output = NodaTimeSplitter::attempt_splitting("20. Jahrhundert v. Chr.");
-        self::assertEquals($output, [
+        self::assertNotEmpty($output);
+        self::assertEquals($output->toOldFormat(), [
            0 => "-2000",
            1 => "-1901",
            2 => "00",
@ -364,11 +393,12 @@ final class NodaTimeSplitterTest extends TestCase {
            4 => "-",
            5 => "",
        ]);
-        self::assertEquals(NodaTimeSplitter::timePartsToTimeName($output), "2000-1901 v. Chr.");
+        self::assertEquals($output->toTimeName(), "2000-1901 v. Chr.");
        self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 1950);

        $output = NodaTimeSplitter::attempt_splitting("20. Jh.");
-        self::assertEquals($output, [
+        self::assertNotEmpty($output);
+        self::assertEquals($output->toOldFormat(), [
            0 => "1901",
            1 => "2000",
            2 => "00",
@ -376,11 +406,12 @@ final class NodaTimeSplitterTest extends TestCase {
            4 => "+",
            5 => "",
        ]);
-        self::assertEquals(NodaTimeSplitter::timePartsToTimeName($output), "1901-2000");
+        self::assertEquals($output->toTimeName(), "1901-2000");
        self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 1951);

        $output = NodaTimeSplitter::attempt_splitting("20. Jhd.");
-        self::assertEquals($output, [
+        self::assertNotEmpty($output);
+        self::assertEquals($output->toOldFormat(), [
            0 => "1901",
            1 => "2000",
            2 => "00",
@ -388,11 +419,12 @@ final class NodaTimeSplitterTest extends TestCase {
            4 => "+",
            5 => "",
        ]);
-        self::assertEquals(NodaTimeSplitter::timePartsToTimeName($output), "1901-2000");
+        self::assertEquals($output->toTimeName(), "1901-2000");
        self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 1951);

        $output = NodaTimeSplitter::attempt_splitting("20. Jhdt.");
-        self::assertEquals($output, [
+        self::assertNotEmpty($output);
+        self::assertEquals($output->toOldFormat(), [
            0 => "1901",
            1 => "2000",
            2 => "00",
@ -400,11 +432,12 @@ final class NodaTimeSplitterTest extends TestCase {
            4 => "+",
            5 => "",
        ]);
-        self::assertEquals(NodaTimeSplitter::timePartsToTimeName($output), "1901-2000");
+        self::assertEquals($output->toTimeName(), "1901-2000");
        self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 1951);

        $output = NodaTimeSplitter::attempt_splitting("20. Jahrhundert");
-        self::assertEquals($output, [
+        self::assertNotEmpty($output);
+        self::assertEquals($output->toOldFormat(), [
            0 => "1901",
            1 => "2000",
            2 => "00",
@ -412,11 +445,12 @@ final class NodaTimeSplitterTest extends TestCase {
            4 => "+",
            5 => "",
        ]);
-        self::assertEquals(NodaTimeSplitter::timePartsToTimeName($output), "1901-2000");
+        self::assertEquals($output->toTimeName(), "1901-2000");
        self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 1951);

        $output = NodaTimeSplitter::attempt_splitting("20.-19. Jahrhundert v. Chr.");
-        self::assertEquals($output, [
+        self::assertNotEmpty($output);
+        self::assertEquals($output->toOldFormat(), [
            0 => "-2000",
            1 => "-1801",
            2 => "00",
@ -424,23 +458,25 @@ final class NodaTimeSplitterTest extends TestCase {
            4 => "-",
            5 => "",
        ]);
-        self::assertEquals(NodaTimeSplitter::timePartsToTimeName($output), "2000-1801 v. Chr.");
+        self::assertEquals($output->toTimeName(), "2000-1801 v. Chr.");
        self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 1900);

        $output = NodaTimeSplitter::attempt_splitting("Bis 20.-19. Jahrhundert v. Chr.");
-        self::assertEquals($output, [
+        self::assertNotEmpty($output);
+        self::assertEquals($output->toOldFormat(), [
            0 => "?",
            1 => "-1801",
            2 => "00",
            3 => "00",
            4 => "-",
-            5 => "",
+            5 => "Bis",
        ]);
-        self::assertEquals(NodaTimeSplitter::timePartsToTimeName($output), "Bis 1801 v. Chr.");
+        self::assertEquals($output->toTimeName(), "Bis 1801 v. Chr.");
        self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 1801);

        $output = NodaTimeSplitter::attempt_splitting("6 November 1978");
-        self::assertEquals($output, [
+        self::assertNotEmpty($output);
+        self::assertEquals($output->toOldFormat(), [
            0 => "1978",
            1 => "1978",
            2 => "11",
@ -448,7 +484,7 @@ final class NodaTimeSplitterTest extends TestCase {
            4 => "+",
            5 => "",
        ]);
-        self::assertEquals(NodaTimeSplitter::timePartsToTimeName($output), "06.11.1978");
+        self::assertEquals($output->toTimeName(), "06.11.1978");
        self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 1978);

    }
@ -465,7 +501,8 @@ final class NodaTimeSplitterTest extends TestCase {
    public function testSplitSimpleDatesEnglish():void {

        $output = NodaTimeSplitter::attempt_splitting("1925 BCE");
-        self::assertEquals($output, [
+        self::assertNotEmpty($output);
+        self::assertEquals($output->toOldFormat(), [
            0 => "-1925",
            1 => "-1925",
            2 => "00",
@ -473,11 +510,12 @@ final class NodaTimeSplitterTest extends TestCase {
            4 => "-",
            5 => "",
        ]);
-        self::assertEquals(NodaTimeSplitter::timePartsToTimeName($output), "1925 v. Chr.");
+        self::assertEquals($output->toTimeName(), "1925 v. Chr.");
        self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 1925);

        $output = NodaTimeSplitter::attempt_splitting("1925 CE");
-        self::assertEquals($output, [
+        self::assertNotEmpty($output);
+        self::assertEquals($output->toOldFormat(), [
            0 => "1925",
            1 => "1925",
            2 => "00",
@ -485,7 +523,7 @@ final class NodaTimeSplitterTest extends TestCase {
            4 => "+",
            5 => "",
        ]);
-        self::assertEquals(NodaTimeSplitter::timePartsToTimeName($output), "1925");
+        self::assertEquals($output->toTimeName(), "1925");
        self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 1925);

    }
@ -502,7 +540,8 @@ final class NodaTimeSplitterTest extends TestCase {
    public function testSplitSimpleDatesHungarian():void {

        $output = NodaTimeSplitter::attempt_splitting("2020.01.02.");
-        self::assertEquals($output, [
+        self::assertNotEmpty($output);
+        self::assertEquals($output->toOldFormat(), [
            0 => "2020",
            1 => "2020",
            2 => "01",
@ -510,11 +549,12 @@ final class NodaTimeSplitterTest extends TestCase {
            4 => "+",
            5 => "",
        ]);
-        self::assertEquals(NodaTimeSplitter::timePartsToTimeName($output), "02.01.2020");
+        self::assertEquals($output->toTimeName(), "02.01.2020");
        self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 2020);

        $output = NodaTimeSplitter::attempt_splitting("2020. januar. 2.");
-        self::assertEquals($output, [
+        self::assertNotEmpty($output);
+        self::assertEquals($output->toOldFormat(), [
            0 => "2020",
            1 => "2020",
            2 => "01",
@ -522,11 +562,12 @@ final class NodaTimeSplitterTest extends TestCase {
            4 => "+",
            5 => "",
        ]);
-        self::assertEquals(NodaTimeSplitter::timePartsToTimeName($output), "02.01.2020");
+        self::assertEquals($output->toTimeName(), "02.01.2020");
        self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 2020);

        $output = NodaTimeSplitter::attempt_splitting("2020.01.2.");
-        self::assertEquals($output, [
+        self::assertNotEmpty($output);
+        self::assertEquals($output->toOldFormat(), [
            0 => "2020",
            1 => "2020",
            2 => "01",
@ -534,11 +575,12 @@ final class NodaTimeSplitterTest extends TestCase {
            4 => "+",
            5 => "",
        ]);
-        self::assertEquals(NodaTimeSplitter::timePartsToTimeName($output), "02.01.2020");
+        self::assertEquals($output->toTimeName(), "02.01.2020");
        self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 2020);

        $output = NodaTimeSplitter::attempt_splitting("2020.1.2.");
-        self::assertEquals($output, [
+        self::assertNotEmpty($output);
+        self::assertEquals($output->toOldFormat(), [
            0 => "2020",
            1 => "2020",
            2 => "01",
@ -546,11 +588,12 @@ final class NodaTimeSplitterTest extends TestCase {
            4 => "+",
            5 => "",
        ]);
-        self::assertEquals(NodaTimeSplitter::timePartsToTimeName($output), "02.01.2020");
+        self::assertEquals($output->toTimeName(), "02.01.2020");
        self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 2020);

        $output = NodaTimeSplitter::attempt_splitting("2020. Januar 2.");
-        self::assertEquals($output, [
+        self::assertNotEmpty($output);
+        self::assertEquals($output->toOldFormat(), [
            0 => "2020",
            1 => "2020",
            2 => "01",
@ -558,11 +601,12 @@ final class NodaTimeSplitterTest extends TestCase {
            4 => "+",
            5 => "",
        ]);
-        self::assertEquals(NodaTimeSplitter::timePartsToTimeName($output), "02.01.2020");
+        self::assertEquals($output->toTimeName(), "02.01.2020");
        self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 2020);

        $output = NodaTimeSplitter::attempt_splitting("2020-01-02");
-        self::assertEquals($output, [
+        self::assertNotEmpty($output);
+        self::assertEquals($output->toOldFormat(), [
            0 => "2020",
            1 => "2020",
            2 => "01",
@ -570,11 +614,12 @@ final class NodaTimeSplitterTest extends TestCase {
            4 => "+",
            5 => "",
        ]);
-        self::assertEquals(NodaTimeSplitter::timePartsToTimeName($output), "02.01.2020");
+        self::assertEquals($output->toTimeName(), "02.01.2020");
        self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 2020);

        $output = NodaTimeSplitter::attempt_splitting("1920-tól 1929-ig");
-        self::assertEquals($output, [
+        self::assertNotEmpty($output);
+        self::assertEquals($output->toOldFormat(), [
            0 => "1920",
            1 => "1929",
            2 => "00",
@ -582,11 +627,12 @@ final class NodaTimeSplitterTest extends TestCase {
            4 => "+",
            5 => "",
        ]);
-        self::assertEquals(NodaTimeSplitter::timePartsToTimeName($output), "1920-1929");
+        self::assertEquals($output->toTimeName(), "1920-1929");
        self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 1925);

        $output = NodaTimeSplitter::attempt_splitting("1920-1929 között");
-        self::assertEquals($output, [
+        self::assertNotEmpty($output);
+        self::assertEquals($output->toOldFormat(), [
            0 => "1920",
            1 => "1929",
            2 => "00",
@ -594,11 +640,12 @@ final class NodaTimeSplitterTest extends TestCase {
            4 => "+",
            5 => "",
        ]);
-        self::assertEquals(NodaTimeSplitter::timePartsToTimeName($output), "1920-1929");
+        self::assertEquals($output->toTimeName(), "1920-1929");
        self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 1925);

        $output = NodaTimeSplitter::attempt_splitting("1920-től 1929-ig");
-        self::assertEquals($output, [
+        self::assertNotEmpty($output);
+        self::assertEquals($output->toOldFormat(), [
            0 => "1920",
            1 => "1929",
            2 => "00",
@ -606,24 +653,26 @@ final class NodaTimeSplitterTest extends TestCase {
            4 => "+",
            5 => "",
        ]);
-        self::assertEquals(NodaTimeSplitter::timePartsToTimeName($output), "1920-1929");
+        self::assertEquals($output->toTimeName(), "1920-1929");
        self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 1925);

        // From 1920 onwards
        $output = NodaTimeSplitter::attempt_splitting("1920 utántól");
-        self::assertEquals($output, [
+        self::assertNotEmpty($output);
+        self::assertEquals($output->toOldFormat(), [
            0 => "1920",
            1 => "?",
            2 => "00",
            3 => "00",
            4 => "+",
-            5 => "",
+            5 => "Seit",
        ]);
-        self::assertEquals(NodaTimeSplitter::timePartsToTimeName($output), "Seit 1920");
+        self::assertEquals($output->toTimeName(), "Seit 1920");
        self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 1920);

        $output = NodaTimeSplitter::attempt_splitting("1920-es évek");
-        self::assertEquals($output, [
+        self::assertNotEmpty($output);
+        self::assertEquals($output->toOldFormat(), [
            0 => "1920",
            1 => "1929",
            2 => "00",
@ -631,22 +680,24 @@ final class NodaTimeSplitterTest extends TestCase {
            4 => "+",
            5 => "",
        ]);
-        self::assertEquals(NodaTimeSplitter::timePartsToTimeName($output), "1920-1929");
+        self::assertEquals($output->toTimeName(), "1920-1929");
        self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 1925);

        $output = NodaTimeSplitter::attempt_splitting("1920-es évekig");
-        self::assertEquals($output, [
+        self::assertNotEmpty($output);
+        self::assertEquals($output->toOldFormat(), [
            0 => "?",
            1 => "1929",
            2 => "00",
            3 => "00",
            4 => "+",
-            5 => "",
+            5 => "Bis",
        ]);
-        self::assertEquals(NodaTimeSplitter::timePartsToTimeName($output), "Bis 1929");
+        self::assertEquals($output->toTimeName(), "Bis 1929");
        self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 1929);

        $output = NodaTimeSplitter::attempt_splitting("2020. Januar");
+        self::assertNotEmpty($output);
        self::assertEquals([
            0 => "2020",
            1 => "2020",
@ -654,12 +705,13 @@ final class NodaTimeSplitterTest extends TestCase {
            3 => "00",
            4 => "+",
            5 => "",
-        ], $output);
-        self::assertEquals(NodaTimeSplitter::timePartsToTimeName($output), "Januar 2020");
+        ], $output->toOldFormat());
+        self::assertEquals($output->toTimeName(), "Januar 2020");
        self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 2020);

        $output = NodaTimeSplitter::attempt_splitting("Kr. e. 2020. Januar");
-        self::assertEquals($output, [
+        self::assertNotEmpty($output);
+        self::assertEquals($output->toOldFormat(), [
            0 => "-2020",
            1 => "-2020",
            2 => "01",
@ -667,11 +719,12 @@ final class NodaTimeSplitterTest extends TestCase {
            4 => "-",
            5 => "",
        ]);
-        self::assertEquals(NodaTimeSplitter::timePartsToTimeName($output), "Januar 2020 v. Chr.");
+        self::assertEquals($output->toTimeName(), "Januar 2020 v. Chr.");
        self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 2020);

        $output = NodaTimeSplitter::attempt_splitting("20. sz");
-        self::assertEquals($output, [
+        self::assertNotEmpty($output);
+        self::assertEquals($output->toOldFormat(), [
            0 => "1901",
            1 => "2000",
            2 => "00",
@ -679,11 +732,12 @@ final class NodaTimeSplitterTest extends TestCase {
            4 => "+",
            5 => "",
        ]);
-        self::assertEquals(NodaTimeSplitter::timePartsToTimeName($output), "1901-2000");
+        self::assertEquals($output->toTimeName(), "1901-2000");
        self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 1951);

        $output = NodaTimeSplitter::attempt_splitting("III. század");
-        self::assertEquals($output, [
+        self::assertNotEmpty($output);
+        self::assertEquals($output->toOldFormat(), [
            0 => "201",
            1 => "300",
            2 => "00",
@ -691,11 +745,12 @@ final class NodaTimeSplitterTest extends TestCase {
            4 => "+",
            5 => "",
        ]);
-        self::assertEquals(NodaTimeSplitter::timePartsToTimeName($output), "201-300 n. Chr.");
+        self::assertEquals($output->toTimeName(), "201-300 n. Chr.");
        self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 251);

        $output = NodaTimeSplitter::attempt_splitting("20th century");
-        self::assertEquals($output, [
+        self::assertNotEmpty($output);
+        self::assertEquals($output->toOldFormat(), [
            0 => "1901",
            1 => "2000",
            2 => "00",
@ -703,11 +758,12 @@ final class NodaTimeSplitterTest extends TestCase {
            4 => "+",
            5 => "",
        ]);
-        self::assertEquals(NodaTimeSplitter::timePartsToTimeName($output), "1901-2000");
+        self::assertEquals($output->toTimeName(), "1901-2000");
        self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 1951);

        $output = NodaTimeSplitter::attempt_splitting("20. század");
-        self::assertEquals($output, [
+        self::assertNotEmpty($output);
+        self::assertEquals($output->toOldFormat(), [
            0 => "1901",
            1 => "2000",
            2 => "00",
@ -715,11 +771,12 @@ final class NodaTimeSplitterTest extends TestCase {
            4 => "+",
            5 => "",
        ]);
-        self::assertEquals(NodaTimeSplitter::timePartsToTimeName($output), "1901-2000");
+        self::assertEquals($output->toTimeName(), "1901-2000");
        self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 1951);

        $output = NodaTimeSplitter::attempt_splitting("20.század");
-        self::assertEquals($output, [
+        self::assertNotEmpty($output);
+        self::assertEquals($output->toOldFormat(), [
            0 => "1901",
            1 => "2000",
            2 => "00",
@ -727,11 +784,12 @@ final class NodaTimeSplitterTest extends TestCase {
            4 => "+",
            5 => "",
        ]);
-        self::assertEquals(NodaTimeSplitter::timePartsToTimeName($output), "1901-2000");
+        self::assertEquals($output->toTimeName(), "1901-2000");
        self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 1951);

        $output = NodaTimeSplitter::attempt_splitting("Kr. e. 20. század");
-        self::assertEquals($output, [
+        self::assertNotEmpty($output);
+        self::assertEquals($output->toOldFormat(), [
            0 => "-2000",
            1 => "-1901",
            2 => "00",
@ -739,11 +797,12 @@ final class NodaTimeSplitterTest extends TestCase {
            4 => "-",
            5 => "",
        ]);
-        self::assertEquals(NodaTimeSplitter::timePartsToTimeName($output), "2000-1901 v. Chr.");
+        self::assertEquals($output->toTimeName(), "2000-1901 v. Chr.");
        self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 1950);

        $output = NodaTimeSplitter::attempt_splitting("Kr. e. 20.-19. század");
-        self::assertEquals($output, [
+        self::assertNotEmpty($output);
+        self::assertEquals($output->toOldFormat(), [
            0 => "-2000",
            1 => "-1801",
            2 => "00",
@ -751,25 +810,27 @@ final class NodaTimeSplitterTest extends TestCase {
            4 => "-",
            5 => "",
        ]);
-        self::assertEquals(NodaTimeSplitter::timePartsToTimeName($output), "2000-1801 v. Chr.");
+        self::assertEquals($output->toTimeName(), "2000-1801 v. Chr.");
        self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 1900);

        $output = NodaTimeSplitter::attempt_splitting("Kr. e. 20.-19. század-ig");
-        self::assertEquals($output, [
+        self::assertNotEmpty($output);
+        self::assertEquals($output->toOldFormat(), [
            0 => "?",
            1 => "-1801",
            2 => "00",
            3 => "00",
            4 => "-",
-            5 => "",
+            5 => "Bis",
        ]);
-        self::assertEquals(NodaTimeSplitter::timePartsToTimeName($output), "Bis 1801 v. Chr.");
+        self::assertEquals($output->toTimeName(), "Bis 1801 v. Chr.");
        self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 1801);

        /*
         * TODO
        $output = NodaTimeSplitter::attempt_splitting("1900 előtt");
-        self::assertEquals($output, [
+        self::assertNotEmpty($output);
+        self::assertEquals($output->toOldFormat(), [
            0 => "?",
            1 => "1899",
            2 => "00",
@ -777,36 +838,39 @@ final class NodaTimeSplitterTest extends TestCase {
            4 => "+",
            5 => "",
        ]);
-        self::assertEquals(NodaTimeSplitter::timePartsToTimeName($output), "Vor 1900");
+        self::assertEquals($output->toTimeName(), "Vor 1900");
        self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 1899);
         */

        $output = NodaTimeSplitter::attempt_splitting("1900-ig");
-        self::assertEquals($output, [
+        self::assertNotEmpty($output);
+        self::assertEquals($output->toOldFormat(), [
            0 => "?",
            1 => "1900",
            2 => "00",
            3 => "00",
            4 => "+",
-            5 => "",
+            5 => "Bis",
        ]);
-        self::assertEquals(NodaTimeSplitter::timePartsToTimeName($output), "Bis 1900");
+        self::assertEquals($output->toTimeName(), "Bis 1900");
        self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 1900);

        $output = NodaTimeSplitter::attempt_splitting("1900ig");
-        self::assertEquals($output, [
+        self::assertNotEmpty($output);
+        self::assertEquals($output->toOldFormat(), [
            0 => "?",
            1 => "1900",
            2 => "00",
            3 => "00",
            4 => "+",
-            5 => "",
+            5 => "Bis",
        ]);
-        self::assertEquals(NodaTimeSplitter::timePartsToTimeName($output), "Bis 1900");
+        self::assertEquals($output->toTimeName(), "Bis 1900");
        self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 1900);

        $output = NodaTimeSplitter::attempt_splitting("2020. december előtt");
-        self::assertEquals($output, [
+        self::assertNotEmpty($output);
+        self::assertEquals($output->toOldFormat(), [
            0 => "?",
            1 => "2020",
            2 => "12",
@ -814,7 +878,7 @@ final class NodaTimeSplitterTest extends TestCase {
            4 => "+",
            5 => "Vor",
        ]);
-        self::assertEquals(NodaTimeSplitter::timePartsToTimeName($output), "Vor Dezember 2020");
+        self::assertEquals($output->toTimeName(), "Vor Dezember 2020");
        self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 2020);

    }
@ -831,7 +895,8 @@ final class NodaTimeSplitterTest extends TestCase {
    public function testSplitSimpleDatesUkrainian():void {

        $output = NodaTimeSplitter::attempt_splitting("2020 p");
-        self::assertEquals($output, [
+        self::assertNotEmpty($output);
+        self::assertEquals($output->toOldFormat(), [
            0 => "2020",
            1 => "2020",
            2 => "00",
@ -839,7 +904,7 @@ final class NodaTimeSplitterTest extends TestCase {
            4 => "+",
            5 => "",
        ]);
-        self::assertEquals(NodaTimeSplitter::timePartsToTimeName($output), "2020");
+        self::assertEquals($output->toTimeName(), "2020");
        self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 2020);

    }
@ -864,8 +929,8 @@ final class NodaTimeSplitterTest extends TestCase {
            "start_year" => '2004',
            "end_year" => '2004',
            "counting_time_year" => "2004",
-            "counting_time_month" => "01",
-            "counting_time_day" => "16",
+            "counting_time_month" => "02",
+            "counting_time_day" => "01",
            "counting_time_bcce" => "+",
        ]);

@ -878,8 +943,8 @@ final class NodaTimeSplitterTest extends TestCase {
            "start_year" => '2004',
            "end_year" => '2004',
            "counting_time_year" => "2004",
-            "counting_time_month" => "01",
-            "counting_time_day" => "16",
+            "counting_time_month" => "02",
+            "counting_time_day" => "01",
            "counting_time_bcce" => "+",
        ]);

@ -925,8 +990,8 @@ final class NodaTimeSplitterTest extends TestCase {
            'end_name' => "1900",
            "start_year" => '1601',
            "end_year" => '1900',
-            "counting_time_year" => "1750",
-            "counting_time_month" => "06",
+            "counting_time_year" => "1751",
+            "counting_time_month" => "01",
            "counting_time_day" => "01",
            "counting_time_bcce" => "+",
        ]);
@ -939,8 +1004,8 @@ final class NodaTimeSplitterTest extends TestCase {
            'end_name' => "1969",
            "start_year" => '1950',
            "end_year" => '1969',
-            "counting_time_year" => "1959",
-            "counting_time_month" => "06",
+            "counting_time_year" => "1960",
+            "counting_time_month" => "01",
            "counting_time_day" => "01",
            "counting_time_bcce" => "+",
        ]);