museum-digital/MDNodaHelpers
33
0
Fork 0
Code Issues 6 Pull Requests Releases Wiki Activity
MDNodaHelpers/tests/NodaTimeSplitterTest.php

1315 lines
46 KiB
PHP
Raw Normal View History

Add tests for splitting Hungarian dates
2020-09-26 14:15:15 +02:00
<?PHP
/**
Add class NodaValidationHelper, for now for validating actor descriptions
2022-05-17 23:27:40 +02:00
* This script contains tests for the time name splitter.
Add tests for splitting Hungarian dates
2020-09-26 14:15:15 +02:00
*
* @author Joshua Ramon Enslin <joshua@museum-digital.de>
*/
declare(strict_types = 1);
Fix edge case 200 b.c. in NodaSplitTime
2024-07-08 01:27:03 +02:00
Add tests for splitting Hungarian dates
2020-09-26 14:15:15 +02:00
use PHPUnit\Framework\TestCase;
Fix edge case 200 b.c. in NodaSplitTime
2024-07-08 01:27:03 +02:00
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Small;
Begin restructuring NodaTimeSplitterTest to use data providers
2025-02-21 10:31:21 +01:00
use PHPUnit\Framework\Attributes\DataProvider;
Add tests for splitting Hungarian dates
2020-09-26 14:15:15 +02:00
/**
Add class NodaValidationHelper, for now for validating actor descriptions
2022-05-17 23:27:40 +02:00
* This script contains tests for the time name splitter.
Add tests for splitting Hungarian dates
2020-09-26 14:15:15 +02:00
*/
Fix edge case 200 b.c. in NodaSplitTime
2024-07-08 01:27:03 +02:00
#[small]
#[CoversClass(\NodaTimeSplitter::class)]
Add tests for splitting Hungarian dates
2020-09-26 14:15:15 +02:00
final class NodaTimeSplitterTest extends TestCase {
Continue refactoring tests for time splitter to run provider-based
2025-02-24 14:02:42 +01:00
/**
* Data provider for German time names.
*
* @return array<string, array{0: string, 1: NodaSplitTime, 2: string}>
*/
public static function splittableGermanTimeNamesProvider():array {
return [
"1920er Jahre" => [
"1920er Jahre",
new NodaSplitTime('1920', '1929',
start_date: '1920-01-01',
end_date: '1929-12-31'),
"1920-1929",
],
"20er" => [
"20er",
new NodaSplitTime('1920', '1929',
start_date: '1920-01-01',
end_date: '1929-12-31'),
"1920-1929",
],
"2. Januar 2020" => [
"2. Januar 2020",
new NodaSplitTime('2020', '2020',
counting_time_month: '01',
counting_time_day: '02',
start_date: '2020-01-02',
end_date: '2020-01-02'),
"02.01.2020",
],
"02.01.2020" => [
"02.01.2020",
new NodaSplitTime('2020', '2020',
counting_time_month: '01',
counting_time_day: '02',
start_date: '2020-01-02',
end_date: '2020-01-02'),
"02.01.2020",
],
"2.1.2020" => [
"2.1.2020",
new NodaSplitTime('2020', '2020',
counting_time_month: '01',
counting_time_day: '02',
start_date: '2020-01-02',
end_date: '2020-01-02'),
"02.01.2020",
],
"?.1.2020" => [
"?.1.2020",
new NodaSplitTime('2020', '2020',
counting_time_month: '01',
start_date: '2020-01-01',
end_date: '2020-01-31'),
"Januar 2020",
],
"? 2020" => [
"? 2020",
new NodaSplitTime('2020', '2020',
start_date: '2020-01-01',
end_date: '2020-12-31'),
"2020",
],
"?.?.2020" => [
"?.?.2020",
new NodaSplitTime('2020', '2020',
start_date: '2020-01-01',
end_date: '2020-12-31'),
"2020",
],
"?.10.2020" => [
"?.10.2020",
new NodaSplitTime('2020', '2020',
counting_time_month: '10',
start_date: '2020-10-01',
end_date: '2020-10-31'),
"Oktober 2020",
],
"20. Jh." => [
"20. Jh.",
new NodaSplitTime('1901', '2000',
start_date: '1901-01-01',
end_date: '2000-12-31'),
"1901-2000",
],
"20. Jhd." => [
"20. Jhd.",
new NodaSplitTime('1901', '2000',
start_date: '1901-01-01',
end_date: '2000-12-31'),
"1901-2000",
],
"20. Jhdt." => [
"20. Jhdt.",
new NodaSplitTime('1901', '2000',
start_date: '1901-01-01',
end_date: '2000-12-31'),
"1901-2000",
],
"20. Jahrhundert" => [
"20. Jahrhundert",
new NodaSplitTime('1901', '2000',
start_date: '1901-01-01',
end_date: '2000-12-31'),
"1901-2000",
],
"1945-48" => [
"1945-48",
new NodaSplitTime('1945', '1948',
start_date: '1945-01-01',
end_date: '1948-12-31'),
"1945-1948",
],
"1945 und 1946" => [
"1945 und 1946",
new NodaSplitTime('1945', '1946',
start_date: '1945-01-01',
end_date: '1946-12-31'),
"1945-1946",
],
"1945 oder 1946" => [
"1945 oder 1946",
new NodaSplitTime('1945', '1946',
start_date: '1945-01-01',
end_date: '1946-12-31'),
"1945-1946",
],
Extend tests
2025-03-10 03:20:46 +01:00
"1945 bis 2046" => [
"1945 bis 2046",
new NodaSplitTime('1945', '2046',
start_date: '1945-01-01',
end_date: '2046-12-31'),
"1945-2046",
],
"1945–2046" => [
"1945 bis 2046",
new NodaSplitTime('1945', '2046',
start_date: '1945-01-01',
end_date: '2046-12-31'),
"1945-2046",
],
"1930–2017" => [
"1930-2017",
new NodaSplitTime('1930', '2017',
start_date: '1930-01-01',
end_date: '2017-12-31'),
"1930-2017",
],
Continue refactoring tests for time splitter to run provider-based
2025-02-24 14:02:42 +01:00
];
}
/**
* Data provider for English time names.
*
* @return array<string, array{0: string, 1: NodaSplitTime, 2: string}>
*/
public static function splittableEnglishTimeNamesProvider():array {
return [
"1925 BCE" => [
"1925 BCE",
new NodaSplitTime('-1925', '-1925',
counting_time_indicator: NodaCountingTimeIndicator::bce,
start_date: '-1925-12-31',
end_date: '-1925-01-01'),
"1925 v. Chr.",
],
"1925 CE" => [
"1925",
new NodaSplitTime('1925', '1925'),
"1925",
],
];
}
/**
* Data provider for Hungarian time names.
*
* @return array<string, array{0: string, 1: NodaSplitTime, 2: string}>
*/
public static function splittableHungarianTimeNamesProvider():array {
return [
'1920-es evek: 1920s' => [
"1920-es évek",
new NodaSplitTime('1920', '1929',
start_date: '1920-01-01',
end_date: '1929-12-31'),
"1920-1929",
],
'1920 es evekig: Until the 1920s' => [
"1920 es évekig",
new NodaSplitTime('?', '1929',
before_after_indicator: NodaTimeBeforeAfterIndicator::until,
end_date: '1929-12-31'),
"Bis 1929",
],
'1920-es evekig: Until the 1920s' => [
"1920-es évekig",
new NodaSplitTime('?', '1929',
before_after_indicator: NodaTimeBeforeAfterIndicator::until,
end_date: '1929-12-31'),
"Bis 1929",
],
'year + month' => [
"2020. Januar",
new NodaSplitTime('2020', '2020',
counting_time_month: '01',
start_date: '2020-01-01',
end_date: '2020-01-31'),
"Januar 2020",
],
'Kr. e. (BC) + year + month' => [
"Kr. e. 2020. Januar",
new NodaSplitTime('-2020', '-2020',
counting_time_month: '01',
counting_time_indicator: NodaCountingTimeIndicator::bce,
start_date: '-2020-01-31',
end_date: '-2020-01-01'),
"Januar 2020 v. Chr.",
],
'[0-9]{2}. sz' => [
"20. sz",
new NodaSplitTime('1901', '2000',
start_date: '1901-01-01',
end_date: '2000-12-31'),
"1901-2000",
],
'[0-9]{2}. század' => [
"20. század",
new NodaSplitTime('1901', '2000',
start_date: '1901-01-01',
end_date: '2000-12-31'),
"1901-2000",
],
'[0-9]{2}.század' => [
"20.század",
new NodaSplitTime('1901', '2000',
start_date: '1901-01-01',
end_date: '2000-12-31'),
"1901-2000",
],
'Kr. e. (BC) + század' => [
"Kr. e. 20. század",
new NodaSplitTime('-2000', '-1901',
counting_time_indicator: NodaCountingTimeIndicator::bce,
start_date: '-2000-12-31',
end_date: '-1901-01-01'),
"2000-1901 v. Chr.",
],
'Kr. e. (BC) + 20-19' => [
"Kr. e. 20.-19. század",
new NodaSplitTime('-2000', '-1801',
counting_time_indicator: NodaCountingTimeIndicator::bce,
start_date: '-1801-12-31',
end_date: '-2000-01-01'),
"2000-1801 v. Chr.",
],
'Kr. e. (BC) + 20-19 + ig (until)' => [
"Kr. e. 20.-19. század-ig",
new NodaSplitTime('?', '-1801',
counting_time_indicator: NodaCountingTimeIndicator::bce,
before_after_indicator: NodaTimeBeforeAfterIndicator::until,
start_date: '-9999-12-31',
end_date: '-2000-01-01'),
"Bis 1801 v. Chr.",
],
'year + suffix: -ig (until)' => [
'1900ig',
new NodaSplitTime('?', '1900',
before_after_indicator: NodaTimeBeforeAfterIndicator::until,
start_date: '-9999-12-31',
end_date: '1900-12-31'),
"Bis 1900",
],
'year + suffix: ig (until)' => [
'1900ig',
new NodaSplitTime('?', '1900',
before_after_indicator: NodaTimeBeforeAfterIndicator::until,
start_date: '-9999-12-31',
end_date: '1900-12-31'),
"Bis 1900",
],
'year előtt (before)' => [
'2020. előtt',
new NodaSplitTime('?', '2019',
before_after_indicator: NodaTimeBeforeAfterIndicator::before,
start_date: '-9999-12-31',
end_date: '2020-01-01'),
'Vor 2020',
],
'year, month + előtt (before)' => [
'2020. december előtt',
new NodaSplitTime('?', '2020',
counting_time_month: '12',
before_after_indicator: NodaTimeBeforeAfterIndicator::before,
start_date: '-9999-12-31',
end_date: '2020-12-01'),
'Vor Dezember 2020',
],
];
}
/**
* Data provider for Ukrainian time names.
*
* @return array<string, array{0: string, 1: NodaSplitTime}>
*/
public static function splittableUkrainianTimeNamesProvider():array {
return [
'Year + p' => [
'2020 p',
new NodaSplitTime('2020', '2020',
start_date: '2020-01-01',
end_date: '2020-12-31'),
],
];
}
/**
* Data provider for time names that the time splitter should not
* be able to split.
*
* @return array<string, array{0: string, 1: array{start_name: string, end_name: string, start_year: string, end_year: string, start_date: string, end_date: string, counting_time_year: string, counting_time_month: string, counting_time_day: string, counting_time_bcce: string}}>
*/
public static function timeNamesToSplitFromTillProvider():array {
$output = [];
foreach ([
"2004.01.-2004.02." => [
'start_name' => "Januar 2004",
'end_name' => "Februar 2004",
"start_year" => '2004',
"end_year" => '2004',
'start_date' => '2004-01-01',
'end_date' => '2004-02-31',
"counting_time_year" => "2004",
"counting_time_month" => "02",
"counting_time_day" => "01",
"counting_time_bcce" => "+",
],
"2004.01.-02." => [
'start_name' => "Januar 2004",
'end_name' => "Februar 2004",
"start_year" => '2004',
"end_year" => '2004',
'start_date' => '2004-01-01',
'end_date' => '2004-02-31',
"counting_time_year" => "2004",
"counting_time_month" => "02",
"counting_time_day" => "01",
"counting_time_bcce" => "+",
],
"2003.04-05." => [
'start_name' => "April 2003",
'end_name' => "Mai 2003",
"start_year" => '2003',
"end_year" => '2003',
'start_date' => '2003-04-01',
'end_date' => '2003-05-31',
"counting_time_year" => "2003",
"counting_time_month" => "05",
"counting_time_day" => "01",
"counting_time_bcce" => "+",
],
"1981. július-augusztus" => [
'start_name' => "Juli 1981",
'end_name' => "August 1981",
"start_year" => '1981',
"end_year" => '1981',
'start_date' => '1981-07-01',
'end_date' => '1981-08-31',
"counting_time_year" => "1981",
"counting_time_month" => "08",
"counting_time_day" => "01",
"counting_time_bcce" => "+",
],
"2019.03.14.,04.15." => [
'start_name' => "14.03.2019",
'end_name' => "15.04.2019",
"start_year" => '2019',
"end_year" => '2019',
'start_date' => '2019-03-14',
'end_date' => '2019-04-15',
"counting_time_year" => "2019",
"counting_time_month" => "03",
"counting_time_day" => "30",
"counting_time_bcce" => "+",
],
"14.-15.03.2019" => [
'start_name' => "14.03.2019",
'end_name' => "15.03.2019",
"start_year" => '2019',
"end_year" => '2019',
'start_date' => '2019-03-14',
'end_date' => '2019-03-15',
"counting_time_year" => "2019",
"counting_time_month" => "03",
"counting_time_day" => "15",
"counting_time_bcce" => "+",
],
"3.-7.9.1819" => [
'start_name' => "03.09.1819",
'end_name' => "07.09.1819",
"start_year" => '1819',
"end_year" => '1819',
'start_date' => '1819-09-03',
'end_date' => '1819-09-07',
"counting_time_year" => "1819",
"counting_time_month" => "09",
"counting_time_day" => "05",
"counting_time_bcce" => "+",
],
"3.-15.9.1819" => [
'start_name' => "03.09.1819",
'end_name' => "15.09.1819",
"start_year" => '1819',
"end_year" => '1819',
'start_date' => '1819-09-03',
'end_date' => '1819-09-15',
"counting_time_year" => "1819",
"counting_time_month" => "09",
"counting_time_day" => "09",
"counting_time_bcce" => "+",
],
"14.-15.9.1819" => [
'start_name' => "14.09.1819",
'end_name' => "15.09.1819",
"start_year" => '1819',
"end_year" => '1819',
'start_date' => '1819-09-14',
'end_date' => '1819-09-15',
"counting_time_year" => "1819",
"counting_time_month" => "09",
"counting_time_day" => "15",
"counting_time_bcce" => "+",
],
"14.-15.11.1819" => [
'start_name' => "14.11.1819",
'end_name' => "15.11.1819",
"start_year" => '1819',
"end_year" => '1819',
'start_date' => '1819-11-14',
'end_date' => '1819-11-15',
"counting_time_year" => "1819",
"counting_time_month" => "11",
"counting_time_day" => "15",
"counting_time_bcce" => "+",
],
"2019.03.14-15" => [
'start_name' => "14.03.2019",
'end_name' => "15.03.2019",
"start_year" => '2019',
"end_year" => '2019',
'start_date' => '2019-03-14',
'end_date' => '2019-03-15',
"counting_time_year" => "2019",
"counting_time_month" => "03",
"counting_time_day" => "15",
"counting_time_bcce" => "+",
],
"17-19.század" => [
'start_name' => "1601",
'end_name' => "1900",
"start_year" => '1601',
"end_year" => '1900',
'start_date' => '1601-01-01',
'end_date' => '1900-12-31',
"counting_time_year" => "1751",
"counting_time_month" => "01",
"counting_time_day" => "01",
"counting_time_bcce" => "+",
],
"1950-60-as évek" => [
'start_name' => "1950",
'end_name' => "1969",
"start_year" => '1950',
"end_year" => '1969',
'start_date' => '1950-01-01',
'end_date' => '1969-12-31',
"counting_time_year" => "1960",
"counting_time_month" => "01",
"counting_time_day" => "01",
"counting_time_bcce" => "+",
],
] as $in => $out) {
$output[$in] = [$in, $out];
}
return $output;
}
/**
* Data provider for time names that the time splitter should not
* be able to split.
*
* @return array<array{0: string}>
*/
public static function nonSplittableNamesProvider():array {
$output = [
'empty string' => [''],
];
foreach ([
"1.2.2020-2.2.2020",
"2020 Januar 2-2020 Februar 2",
"2020 Januar-2020 Februar",
"Januar-Februar",
"13.13.2022",
"2022-13-13",
"40.10.2022",
"2022-10-40",
"6;November 1978",
"65497028c51eb",
"6552cf08b0196 test tag",
"1978. július7",
"1978. július 7 elött",
"Anfang September 1903",
"120-63 v. Chr.",
"0-25 n. Chr.", // Should not be splittable because 25 CE is too close to 0. 0 might actually be correct, not an artefact.
] as $entry) {
$output[$entry] = [$entry];
}
return $output;
}
Add tests for German dates, enable splitting of 5 digit timespans
2020-09-26 15:10:06 +02:00
/**
* Test to check whether the HTML page is correctly generated.
*
* @author Joshua Ramon Enslin <joshua@museum-digital.de>
* @group ValidOutput
Add autoloader for tests, phpunit config
2023-11-06 23:46:30 +01:00
* @small
Add tests for German dates, enable splitting of 5 digit timespans
2020-09-26 15:10:06 +02:00
*
* @return void
*/
Continue refactoring tests for time splitter to run provider-based
2025-02-24 14:02:42 +01:00
public function testSplitSimpleDatesGermanOld():void {
Refactor time splitter, support computing of dates for time entries
2024-04-16 23:21:34 +02:00
Allow automatic translations of days before 1000 CE
2020-09-26 16:02:18 +02:00
$output = NodaTimeSplitter::attempt_splitting("02.1.25 v. Chr");
Refactor time splitter, support computing of dates for time entries
2024-04-16 23:21:34 +02:00
self::assertNotEmpty($output);
self::assertEquals($output->toOldFormat(), [
Allow automatic translations of days before 1000 CE
2020-09-26 16:02:18 +02:00
0 => "-25",
1 => "-25",
2 => "01",
3 => "02",
4 => "-",
5 => "",
]);
Refactor time splitter, support computing of dates for time entries
2024-04-16 23:21:34 +02:00
self::assertEquals($output->toTimeName(), "02.01.25 v. Chr.");
Allow automatic translations of days before 1000 CE
2020-09-26 16:02:18 +02:00
self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 25);
$output = NodaTimeSplitter::attempt_splitting("2.01.25 v. Chr");
Refactor time splitter, support computing of dates for time entries
2024-04-16 23:21:34 +02:00
self::assertNotEmpty($output);
self::assertEquals($output->toOldFormat(), [
Allow automatic translations of days before 1000 CE
2020-09-26 16:02:18 +02:00
0 => "-25",
1 => "-25",
2 => "01",
3 => "02",
4 => "-",
5 => "",
]);
Refactor time splitter, support computing of dates for time entries
2024-04-16 23:21:34 +02:00
self::assertEquals($output->toTimeName(), "02.01.25 v. Chr.");
Allow automatic translations of days before 1000 CE
2020-09-26 16:02:18 +02:00
self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 25);
$output = NodaTimeSplitter::attempt_splitting("02.01.25 v. Chr");
Refactor time splitter, support computing of dates for time entries
2024-04-16 23:21:34 +02:00
self::assertNotEmpty($output);
self::assertEquals($output->toOldFormat(), [
Allow automatic translations of days before 1000 CE
2020-09-26 16:02:18 +02:00
0 => "-25",
1 => "-25",
2 => "01",
3 => "02",
4 => "-",
5 => "",
]);
Refactor time splitter, support computing of dates for time entries
2024-04-16 23:21:34 +02:00
self::assertEquals($output->toTimeName(), "02.01.25 v. Chr.");
Allow automatic translations of days before 1000 CE
2020-09-26 16:02:18 +02:00
self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 25);
$output = NodaTimeSplitter::attempt_splitting("2.1.25 v. Chr");
Refactor time splitter, support computing of dates for time entries
2024-04-16 23:21:34 +02:00
self::assertNotEmpty($output);
self::assertEquals($output->toOldFormat(), [
Allow automatic translations of days before 1000 CE
2020-09-26 16:02:18 +02:00
0 => "-25",
1 => "-25",
2 => "01",
3 => "02",
4 => "-",
5 => "",
]);
Refactor time splitter, support computing of dates for time entries
2024-04-16 23:21:34 +02:00
self::assertEquals($output->toTimeName(), "02.01.25 v. Chr.");
Allow automatic translations of days before 1000 CE
2020-09-26 16:02:18 +02:00
self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 25);
Add tests for German dates, enable splitting of 5 digit timespans
2020-09-26 15:10:06 +02:00
$output = NodaTimeSplitter::attempt_splitting("02.01.2020");
Refactor time splitter, support computing of dates for time entries
2024-04-16 23:21:34 +02:00
self::assertNotEmpty($output);
self::assertEquals($output->toOldFormat(), [
Add tests for German dates, enable splitting of 5 digit timespans
2020-09-26 15:10:06 +02:00
0 => "2020",
1 => "2020",
2 => "01",
3 => "02",
4 => "+",
5 => "",
]);
Refactor time splitter, support computing of dates for time entries
2024-04-16 23:21:34 +02:00
self::assertEquals($output->toTimeName(), "02.01.2020");
Add tests for German dates, enable splitting of 5 digit timespans
2020-09-26 15:10:06 +02:00
self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 2020);
Cover more edge cases for splitting time names
2025-01-15 11:49:20 +01:00
$output = NodaTimeSplitter::attempt_splitting(".2020");
self::assertNotEmpty($output);
self::assertEquals($output->toOldFormat(), [
0 => "2020",
1 => "2020",
2 => "00",
3 => "00",
4 => "+",
5 => "",
]);
self::assertEquals($output->toTimeName(), "2020");
self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 2020);
$output = NodaTimeSplitter::attempt_splitting("0-2020");
self::assertNotEmpty($output);
self::assertEquals($output->toOldFormat(), [
0 => "2020",
1 => "2020",
2 => "00",
3 => "00",
4 => "+",
5 => "",
]);
self::assertEquals($output->toTimeName(), "2020");
self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 2020);
$output = NodaTimeSplitter::attempt_splitting("2020-0");
self::assertNotEmpty($output);
self::assertEquals($output->toOldFormat(), [
0 => "2020",
1 => "2020",
2 => "00",
3 => "00",
4 => "+",
5 => "",
]);
self::assertEquals($output->toTimeName(), "2020");
self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 2020);
Add tests for German dates, enable splitting of 5 digit timespans
2020-09-26 15:10:06 +02:00
$output = NodaTimeSplitter::attempt_splitting("1920-1929");
Refactor time splitter, support computing of dates for time entries
2024-04-16 23:21:34 +02:00
self::assertNotEmpty($output);
self::assertEquals($output->toOldFormat(), [
Add tests for German dates, enable splitting of 5 digit timespans
2020-09-26 15:10:06 +02:00
0 => "1920",
1 => "1929",
2 => "00",
3 => "00",
4 => "+",
5 => "",
]);
Refactor time splitter, support computing of dates for time entries
2024-04-16 23:21:34 +02:00
self::assertEquals($output->toTimeName(), "1920-1929");
Add tests for German dates, enable splitting of 5 digit timespans
2020-09-26 15:10:06 +02:00
self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 1925);
Allow splitting times "before <X>"
2020-10-04 19:27:23 +02:00
$output = NodaTimeSplitter::attempt_splitting("Vor Dezember 2020");
Refactor time splitter, support computing of dates for time entries
2024-04-16 23:21:34 +02:00
self::assertNotEmpty($output);
self::assertEquals($output->toOldFormat(), [
Allow splitting times "before <X>"
2020-10-04 19:27:23 +02:00
0 => "?",
1 => "2020",
2 => "12",
3 => "00",
4 => "+",
5 => "Vor",
]);
Refactor time splitter, support computing of dates for time entries
2024-04-16 23:21:34 +02:00
self::assertEquals($output->toTimeName(), "Vor Dezember 2020");
Allow splitting times "before <X>"
2020-10-04 19:27:23 +02:00
self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 2020);
$output = NodaTimeSplitter::attempt_splitting("Vor 2020");
Refactor time splitter, support computing of dates for time entries
2024-04-16 23:21:34 +02:00
self::assertNotEmpty($output);
self::assertEquals($output->toOldFormat(), [
Allow splitting times "before <X>"
2020-10-04 19:27:23 +02:00
0 => "?",
1 => "2019",
2 => "00",
3 => "00",
4 => "+",
5 => "Vor",
]);
Refactor time splitter, support computing of dates for time entries
2024-04-16 23:21:34 +02:00
self::assertEquals($output->toTimeName(), "Vor 2020");
Allow splitting times "before <X>"
2020-10-04 19:27:23 +02:00
self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 2020);
Allow splitting times after <year><month>
2020-10-04 19:17:18 +02:00
$output = NodaTimeSplitter::attempt_splitting("Nach Januar 2020");
Refactor time splitter, support computing of dates for time entries
2024-04-16 23:21:34 +02:00
self::assertNotEmpty($output);
self::assertEquals($output->toOldFormat(), [
Allow splitting times after <year><month>
2020-10-04 19:17:18 +02:00
0 => "2020",
1 => "?",
2 => "01",
3 => "00",
4 => "+",
5 => "Nach",
]);
Refactor time splitter, support computing of dates for time entries
2024-04-16 23:21:34 +02:00
self::assertEquals($output->toTimeName(), "Nach Januar 2020");
Allow splitting times after <year><month>
2020-10-04 19:17:18 +02:00
self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 2020);
Add tests for splitting common historical month names
2022-04-12 23:47:08 +02:00
$output = NodaTimeSplitter::attempt_splitting("Januar 2020");
Refactor time splitter, support computing of dates for time entries
2024-04-16 23:21:34 +02:00
self::assertNotEmpty($output);
self::assertEquals($output->toOldFormat(), [
Add tests for splitting common historical month names
2022-04-12 23:47:08 +02:00
0 => "2020",
1 => "2020",
2 => "01",
3 => "00",
4 => "+",
5 => "",
]);
Refactor time splitter, support computing of dates for time entries
2024-04-16 23:21:34 +02:00
self::assertEquals($output->toTimeName(), "Januar 2020");
Add tests for splitting common historical month names
2022-04-12 23:47:08 +02:00
self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 2020);
$output = NodaTimeSplitter::attempt_splitting("Januar 1217");
Refactor time splitter, support computing of dates for time entries
2024-04-16 23:21:34 +02:00
self::assertNotEmpty($output);
self::assertEquals($output->toOldFormat(), [
Add tests for splitting common historical month names
2022-04-12 23:47:08 +02:00
0 => "1217",
1 => "1217",
2 => "01",
3 => "00",
4 => "+",
5 => "",
]);
Fix bug in setting names for months
2022-11-03 16:02:10 +01:00
Refactor time splitter, support computing of dates for time entries
2024-04-16 23:21:34 +02:00
self::assertEquals($output->toTimeName(), "Januar 1217");
Add tests for splitting common historical month names
2022-04-12 23:47:08 +02:00
self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 1217);
Fix bug in setting names for months
2022-11-03 16:02:10 +01:00
$output = NodaTimeSplitter::attempt_splitting("Januar 1520");
Refactor time splitter, support computing of dates for time entries
2024-04-16 23:21:34 +02:00
self::assertNotEmpty($output);
self::assertEquals($output->toOldFormat(), [
Fix bug in setting names for months
2022-11-03 16:02:10 +01:00
0 => "1520",
1 => "1520",
2 => "01",
3 => "00",
4 => "+",
5 => "",
]);
Refactor time splitter, support computing of dates for time entries
2024-04-16 23:21:34 +02:00
self::assertEquals($output->toTimeName(), "Januar 1520");
Fix bug in setting names for months
2022-11-03 16:02:10 +01:00
self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 1520);
$output = NodaTimeSplitter::attempt_splitting("Januar 1001");
Refactor time splitter, support computing of dates for time entries
2024-04-16 23:21:34 +02:00
self::assertNotEmpty($output);
self::assertEquals($output->toOldFormat(), [
Fix bug in setting names for months
2022-11-03 16:02:10 +01:00
0 => "1001",
1 => "1001",
2 => "01",
3 => "00",
4 => "+",
5 => "",
]);
Refactor time splitter, support computing of dates for time entries
2024-04-16 23:21:34 +02:00
self::assertEquals($output->toTimeName(), "Januar 1001");
Fix bug in setting names for months
2022-11-03 16:02:10 +01:00
self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 1001);
$output = NodaTimeSplitter::attempt_splitting("Januar 2780");
Refactor time splitter, support computing of dates for time entries
2024-04-16 23:21:34 +02:00
self::assertNotEmpty($output);
self::assertEquals($output->toOldFormat(), [
Fix bug in setting names for months
2022-11-03 16:02:10 +01:00
0 => "2780",
1 => "2780",
2 => "01",
3 => "00",
4 => "+",
5 => "",
]);
Refactor time splitter, support computing of dates for time entries
2024-04-16 23:21:34 +02:00
self::assertEquals($output->toTimeName(), "Januar 2780");
Fix bug in setting names for months
2022-11-03 16:02:10 +01:00
self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 2780);
Allow splitting times after <year><month>
2020-10-04 19:17:18 +02:00
$output = NodaTimeSplitter::attempt_splitting("Nach 60er Jahre");
Refactor time splitter, support computing of dates for time entries
2024-04-16 23:21:34 +02:00
self::assertNotEmpty($output);
self::assertEquals($output->toOldFormat(), [
Allow splitting times after <year><month>
2020-10-04 19:17:18 +02:00
0 => "1970",
1 => "?",
2 => "00",
3 => "00",
4 => "+",
5 => "Nach",
]);
Refactor time splitter, support computing of dates for time entries
2024-04-16 23:21:34 +02:00
self::assertEquals($output->toTimeName(), "Nach 1969");
Allow splitting times after <year><month>
2020-10-04 19:17:18 +02:00
self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 1969);
Allow splitting times "Nach 1905" ("Nach " followed by 4 digit time number)
2020-10-04 17:39:34 +02:00
$output = NodaTimeSplitter::attempt_splitting("Nach 2020");
Refactor time splitter, support computing of dates for time entries
2024-04-16 23:21:34 +02:00
self::assertNotEmpty($output);
self::assertEquals($output->toOldFormat(), [
Allow splitting times "Nach 1905" ("Nach " followed by 4 digit time number)
2020-10-04 17:39:34 +02:00
0 => "2021",
1 => "?",
2 => "00",
3 => "00",
4 => "+",
5 => "Nach",
]);
Refactor time splitter, support computing of dates for time entries
2024-04-16 23:21:34 +02:00
self::assertEquals($output->toTimeName(), "Nach 2020");
Allow splitting times "Nach 1905" ("Nach " followed by 4 digit time number)
2020-10-04 17:39:34 +02:00
self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 2020);
$output = NodaTimeSplitter::attempt_splitting("Bis Januar 2020");
Refactor time splitter, support computing of dates for time entries
2024-04-16 23:21:34 +02:00
self::assertNotEmpty($output);
self::assertEquals($output->toOldFormat(), [
Allow splitting times "Nach 1905" ("Nach " followed by 4 digit time number)
2020-10-04 17:39:34 +02:00
0 => "?",
1 => "2020",
2 => "01",
3 => "00",
4 => "+",
Refactor time splitter, support computing of dates for time entries
2024-04-16 23:21:34 +02:00
5 => "Bis",
Allow splitting times "Nach 1905" ("Nach " followed by 4 digit time number)
2020-10-04 17:39:34 +02:00
]);
Refactor time splitter, support computing of dates for time entries
2024-04-16 23:21:34 +02:00
self::assertEquals($output->toTimeName(), "Bis Januar 2020");
Allow splitting times "Nach 1905" ("Nach " followed by 4 digit time number)
2020-10-04 17:39:34 +02:00
self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 2020);
Add tests for German dates, enable splitting of 5 digit timespans
2020-09-26 15:10:06 +02:00
$output = NodaTimeSplitter::attempt_splitting("Januar 2020");
Refactor time splitter, support computing of dates for time entries
2024-04-16 23:21:34 +02:00
self::assertNotEmpty($output);
self::assertEquals($output->toOldFormat(), [
Continue refactoring tests for time splitter to run provider-based
2025-02-24 14:02:42 +01:00
0 => "2020",
1 => "2020",
2 => "01",
Handle Jhdt as a form of century in time splitter Close #9
2022-03-12 19:32:28 +01:00
3 => "00",
4 => "+",
5 => "",
]);
Continue refactoring tests for time splitter to run provider-based
2025-02-24 14:02:42 +01:00
self::assertEquals($output->toTimeName(), "Januar 2020");
self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 2020);
Handle Jhdt as a form of century in time splitter Close #9
2022-03-12 19:32:28 +01:00
Continue refactoring tests for time splitter to run provider-based
2025-02-24 14:02:42 +01:00
// Intl' month: 2020-01
$output = NodaTimeSplitter::attempt_splitting("2020-01");
Refactor time splitter, support computing of dates for time entries
2024-04-16 23:21:34 +02:00
self::assertNotEmpty($output);
self::assertEquals($output->toOldFormat(), [
Continue refactoring tests for time splitter to run provider-based
2025-02-24 14:02:42 +01:00
0 => "2020",
1 => "2020",
2 => "01",
Handle Jhdt as a form of century in time splitter Close #9
2022-03-12 19:32:28 +01:00
3 => "00",
4 => "+",
5 => "",
]);
Continue refactoring tests for time splitter to run provider-based
2025-02-24 14:02:42 +01:00
self::assertEquals($output->toTimeName(), "Januar 2020");
self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 2020);
Handle Jhdt as a form of century in time splitter Close #9
2022-03-12 19:32:28 +01:00
Continue refactoring tests for time splitter to run provider-based
2025-02-24 14:02:42 +01:00
$output = NodaTimeSplitter::attempt_splitting("Januar 2020 v. Chr.");
Refactor time splitter, support computing of dates for time entries
2024-04-16 23:21:34 +02:00
self::assertNotEmpty($output);
self::assertEquals($output->toOldFormat(), [
Continue refactoring tests for time splitter to run provider-based
2025-02-24 14:02:42 +01:00
0 => "-2020",
1 => "-2020",
2 => "01",
Handle Jhdt as a form of century in time splitter Close #9
2022-03-12 19:32:28 +01:00
3 => "00",
Continue refactoring tests for time splitter to run provider-based
2025-02-24 14:02:42 +01:00
4 => "-",
Handle Jhdt as a form of century in time splitter Close #9
2022-03-12 19:32:28 +01:00
5 => "",
]);
Continue refactoring tests for time splitter to run provider-based
2025-02-24 14:02:42 +01:00
self::assertEquals($output->toTimeName(), "Januar 2020 v. Chr.");
self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 2020);
Handle Jhdt as a form of century in time splitter Close #9
2022-03-12 19:32:28 +01:00
Continue refactoring tests for time splitter to run provider-based
2025-02-24 14:02:42 +01:00
// 5-Digit timespans BCE
$output = NodaTimeSplitter::attempt_splitting("40000-25000 vor Christus");
Allow splitting 1945-48
2025-01-15 10:35:35 +01:00
self::assertNotEmpty($output);
self::assertEquals($output->toOldFormat(), [
Continue refactoring tests for time splitter to run provider-based
2025-02-24 14:02:42 +01:00
0 => "-40000",
1 => "-25000",
Allow splitting 1945-48
2025-01-15 10:35:35 +01:00
2 => "00",
3 => "00",
Continue refactoring tests for time splitter to run provider-based
2025-02-24 14:02:42 +01:00
4 => "-",
Allow splitting 1945-48
2025-01-15 10:35:35 +01:00
5 => "",
]);
Continue refactoring tests for time splitter to run provider-based
2025-02-24 14:02:42 +01:00
self::assertEquals($output->toTimeName(), "40000-25000 v. Chr.");
self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 32500);
Allow splitting 1945-48
2025-01-15 10:35:35 +01:00
Continue refactoring tests for time splitter to run provider-based
2025-02-24 14:02:42 +01:00
// 5-Digit timespans BCE
$output = NodaTimeSplitter::attempt_splitting("40000-25000 v.C.");
Cover more edge cases for splitting time names
2025-01-15 11:49:20 +01:00
self::assertNotEmpty($output);
self::assertEquals($output->toOldFormat(), [
Continue refactoring tests for time splitter to run provider-based
2025-02-24 14:02:42 +01:00
0 => "-40000",
1 => "-25000",
Cover more edge cases for splitting time names
2025-01-15 11:49:20 +01:00
2 => "00",
3 => "00",
Continue refactoring tests for time splitter to run provider-based
2025-02-24 14:02:42 +01:00
4 => "-",
Cover more edge cases for splitting time names
2025-01-15 11:49:20 +01:00
5 => "",
]);
Continue refactoring tests for time splitter to run provider-based
2025-02-24 14:02:42 +01:00
self::assertEquals($output->toTimeName(), "40000-25000 v. Chr.");
self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 32500);
Cover more edge cases for splitting time names
2025-01-15 11:49:20 +01:00
Continue refactoring tests for time splitter to run provider-based
2025-02-24 14:02:42 +01:00
$output = NodaTimeSplitter::attempt_splitting("20. Jahrhundert v. Chr.");
Cover more edge cases for splitting time names
2025-01-15 11:49:20 +01:00
self::assertNotEmpty($output);
self::assertEquals($output->toOldFormat(), [
Continue refactoring tests for time splitter to run provider-based
2025-02-24 14:02:42 +01:00
0 => "-2000",
1 => "-1901",
Cover more edge cases for splitting time names
2025-01-15 11:49:20 +01:00
2 => "00",
3 => "00",
Continue refactoring tests for time splitter to run provider-based
2025-02-24 14:02:42 +01:00
4 => "-",
Cover more edge cases for splitting time names
2025-01-15 11:49:20 +01:00
5 => "",
]);
Continue refactoring tests for time splitter to run provider-based
2025-02-24 14:02:42 +01:00
self::assertEquals($output->toTimeName(), "2000-1901 v. Chr.");
self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 1950);
Cover more edge cases for splitting time names
2025-01-15 11:49:20 +01:00
Add tests for German dates, enable splitting of 5 digit timespans
2020-09-26 15:10:06 +02:00
$output = NodaTimeSplitter::attempt_splitting("20.-19. Jahrhundert v. Chr.");
Refactor time splitter, support computing of dates for time entries
2024-04-16 23:21:34 +02:00
self::assertNotEmpty($output);
self::assertEquals($output->toOldFormat(), [
Add tests for German dates, enable splitting of 5 digit timespans
2020-09-26 15:10:06 +02:00
0 => "-2000",
1 => "-1801",
2 => "00",
3 => "00",
4 => "-",
5 => "",
]);
Refactor time splitter, support computing of dates for time entries
2024-04-16 23:21:34 +02:00
self::assertEquals($output->toTimeName(), "2000-1801 v. Chr.");
Add tests for German dates, enable splitting of 5 digit timespans
2020-09-26 15:10:06 +02:00
self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 1900);
$output = NodaTimeSplitter::attempt_splitting("Bis 20.-19. Jahrhundert v. Chr.");
Refactor time splitter, support computing of dates for time entries
2024-04-16 23:21:34 +02:00
self::assertNotEmpty($output);
self::assertEquals($output->toOldFormat(), [
Add tests for German dates, enable splitting of 5 digit timespans
2020-09-26 15:10:06 +02:00
0 => "?",
1 => "-1801",
2 => "00",
3 => "00",
4 => "-",
Refactor time splitter, support computing of dates for time entries
2024-04-16 23:21:34 +02:00
5 => "Bis",
Add tests for German dates, enable splitting of 5 digit timespans
2020-09-26 15:10:06 +02:00
]);
Refactor time splitter, support computing of dates for time entries
2024-04-16 23:21:34 +02:00
self::assertEquals($output->toTimeName(), "Bis 1801 v. Chr.");
Add tests for German dates, enable splitting of 5 digit timespans
2020-09-26 15:10:06 +02:00
self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 1801);
Ensure times can be split despite spaces at random points in given name
2024-10-23 18:02:23 +02:00
$output = NodaTimeSplitter::attempt_splitting("15. 11. 1978");
self::assertNotEmpty($output);
self::assertEquals($output->toOldFormat(), [
0 => "1978",
1 => "1978",
2 => "11",
3 => "15",
4 => "+",
5 => "",
]);
self::assertEquals($output->toTimeName(), "15.11.1978");
self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 1978);
Fix bug in German dates like "1 November 1921"
2022-09-08 16:28:27 +02:00
$output = NodaTimeSplitter::attempt_splitting("6 November 1978");
Refactor time splitter, support computing of dates for time entries
2024-04-16 23:21:34 +02:00
self::assertNotEmpty($output);
self::assertEquals($output->toOldFormat(), [
Fix bug in German dates like "1 November 1921"
2022-09-08 16:28:27 +02:00
0 => "1978",
1 => "1978",
2 => "11",
3 => "06",
4 => "+",
5 => "",
]);
Refactor time splitter, support computing of dates for time entries
2024-04-16 23:21:34 +02:00
self::assertEquals($output->toTimeName(), "06.11.1978");
Fix bug in German dates like "1 November 1921"
2022-09-08 16:28:27 +02:00
self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 1978);
Add tests for German dates, enable splitting of 5 digit timespans
2020-09-26 15:10:06 +02:00
}
Support BCE / CE times
2023-10-15 19:20:16 +02:00
/**
Continue refactoring tests for time splitter to run provider-based
2025-02-24 14:02:42 +01:00
* Test that German dates are correctly parsed.
Support BCE / CE times
2023-10-15 19:20:16 +02:00
*
* @author Joshua Ramon Enslin <joshua@museum-digital.de>
* @group ValidOutput
Add autoloader for tests, phpunit config
2023-11-06 23:46:30 +01:00
* @small
Support BCE / CE times
2023-10-15 19:20:16 +02:00
*
Continue refactoring tests for time splitter to run provider-based
2025-02-24 14:02:42 +01:00
* @param string $time_name Input time name.
* @param NodaSplitTime $expected Expected output.
* @param string $expected_name Expected name.
*
Support BCE / CE times
2023-10-15 19:20:16 +02:00
* @return void
*/
Continue refactoring tests for time splitter to run provider-based
2025-02-24 14:02:42 +01:00
#[DataProvider('splittableGermanTimeNamesProvider')]
public function testSplitSimpleDatesGerman(string $time_name, NodaSplitTime $expected, string $expected_name):void {
Support BCE / CE times
2023-10-15 19:20:16 +02:00
Continue refactoring tests for time splitter to run provider-based
2025-02-24 14:02:42 +01:00
$output = NodaTimeSplitter::attempt_splitting($time_name);
self::assertEquals($expected, $output);
self::assertEquals($expected_name, $output->toTimeName());
Support BCE / CE times
2023-10-15 19:20:16 +02:00
Continue refactoring tests for time splitter to run provider-based
2025-02-24 14:02:42 +01:00
}
/**
* Test that English dates are correctly parsed.
*
* @author Joshua Ramon Enslin <joshua@museum-digital.de>
* @group ValidOutput
* @small
*
* @param string $time_name Input time name.
* @param NodaSplitTime $expected Expected output.
* @param string $expected_name Expected name.
*
* @return void
*/
#[DataProvider('splittableEnglishTimeNamesProvider')]
public function testSplitSimpleDatesEnglish(string $time_name, NodaSplitTime $expected, string $expected_name):void {
$output = NodaTimeSplitter::attempt_splitting($time_name);
self::assertEquals($expected, $output);
self::assertEquals($expected_name, $output->toTimeName());
Support BCE / CE times
2023-10-15 19:20:16 +02:00
}
Add tests for splitting Hungarian dates
2020-09-26 14:15:15 +02:00
/**
Continue refactoring tests for time splitter to run provider-based
2025-02-24 14:02:42 +01:00
* Test that Hungarian dates are correctly parsed.
Add tests for splitting Hungarian dates
2020-09-26 14:15:15 +02:00
*
* @author Joshua Ramon Enslin <joshua@museum-digital.de>
* @group ValidOutput
Add autoloader for tests, phpunit config
2023-11-06 23:46:30 +01:00
* @small
Add tests for splitting Hungarian dates
2020-09-26 14:15:15 +02:00
*
* @return void
*/
public function testSplitSimpleDatesHungarian():void {
Fix edge case 200 b.c. in NodaSplitTime
2024-07-08 01:27:03 +02:00
$output = NodaTimeSplitter::attempt_splitting("Kr. e. 2. század");
self::assertNotEmpty($output);
self::assertEquals($output->toOldFormat(), [
0 => "-200",
1 => "-101",
2 => "00",
3 => "00",
4 => "-",
5 => "",
]);
self::assertEquals($output->toTimeName(), "200-101 v. Chr.");
self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 150);
Add tests for splitting Hungarian dates
2020-09-26 14:15:15 +02:00
$output = NodaTimeSplitter::attempt_splitting("2020.01.02.");
Refactor time splitter, support computing of dates for time entries
2024-04-16 23:21:34 +02:00
self::assertNotEmpty($output);
self::assertEquals($output->toOldFormat(), [
Add tests for splitting Hungarian dates
2020-09-26 14:15:15 +02:00
0 => "2020",
1 => "2020",
2 => "01",
3 => "02",
4 => "+",
5 => "",
]);
Refactor time splitter, support computing of dates for time entries
2024-04-16 23:21:34 +02:00
self::assertEquals($output->toTimeName(), "02.01.2020");
Add tests for German dates, enable splitting of 5 digit timespans
2020-09-26 15:10:06 +02:00
self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 2020);
Add tests for splitting Hungarian dates
2020-09-26 14:15:15 +02:00
Extend NodaTimeSplitter
2023-12-09 23:54:45 +01:00
$output = NodaTimeSplitter::attempt_splitting("2020. januar. 2.");
Refactor time splitter, support computing of dates for time entries
2024-04-16 23:21:34 +02:00
self::assertNotEmpty($output);
self::assertEquals($output->toOldFormat(), [
Extend NodaTimeSplitter
2023-12-09 23:54:45 +01:00
0 => "2020",
1 => "2020",
2 => "01",
3 => "02",
4 => "+",
5 => "",
]);
Refactor time splitter, support computing of dates for time entries
2024-04-16 23:21:34 +02:00
self::assertEquals($output->toTimeName(), "02.01.2020");
Extend NodaTimeSplitter
2023-12-09 23:54:45 +01:00
self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 2020);
Rewrite incomplete time span spellings to extend parsable and splittable time names
2023-11-20 03:18:02 +01:00
$output = NodaTimeSplitter::attempt_splitting("2020.01.2.");
Refactor time splitter, support computing of dates for time entries
2024-04-16 23:21:34 +02:00
self::assertNotEmpty($output);
self::assertEquals($output->toOldFormat(), [
Rewrite incomplete time span spellings to extend parsable and splittable time names
2023-11-20 03:18:02 +01:00
0 => "2020",
1 => "2020",
2 => "01",
3 => "02",
4 => "+",
5 => "",
]);
Refactor time splitter, support computing of dates for time entries
2024-04-16 23:21:34 +02:00
self::assertEquals($output->toTimeName(), "02.01.2020");
Rewrite incomplete time span spellings to extend parsable and splittable time names
2023-11-20 03:18:02 +01:00
self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 2020);
$output = NodaTimeSplitter::attempt_splitting("2020.1.2.");
Refactor time splitter, support computing of dates for time entries
2024-04-16 23:21:34 +02:00
self::assertNotEmpty($output);
self::assertEquals($output->toOldFormat(), [
Rewrite incomplete time span spellings to extend parsable and splittable time names
2023-11-20 03:18:02 +01:00
0 => "2020",
1 => "2020",
2 => "01",
3 => "02",
4 => "+",
5 => "",
]);
Refactor time splitter, support computing of dates for time entries
2024-04-16 23:21:34 +02:00
self::assertEquals($output->toTimeName(), "02.01.2020");
Rewrite incomplete time span spellings to extend parsable and splittable time names
2023-11-20 03:18:02 +01:00
self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 2020);
Add tests for splitting Hungarian dates
2020-09-26 14:15:15 +02:00
$output = NodaTimeSplitter::attempt_splitting("2020. Januar 2.");
Refactor time splitter, support computing of dates for time entries
2024-04-16 23:21:34 +02:00
self::assertNotEmpty($output);
self::assertEquals($output->toOldFormat(), [
Add tests for splitting Hungarian dates
2020-09-26 14:15:15 +02:00
0 => "2020",
1 => "2020",
2 => "01",
3 => "02",
4 => "+",
5 => "",
]);
Refactor time splitter, support computing of dates for time entries
2024-04-16 23:21:34 +02:00
self::assertEquals($output->toTimeName(), "02.01.2020");
Add test assertion for splitting international dates
2020-09-27 12:40:15 +02:00
self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 2020);
$output = NodaTimeSplitter::attempt_splitting("2020-01-02");
Refactor time splitter, support computing of dates for time entries
2024-04-16 23:21:34 +02:00
self::assertNotEmpty($output);
self::assertEquals($output->toOldFormat(), [
Add test assertion for splitting international dates
2020-09-27 12:40:15 +02:00
0 => "2020",
1 => "2020",
2 => "01",
3 => "02",
4 => "+",
5 => "",
]);
Refactor time splitter, support computing of dates for time entries
2024-04-16 23:21:34 +02:00
self::assertEquals($output->toTimeName(), "02.01.2020");
Add tests for German dates, enable splitting of 5 digit timespans
2020-09-26 15:10:06 +02:00
self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 2020);
Add tests for splitting Hungarian dates
2020-09-26 14:15:15 +02:00
$output = NodaTimeSplitter::attempt_splitting("1920-tól 1929-ig");
Refactor time splitter, support computing of dates for time entries
2024-04-16 23:21:34 +02:00
self::assertNotEmpty($output);
self::assertEquals($output->toOldFormat(), [
Add tests for splitting Hungarian dates
2020-09-26 14:15:15 +02:00
0 => "1920",
1 => "1929",
2 => "00",
3 => "00",
4 => "+",
5 => "",
]);
Refactor time splitter, support computing of dates for time entries
2024-04-16 23:21:34 +02:00
self::assertEquals($output->toTimeName(), "1920-1929");
Add tests for German dates, enable splitting of 5 digit timespans
2020-09-26 15:10:06 +02:00
self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 1925);
Add tests for splitting Hungarian dates
2020-09-26 14:15:15 +02:00
$output = NodaTimeSplitter::attempt_splitting("1920-1929 között");
Refactor time splitter, support computing of dates for time entries
2024-04-16 23:21:34 +02:00
self::assertNotEmpty($output);
self::assertEquals($output->toOldFormat(), [
Add tests for splitting Hungarian dates
2020-09-26 14:15:15 +02:00
0 => "1920",
1 => "1929",
2 => "00",
3 => "00",
4 => "+",
5 => "",
]);
Refactor time splitter, support computing of dates for time entries
2024-04-16 23:21:34 +02:00
self::assertEquals($output->toTimeName(), "1920-1929");
Add tests for German dates, enable splitting of 5 digit timespans
2020-09-26 15:10:06 +02:00
self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 1925);
Add tests for splitting Hungarian dates
2020-09-26 14:15:15 +02:00
Extend tests
2025-03-10 03:20:46 +01:00
$output = NodaTimeSplitter::attempt_splitting("1920-2929 között");
self::assertNotEmpty($output);
self::assertEquals($output->toOldFormat(), [
0 => "1920",
1 => "2929",
2 => "00",
3 => "00",
4 => "+",
5 => "",
]);
self::assertEquals($output->toTimeName(), "1920-2929");
self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 2425);
Add tests for splitting Hungarian dates
2020-09-26 14:15:15 +02:00
$output = NodaTimeSplitter::attempt_splitting("1920-től 1929-ig");
Refactor time splitter, support computing of dates for time entries
2024-04-16 23:21:34 +02:00
self::assertNotEmpty($output);
self::assertEquals($output->toOldFormat(), [
Add tests for splitting Hungarian dates
2020-09-26 14:15:15 +02:00
0 => "1920",
1 => "1929",
2 => "00",
3 => "00",
4 => "+",
5 => "",
]);
Continue refactoring tests for time splitter to run provider-based
2025-02-24 14:02:42 +01:00
self::assertEquals($output->toTimeName(), "1920-1929");
self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 1925);
Fix erroneous splitting of Hungarian time names with additions
2023-12-09 11:56:15 +01:00
Continue refactoring tests for time splitter to run provider-based
2025-02-24 14:02:42 +01:00
// From 1920 onwards
$output = NodaTimeSplitter::attempt_splitting("1920 utántól");
Refactor time splitter, support computing of dates for time entries
2024-04-16 23:21:34 +02:00
self::assertNotEmpty($output);
self::assertEquals($output->toOldFormat(), [
Continue refactoring tests for time splitter to run provider-based
2025-02-24 14:02:42 +01:00
0 => "1920",
1 => "?",
Fix erroneous splitting of Hungarian time names with additions
2023-12-09 11:56:15 +01:00
2 => "00",
3 => "00",
4 => "+",
Continue refactoring tests for time splitter to run provider-based
2025-02-24 14:02:42 +01:00
5 => "Seit",
Fix erroneous splitting of Hungarian time names with additions
2023-12-09 11:56:15 +01:00
]);
Continue refactoring tests for time splitter to run provider-based
2025-02-24 14:02:42 +01:00
self::assertEquals($output->toTimeName(), "Seit 1920");
self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 1920);
Fix erroneous splitting of Hungarian time names with additions
2023-12-09 11:56:15 +01:00
Continue refactoring tests for time splitter to run provider-based
2025-02-24 14:02:42 +01:00
$output = NodaTimeSplitter::attempt_splitting("III. század");
Refactor time splitter, support computing of dates for time entries
2024-04-16 23:21:34 +02:00
self::assertNotEmpty($output);
self::assertEquals($output->toOldFormat(), [
Continue refactoring tests for time splitter to run provider-based
2025-02-24 14:02:42 +01:00
0 => "201",
1 => "300",
Fix erroneous splitting of Hungarian time names with additions
2023-12-09 11:56:15 +01:00
2 => "00",
3 => "00",
4 => "+",
Continue refactoring tests for time splitter to run provider-based
2025-02-24 14:02:42 +01:00
5 => "",
Fix erroneous splitting of Hungarian time names with additions
2023-12-09 11:56:15 +01:00
]);
Continue refactoring tests for time splitter to run provider-based
2025-02-24 14:02:42 +01:00
self::assertEquals($output->toTimeName(), "201-300 n. Chr.");
self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 251);
Fix erroneous splitting of Hungarian time names with additions
2023-12-09 11:56:15 +01:00
Continue refactoring tests for time splitter to run provider-based
2025-02-24 14:02:42 +01:00
$output = NodaTimeSplitter::attempt_splitting("20th century");
Refactor time splitter, support computing of dates for time entries
2024-04-16 23:21:34 +02:00
self::assertNotEmpty($output);
self::assertEquals($output->toOldFormat(), [
Continue refactoring tests for time splitter to run provider-based
2025-02-24 14:02:42 +01:00
0 => "1901",
1 => "2000",
2 => "00",
Extend NodaTimeSplitter
2023-12-09 23:54:45 +01:00
3 => "00",
4 => "+",
Continue refactoring tests for time splitter to run provider-based
2025-02-24 14:02:42 +01:00
5 => "",
Extend NodaTimeSplitter
2023-12-09 23:54:45 +01:00
]);
Continue refactoring tests for time splitter to run provider-based
2025-02-24 14:02:42 +01:00
self::assertEquals($output->toTimeName(), "1901-2000");
self::assertEquals(NodaTimeSplitter::timePartsToCountingYear($output), 1951);
Extend NodaTimeSplitter
2023-12-09 23:54:45 +01:00
Add tests for splitting Hungarian dates
2020-09-26 14:15:15 +02:00
}
Handle Ukrainian year names (2022 p > 2022)
2024-03-24 00:59:30 +01:00
/**
Continue refactoring tests for time splitter to run provider-based
2025-02-24 14:02:42 +01:00
* Test that Hungarian dates are correctly parsed.
Handle Ukrainian year names (2022 p > 2022)
2024-03-24 00:59:30 +01:00
*
* @author Joshua Ramon Enslin <joshua@museum-digital.de>
* @group ValidOutput
* @small
*
Continue refactoring tests for time splitter to run provider-based
2025-02-24 14:02:42 +01:00
* @param string $time_name Input time name.
* @param NodaSplitTime $expected Expected output.
* @param string $expected_name Expected name.
*
Handle Ukrainian year names (2022 p > 2022)
2024-03-24 00:59:30 +01:00
* @return void
*/
Continue refactoring tests for time splitter to run provider-based
2025-02-24 14:02:42 +01:00
#[DataProvider('splittableHungarianTimeNamesProvider')]
public function testSplitSimpleDatesHungarianNew(string $time_name, NodaSplitTime $expected, string $expected_name):void {
Handle Ukrainian year names (2022 p > 2022)
2024-03-24 00:59:30 +01:00
Continue refactoring tests for time splitter to run provider-based
2025-02-24 14:02:42 +01:00
$output = NodaTimeSplitter::attempt_splitting($time_name);
self::assertEquals($expected, $output);
self::assertEquals($expected_name, $output->toTimeName());
Handle Ukrainian year names (2022 p > 2022)
2024-03-24 00:59:30 +01:00
}
Begin restructuring NodaTimeSplitterTest to use data providers
2025-02-21 10:31:21 +01:00
/**
Continue refactoring tests for time splitter to run provider-based
2025-02-24 14:02:42 +01:00
* Test that Ukrainian dates are correctly parsed.
*
* @author Joshua Ramon Enslin <joshua@museum-digital.de>
* @group ValidOutput
* @small
*
* @param string $time_name Input time name.
* @param NodaSplitTime $expected Expected output.
Begin restructuring NodaTimeSplitterTest to use data providers
2025-02-21 10:31:21 +01:00
*
Continue refactoring tests for time splitter to run provider-based
2025-02-24 14:02:42 +01:00
* @return void
Begin restructuring NodaTimeSplitterTest to use data providers
2025-02-21 10:31:21 +01:00
*/
Continue refactoring tests for time splitter to run provider-based
2025-02-24 14:02:42 +01:00
#[DataProvider('splittableUkrainianTimeNamesProvider')]
public function testSplitSimpleDatesUkrainian(string $time_name, NodaSplitTime $expected):void {
Begin restructuring NodaTimeSplitterTest to use data providers
2025-02-21 10:31:21 +01:00
Continue refactoring tests for time splitter to run provider-based
2025-02-24 14:02:42 +01:00
$output = NodaTimeSplitter::attempt_splitting($time_name);
self::assertNotEmpty($output);
self::assertEquals($expected, $output);
Begin restructuring NodaTimeSplitterTest to use data providers
2025-02-21 10:31:21 +01:00
}
Rewrite incomplete time span spellings to extend parsable and splittable time names
2023-11-20 03:18:02 +01:00
/**
Continue refactoring tests for time splitter to run provider-based
2025-02-24 14:02:42 +01:00
* Test to check that time spans can be parsed as expected.
Rewrite incomplete time span spellings to extend parsable and splittable time names
2023-11-20 03:18:02 +01:00
*
* @author Joshua Ramon Enslin <joshua@museum-digital.de>
* @group ValidOutput
* @small
*
Begin restructuring NodaTimeSplitterTest to use data providers
2025-02-21 10:31:21 +01:00
* @param string $time_name Input time name.
* @param array{start_name: string, end_name: string, start_year: string, end_year: string, start_date: string, end_date: string, counting_time_year: string, counting_time_month: string, counting_time_day: string, counting_time_bcce: string} $expected Expected values.
*
Rewrite incomplete time span spellings to extend parsable and splittable time names
2023-11-20 03:18:02 +01:00
* @return void
*/
Begin restructuring NodaTimeSplitterTest to use data providers
2025-02-21 10:31:21 +01:00
#[DataProvider('timeNamesToSplitFromTillProvider')]
public function testSplittingFromTill(string $time_name, array $expected):void {
Rewrite incomplete time span spellings to extend parsable and splittable time names
2023-11-20 03:18:02 +01:00
// Regular
Begin restructuring NodaTimeSplitterTest to use data providers
2025-02-21 10:31:21 +01:00
$output = NodaTimeSplitter::attempt_splitting_from_till($time_name);
Rewrite incomplete time span spellings to extend parsable and splittable time names
2023-11-20 03:18:02 +01:00
self::assertNotEmpty($output);
Continue refactoring tests for time splitter to run provider-based
2025-02-24 14:02:42 +01:00
self::assertEquals($expected, $output);
Begin restructuring NodaTimeSplitterTest to use data providers
2025-02-21 10:31:21 +01:00
}
/**
Continue refactoring tests for time splitter to run provider-based
2025-02-24 14:02:42 +01:00
* Test to check special cases of timespans can be parsed.
Begin restructuring NodaTimeSplitterTest to use data providers
2025-02-21 10:31:21 +01:00
*
* @return void
*/
public function testSpecialCasesForTimespans():void {
Rewrite incomplete time span spellings to extend parsable and splittable time names
2023-11-20 03:18:02 +01:00
Fix broken time splitting for year ranges BC
2024-05-04 01:17:33 +02:00
// Rewritten / 1950-60-as évek
$output = NodaTimeSplitter::attempt_splitting("1400-1100 v. Chr.");
Add additional assertion to NodaTimeSplitterTest for more thorough type safety
2024-05-05 22:54:33 +02:00
self::assertNotEmpty($output);
Fix broken time splitting for year ranges BC
2024-05-04 01:17:33 +02:00
self::assertEquals('-1400', $output->start_year);
self::assertEquals('-1400-01-01', $output->start_date);
Ensure duplicate time names can be parsed in NodaTimeSplitter (e.g. 1.1.2024-1.1.2024)
2024-11-20 10:02:10 +01:00
// Same start as end with day
$output = NodaTimeSplitter::attempt_splitting("11.10.1991-11.10.1991");
self::assertNotEmpty($output);
self::assertEquals('1991', $output->start_year);
self::assertEquals('1991-10-11', $output->start_date);
self::assertEquals('1991', $output->end_year);
self::assertEquals('1991-10-11', $output->end_date);
Rewrite incomplete time span spellings to extend parsable and splittable time names
2023-11-20 03:18:02 +01:00
}
Add tests for splitting Hungarian dates
2020-09-26 14:15:15 +02:00
/**
* Test to check whether the HTML page is correctly generated.
*
* @author Joshua Ramon Enslin <joshua@museum-digital.de>
* @group ValidOutput
Add autoloader for tests, phpunit config
2023-11-06 23:46:30 +01:00
* @small
Add tests for splitting Hungarian dates
2020-09-26 14:15:15 +02:00
*
Begin restructuring NodaTimeSplitterTest to use data providers
2025-02-21 10:31:21 +01:00
* @param string $unsplittable_name Name that the time splitter should not
* be able to split.
*
Add tests for splitting Hungarian dates
2020-09-26 14:15:15 +02:00
* @return void
*/
Begin restructuring NodaTimeSplitterTest to use data providers
2025-02-21 10:31:21 +01:00
#[DataProvider('nonSplittableNamesProvider')]
public function testSplitDoesNotWorkWhenItShouldNot(string $unsplittable_name):void {
Fix edge cases in time splitter where inputs start with many digits but are not dates
2023-11-07 00:27:20 +01:00
Begin restructuring NodaTimeSplitterTest to use data providers
2025-02-21 10:31:21 +01:00
$output = NodaTimeSplitter::attempt_splitting($unsplittable_name);
self::assertEmpty($output, "Time name $unsplittable_name should not be split. It was split into:" . PHP_EOL . PHP_EOL . var_export($output, true));
Add tests for German dates, enable splitting of 5 digit timespans
2020-09-26 15:10:06 +02:00
Add tests for splitting Hungarian dates
2020-09-26 14:15:15 +02:00
}
}
Reference in New Issue Copy Permalink