ConvertModuleToPoToolTest.php

Go to the documentation of this file.

<?php
 
declare(strict_types=1);
 
use ILIAS\Language\ComponentTranslation\Catalog\TranslationCatalog;
use PHPUnit\Framework\Attributes\DataProvider;
use PHPUnit\Framework\TestCase;
 
class ConvertModuleToPoToolTest extends TestCase
{
    private const string TOOL = __DIR__ . '/../tools/po-migration/convert_module_to_po.php';
 
    private string $directory;
 
    protected function setUp(): void
    {
        // the tool prints resolved paths: macOS /var is a link, FreeBSD's temp dir ends with a slash
        $this->directory = (string) realpath(sys_get_temp_dir()) . '/ilias_convert_tool_' . bin2hex(random_bytes(4));
        mkdir($this->directory . '/out', 0775, true);
    }
 
    protected function tearDown(): void
    {
        MigratedPoFixture::removeDirectory($this->directory);
    }
 
    private function runTool(string ...$arguments): array
    {
        return $this->runToolAt(self::TOOL, ...$arguments);
    }
 
    private function runToolAt(string $tool_path, string ...$arguments): array
    {
        $result = ChildPhp::run(
            ['-d', 'error_reporting=-1', '-d', 'display_errors=stderr', $tool_path, ...$arguments]
        );
        $this->assertNotNull($result, 'could not start the child PHP process');
 
        return $result;
    }
 
    private function buildFixtureRepo(): string
    {
        $root = $this->directory . '/repo';
        $tool_dir = $root . '/components/ILIAS/Language/tools/po-migration';
        mkdir($tool_dir, 0775, true);
        mkdir($root . '/lang', 0775, true);
        mkdir($root . '/out', 0775, true);
        copy(self::TOOL, $tool_dir . '/convert_module_to_po.php');
 
        mkdir($root . '/vendor/composer/vendor', 0775, true);
        $real_autoload = realpath(__DIR__ . '/../../../../vendor/composer/vendor/autoload.php');
        $this->assertIsString($real_autoload, 'the real Composer autoloader was not found');
        symlink($real_autoload, $root . '/vendor/composer/vendor/autoload.php');
 
        return $root;
    }
 
    private function toolPathOf(string $fixture_root): string
    {
        return $fixture_root . '/components/ILIAS/Language/tools/po-migration/convert_module_to_po.php';
    }
 
    private function writePluralsConfig(string $fixture_root, array $plural_forms, array $modules): void
    {
        file_put_contents(
            $fixture_root . '/components/ILIAS/Language/tools/po-migration/plurals.json',
            (string) json_encode(['plural_forms' => $plural_forms, 'modules' => $modules], JSON_THROW_ON_ERROR)
        );
    }
 
    private function writeLangFile(string $fixture_root, string $lang_key, string $content): void
    {
        if (!str_contains($content, self::START)) {
            $content = self::START . "\n" . $content;
        }
        file_put_contents($fixture_root . '/lang/ilias_' . $lang_key . '.lang', $content);
    }
 
    private static function files(string $directory): array
    {
        $files = [];
        foreach (glob($directory . '/*.{po,pot}', GLOB_BRACE) ?: [] as $file) {
            $files[basename($file)] = (string) file_get_contents($file);
        }
        ksort($files);
 
        return $files;
    }
 
    public function testFailsWithExitOneAndWritesNothingWhenALanguageHasAKeyMissingFromTheReferenceLanguage(): void
    {
        $root = $this->buildFixtureRepo();
        $this->writeLangFile($root, 'de', "tst#:#greeting#:#Hallo\n");
        $this->writeLangFile($root, 'fr', "tst#:#greeting#:#Bonjour\ntst#:#extra#:#En trop\n");
 
        [$exit_code, $stdout, $stderr] = $this->runToolAt($this->toolPathOf($root), 'tst', 'de', $root . '/out');
 
        $this->assertSame(1, $exit_code, $stdout . $stderr);
        $this->assertStringContainsString("reference language 'de' does not have", $stderr);
        $this->assertStringContainsString('fr: extra', $stderr);
        $this->assertSame([], glob($root . '/out/*') ?: [], 'nothing must be written once an inconsistency was found');
    }
 
    public function testWarnsOnAnExtraHashColonHashInAValueAndUsesOnlyThePartBeforeItLikeTheInstaller(): void
    {
        $root = $this->buildFixtureRepo();
        $this->writeLangFile($root, 'de', "tst#:#greeting#:#Hallo#:#Extra\n");
 
        [$exit_code, $stdout, $stderr] = $this->runToolAt($this->toolPathOf($root), 'tst', 'de', $root . '/out');
 
        $this->assertSame(0, $exit_code, $stdout . $stderr);
        $this->assertStringContainsString(
            'contains "#:#" in its value - only the part before it is used, like the installer does.',
            $stderr
        );
        $catalog = \ILIAS\Language\ComponentTranslation\Catalog\TranslationCatalog::fromPoFile($root . '/out/tst_de.po');
        $entry = $catalog->find(null, 'greeting');
        $this->assertNotNull($entry);
        $this->assertSame('Hallo', $entry->getTranslation());
    }
 
    public function testANoteThatMerelyMentionsNewVariableStaysANoteAndIsNotMarkedFuzzy(): void
    {
        $root = $this->buildFixtureRepo();
        $note = 'Bitte pruefen, ob hier evtl. eine neue Variable (englisch: new variable) gemeint war';
        $this->writeLangFile($root, 'de', "tst#:#greeting#:#Hallo###$note\n");
 
        [$exit_code, $stdout, $stderr] = $this->runToolAt($this->toolPathOf($root), 'tst', 'de', $root . '/out');
 
        $this->assertSame(0, $exit_code, $stdout . $stderr);
        $catalog = \ILIAS\Language\ComponentTranslation\Catalog\TranslationCatalog::fromPoFile($root . '/out/tst_de.po');
        $entry = $catalog->find(null, 'greeting');
        $this->assertNotNull($entry);
        $this->assertFalse($entry->hasFlag('fuzzy'));
        $this->assertSame([$note], $entry->getExtractedComments());
    }
 
    public function testTheDatedNewVariablePlaceholderFormatIsMarkedFuzzyNotKeptAsANote(): void
    {
        $root = $this->buildFixtureRepo();
        $this->writeLangFile($root, 'de', "tst#:#greeting#:#Hallo\n");
        $this->writeLangFile($root, 'fr', "tst#:#greeting#:####13 3 2019 new variable\n");
 
        [$exit_code, $stdout, $stderr] = $this->runToolAt($this->toolPathOf($root), 'tst', 'de', $root . '/out');
 
        $this->assertSame(0, $exit_code, $stdout . $stderr);
        $catalog = \ILIAS\Language\ComponentTranslation\Catalog\TranslationCatalog::fromPoFile($root . '/out/tst_fr.po');
        $entry = $catalog->find(null, 'greeting');
        $this->assertNotNull($entry);
        $this->assertTrue($entry->hasFlag('fuzzy'));
        $this->assertSame([], $entry->getExtractedComments());
    }
 
    public function testAMissingOrEmptyValueGetsTheReferenceValueFlaggedFuzzy(): void
    {
        $root = $this->buildFixtureRepo();
        $this->writeLangFile($root, 'en', "tst#:#greeting#:#Hello\ntst#:#bye#:#Bye\ntst#:#none#:#\n");
        $this->writeLangFile($root, 'de', "tst#:#greeting#:#Hallo\n");
        $this->writeLangFile($root, 'fr', "tst#:#greeting#:####Bitte uebersetzen\ntst#:#bye#:#Salut\n");
 
        [$exit_code, $stdout, $stderr] = $this->runToolAt($this->toolPathOf($root), 'tst');
 
        $this->assertSame(0, $exit_code, $stdout . $stderr);
        $out = dirname($this->toolPathOf($root)) . '/output/tst';
        $pot = \ILIAS\Language\ComponentTranslation\Catalog\TranslationCatalog::fromPoFile($out . '/tst.pot');
        $this->assertSame(['greeting', 'bye', 'none'], array_map(static fn($e): string => $e->getId(), $pot->getEntries()), 'msgids from en');
 
        $de = \ILIAS\Language\ComponentTranslation\Catalog\TranslationCatalog::fromPoFile($out . '/tst_de.po');
        $this->assertSame('Hallo', $de->find(null, 'greeting')?->getTranslation());
        $this->assertFalse($de->find(null, 'greeting')->hasFlag('fuzzy'));
        $this->assertSame('Bye', $de->find(null, 'bye')?->getTranslation(), 'no line: the en value');
        $this->assertTrue($de->find(null, 'bye')->hasFlag('fuzzy'));
        $this->assertSame('', $de->find(null, 'none')?->getTranslation(), 'an empty en value fills nothing');
        $this->assertFalse($de->find(null, 'none')->hasFlag('fuzzy'));
 
        $fr = \ILIAS\Language\ComponentTranslation\Catalog\TranslationCatalog::fromPoFile($out . '/tst_fr.po');
        $this->assertSame('Hello', $fr->find(null, 'greeting')?->getTranslation(), 'empty value: the en value');
        $this->assertTrue($fr->find(null, 'greeting')->hasFlag('fuzzy'));
        $this->assertSame(['Bitte uebersetzen'], $fr->find(null, 'greeting')->getTranslatorComments());
        $this->assertSame([], $fr->find(null, 'greeting')->getExtractedComments());
        $this->assertFalse($fr->find(null, 'bye')?->hasFlag('fuzzy'));
 
        $this->assertMatchesRegularExpression('/^de\s+1\s+0\s+1\s+yes$/m', $stdout);
        $this->assertMatchesRegularExpression('/^en\s+3\s+0\s+0\s+yes$/m', $stdout);
        $this->assertMatchesRegularExpression('/^fr\s+2\s+0\s+1\s+yes$/m', $stdout);
        $this->assertStringContainsString("(2 entries filled from 'en', flagged fuzzy)", $stdout);
    }
 
    public function testAMissingPluralMessageGetsTheReferenceValuesFlaggedFuzzy(): void
    {
        $root = $this->buildFixtureRepo();
        $this->writeLangFile($root, 'en', "tst#:#item#:#Entries\ntst#:#item_singular#:#One entry\n");
        $this->writeLangFile($root, 'de', "tst#:#item#:#Eintraege\n");
        $this->writeLangFile($root, 'fr', "tst#:#item_singular#:#Une entree\n");
        $this->writePluralsConfig(
            $root,
            ['en' => 'nplurals=2; plural=(n != 1);', 'de' => 'nplurals=2; plural=(n != 1);', 'fr' => 'nplurals=2; plural=(n > 1);'],
            ['tst' => ['item' => ['singular' => 'item_singular']]]
        );
 
        [$exit_code, $stdout, $stderr] = $this->runToolAt($this->toolPathOf($root), 'tst', 'en', $root . '/out');
 
        $this->assertSame(0, $exit_code, $stdout . $stderr);
        $de_item = \ILIAS\Language\ComponentTranslation\Catalog\TranslationCatalog::fromPoFile($root . '/out/tst_de.po')->find(null, 'item');
        $this->assertSame(['Eintraege', 'Eintraege'], $de_item?->getPluralTranslations(), 'the singular key filled from the reference language is not taken over');
        $this->assertFalse($de_item->hasFlag('fuzzy'), 'de: a source language, its own value is present');
        $fr_item = \ILIAS\Language\ComponentTranslation\Catalog\TranslationCatalog::fromPoFile($root . '/out/tst_fr.po')->find(null, 'item');
        $this->assertSame(['Entries', 'Entries'], $fr_item?->getPluralTranslations(), 'the en value in every form');
        $this->assertTrue($fr_item->hasFlag('fuzzy'));
        $this->assertStringContainsString('round-trip identically through PO', $stdout);
    }
 
    public function testAPluralMessageIsMarkedFuzzyWhenItsSingularKeyIsButOnlyWhereTheSingularValueIsActuallyUsed(): void
    {
        $root = $this->buildFixtureRepo();
        $this->writeLangFile($root, 'de', "tst#:#item#:#Eintraege\ntst#:#item_singular#:#Ein Eintrag\n");
        $this->writeLangFile(
            $root,
            'fr',
            "tst#:#item#:#Des entrees\ntst#:#item_singular#:#Une entree###13 3 2019 new variable\n"
        );
        $this->writeLangFile(
            $root,
            'zh',
            "tst#:#item#:#Eintraege ZH\ntst#:#item_singular#:#Ein Eintrag ZH###13 3 2019 new variable\n"
        );
        $this->writePluralsConfig(
            $root,
            [
                'de' => 'nplurals=2; plural=(n != 1);',
                'fr' => 'nplurals=2; plural=(n != 1);',
                'zh' => 'nplurals=1; plural=0;',
            ],
            ['tst' => ['item' => ['singular' => 'item_singular']]]
        );
 
        [$exit_code, $stdout, $stderr] = $this->runToolAt($this->toolPathOf($root), 'tst', 'de', $root . '/out');
 
        $this->assertSame(0, $exit_code, $stdout . $stderr);
        $fr_item = \ILIAS\Language\ComponentTranslation\Catalog\TranslationCatalog::fromPoFile($root . '/out/tst_fr.po')
            ->find(null, 'item');
        $this->assertNotNull($fr_item);
        $this->assertSame(['Des entrees', 'Des entrees'], $fr_item->getPluralTranslations(), 'a fuzzy singular key is not taken over');
        $this->assertTrue($fr_item->hasFlag('fuzzy'), 'fr: the own value is copied into both forms');
 
        $zh_item = \ILIAS\Language\ComponentTranslation\Catalog\TranslationCatalog::fromPoFile($root . '/out/tst_zh.po')
            ->find(null, 'item');
        $this->assertNotNull($zh_item);
        $this->assertSame(['Eintraege ZH'], $zh_item->getPluralTranslations(), 'precondition: single form, own value - not the singular key');
        $this->assertFalse($zh_item->hasFlag('fuzzy'), 'zh: the singular key is never used here, so its fuzziness must not leak in');
    }
 
    public function testAPluralMessageWithoutASingularKeyIsFuzzyOnlyInATranslationWithSeveralForms(): void
    {
        $root = $this->buildFixtureRepo();
        $this->writeLangFile($root, 'de', "tst#:#multi#:#Mehrere Werte\n");
        $this->writeLangFile($root, 'fr', "tst#:#multi#:#Plusieurs valeurs\n");
        $this->writeLangFile($root, 'zh', "tst#:#multi#:#Mehrere Werte ZH\n");
        $this->writePluralsConfig(
            $root,
            ['de' => 'nplurals=2; plural=(n != 1);', 'fr' => 'nplurals=2; plural=(n > 1);', 'zh' => 'nplurals=1; plural=0;'],
            ['tst' => ['multi' => []]]
        );
 
        [$exit_code, $stdout, $stderr] = $this->runToolAt($this->toolPathOf($root), 'tst', 'de', $root . '/out');
 
        $this->assertSame(0, $exit_code, $stdout . $stderr);
        $de_multi = \ILIAS\Language\ComponentTranslation\Catalog\TranslationCatalog::fromPoFile($root . '/out/tst_de.po')
            ->find(null, 'multi');
        $this->assertNotNull($de_multi);
        $this->assertSame(['Mehrere Werte', 'Mehrere Werte'], $de_multi->getPluralTranslations());
        $this->assertFalse($de_multi->hasFlag('fuzzy'), 'de: a source language');
        $fr_multi = \ILIAS\Language\ComponentTranslation\Catalog\TranslationCatalog::fromPoFile($root . '/out/tst_fr.po')
            ->find(null, 'multi');
        $this->assertSame(['Plusieurs valeurs', 'Plusieurs valeurs'], $fr_multi?->getPluralTranslations());
        $this->assertTrue($fr_multi->hasFlag('fuzzy'), 'fr: copied into 2 forms');
 
        $zh_multi = \ILIAS\Language\ComponentTranslation\Catalog\TranslationCatalog::fromPoFile($root . '/out/tst_zh.po')
            ->find(null, 'multi');
        $this->assertNotNull($zh_multi);
        $this->assertSame(['Mehrere Werte ZH'], $zh_multi->getPluralTranslations());
        $this->assertFalse($zh_multi->hasFlag('fuzzy'), 'zh: a single form is not "copied" anywhere');
    }
 
    public function testAFileWithoutALanguageKeyInItsNameIsSkippedWithAWarning(): void
    {
        $root = $this->buildFixtureRepo();
        $this->writeLangFile($root, 'de', "tst#:#greeting#:#Hallo\n");
        file_put_contents($root . '/lang/ilias_ABC.lang', "tst#:#greeting#:#Sollte nicht gelesen werden\n");
 
        [$exit_code, $stdout, $stderr] = $this->runToolAt($this->toolPathOf($root), 'tst', 'de', $root . '/out');
 
        $this->assertSame(0, $exit_code, $stdout . $stderr);
        $this->assertStringContainsString('WARNING: skipping', $stderr);
        $this->assertStringContainsString('ilias_ABC.lang', $stderr);
        $this->assertStringContainsString('no language key in its name', $stderr);
        $this->assertFileDoesNotExist($root . '/out/tst_ABC.po');
    }
 
    public function testLanguageTeamHeaderNamesTheLanguageInEnglishFromTheMetaModule(): void
    {
        $root = $this->buildFixtureRepo();
        $this->writeLangFile($root, 'de', "tst#:#greeting#:#Hallo\n");
        $this->writeLangFile($root, 'en', "tst#:#greeting#:#Hello\nmeta#:#meta_l_de#:#German\nmeta#:#meta_l_en#:#English\n");
        $this->writeLangFile($root, 'fr', "tst#:#greeting#:#Bonjour\n");
 
        [$exit_code, $stdout, $stderr] = $this->runToolAt($this->toolPathOf($root), 'tst', 'de', $root . '/out');
 
        $this->assertSame(0, $exit_code, $stdout . $stderr);
        $de = \ILIAS\Language\ComponentTranslation\Catalog\TranslationCatalog::fromPoFile($root . '/out/tst_de.po');
        $this->assertSame('de', $de->getHeader('Language'));
        $this->assertSame('German', $de->getHeader('Language-Team'));
        $en = \ILIAS\Language\ComponentTranslation\Catalog\TranslationCatalog::fromPoFile($root . '/out/tst_en.po');
        $this->assertSame('English', $en->getHeader('Language-Team'));
        $fr = \ILIAS\Language\ComponentTranslation\Catalog\TranslationCatalog::fromPoFile($root . '/out/tst_fr.po');
        $this->assertNull($fr->getHeader('Language-Team'));
        $this->assertStringContainsString("NOTE: no meta_l_fr in lang/ilias_en.lang", $stdout);
        $pot = \ILIAS\Language\ComponentTranslation\Catalog\TranslationCatalog::fromPoFile($root . '/out/tst.pot');
        $this->assertNull($pot->getHeader('Language-Team'));
    }
 
    public function testCustomPatternNamesThePoFilesAndThePotTemplate(): void
    {
        $root = $this->buildFixtureRepo();
        $this->writeLangFile($root, 'de', "tst#:#greeting#:#Hallo\n");
 
        [$exit_code, $stdout, $stderr] = $this->runToolAt(
            $this->toolPathOf($root),
            '--pattern=ilias_%s',
            'tst',
            'de',
            $root . '/out'
        );
 
        $this->assertSame(0, $exit_code, $stdout . $stderr);
        $this->assertFileExists($root . '/out/ilias_de.po');
        $this->assertFileExists($root . '/out/ilias.pot');
        $this->assertFileDoesNotExist($root . '/out/tst_de.po');
        $this->assertFileDoesNotExist($root . '/out/tst.pot');
        $entry = \ILIAS\Language\ComponentTranslation\Catalog\TranslationCatalog::fromPoFile($root . '/out/ilias_de.po')->find(null, 'greeting');
        $this->assertNotNull($entry);
        $this->assertSame('Hallo', $entry->getTranslation());
    }
 
    public function testAnInvalidPatternFailsWithExitOneAndWritesNothing(): void
    {
        $root = $this->buildFixtureRepo();
        $this->writeLangFile($root, 'de', "tst#:#greeting#:#Hallo\n");
 
        [$exit_code, $stdout, $stderr] = $this->runToolAt(
            $this->toolPathOf($root),
            '--pattern=no-placeholder-at-all',
            'tst',
            'de',
            $root . '/out'
        );
 
        $this->assertSame(1, $exit_code, $stdout . $stderr);
        $this->assertStringContainsString('not a valid file name pattern', $stderr);
        $this->assertSame([], glob($root . '/out/*') ?: [], 'nothing must be written for an invalid pattern');
    }
 
    private const string START = "<!-- language file start -->";
 
    private static function contribution(string $module, string $further_arguments = ''): string
    {
        return '$contribute[LanguageFileDirectory::class] = fn() => '
            . "new ComponentLanguageFileDirectory(\$this, '$module'$further_arguments);";
    }
 
    private static function componentSource(string $code): string
    {
        return "<?php\n\nclass Comp\n{\n    public function init(array &\$contribute): void\n    {\n        $code\n    }\n}\n";
    }
 
    private function addComponent(string $root, ?string $source, string $vendor = 'ILIAS'): string
    {
        $directory = $root . '/components/' . $vendor . '/Comp';
        mkdir($directory . '/lang', 0775, true);
        if ($source !== null) {
            file_put_contents($directory . '/Comp.php', $source);
        }
 
        return $directory . '/lang';
    }
 
    private function addRegisteredComponent(string $root, string $module): string
    {
        return $this->addComponent($root, self::componentSource(self::contribution($module)));
    }
 
    private static function langSnapshot(string $root): array
    {
        clearstatcache();
        $snapshot = [];
        foreach (glob($root . '/lang/*') ?: [] as $file) {
            $snapshot[basename($file)] = [(string) file_get_contents($file), fileperms($file)];
        }
        ksort($snapshot);
 
        return $snapshot;
    }
 
    private static function idsOf(string $file): array
    {
        return array_map(
            static fn($entry): string => $entry->getId(),
            TranslationCatalog::fromPoFile($file)->getEntries()
        );
    }
 
    public static function failureProvider(): array
    {
        return [
            'key missing from the reference language' => [
                ['de' => "tst#:#a#:#A\n", 'fr' => "tst#:#a#:#B\ntst#:#x#:#X\n"], [], 'fr: x',
            ],
            'empty key in the reference language' => [
                ['de' => "tst#:#a#:#A\ntst#:##:#E\n"], [], 'de: "" (empty key)',
            ],
            'identical duplicate without the option' => [
                ['de' => "tst#:#a#:#A\ntst#:#a#:#A\n"], [], 'de: a',
            ],
            'duplicate with different values, also with the option' => [
                ['de' => "tst#:#a#:#A\ntst#:#a#:#B\n"], ['--skip-unmigratable-keys'], 'duplicate identifiers',
            ],
            'duplicate differing only in its ### comment, also with the option' => [
                ['de' => "tst#:#a#:#A###x\ntst#:#a#:#A###y\n"], ['--skip-unmigratable-keys'], 'duplicate identifiers',
            ],
            'module without any line (migrated already)' => [
                ['de' => "other#:#a#:#A\n", 'fr' => "other#:#a#:#B\n"], [], 'has no lines in any of the 2 lang/ilias_*.lang files',
            ],
            'control character in a key is shown escaped' => [
                ['de' => "tst#:#a#:#A\n", 'fr' => "tst#:#a#:#B\ntst#:#x\033y#:#X\n"], [], 'fr: x\033y',
            ],
            'unknown option' => [
                ['de' => "tst#:#a#:#A\n"], ['--remove-from-lang-typo'], "unknown option '--remove-from-lang-typo'",
            ],
        ];
    }
 
    #[DataProvider('failureProvider')]
    public function testAFailedRunNeverTouchesALangFileNorWritesAnything(array $files, array $options, string $expected_stderr): void
    {
        $root = $this->buildFixtureRepo();
        $component_lang = $this->addRegisteredComponent($root, 'tst');
        foreach ($files as $lang_key => $content) {
            $this->writeLangFile($root, $lang_key, $content);
        }
        $before = self::langSnapshot($root);
 
        [$exit_code, $stdout, $stderr] = $this->runToolAt(
            $this->toolPathOf($root),
            '--remove-from-lang',
            ...$options,
            ...['tst', 'de', $component_lang]
        );
        $this->assertSame(1, $exit_code, $stdout . $stderr);
        $this->assertStringContainsString($expected_stderr, $stderr);
        $this->assertStringNotContainsString("\033", $stderr);
        $this->assertSame($before, self::langSnapshot($root));
        $this->assertSame([], glob($component_lang . '/*') ?: [], 'nothing written');
 
        [$exit_code, $stdout, $stderr] = $this->runToolAt($this->toolPathOf($root), ...$options, ...['tst', 'de', $root . '/newout']);
        $this->assertSame(1, $exit_code, $stdout . $stderr);
        $this->assertDirectoryDoesNotExist($root . '/newout');
    }
 
    public static function invalidArgumentsProvider(): array
    {
        return [
            'short option' => [['-x', 'tst', 'de']],
            'misspelled long option' => [['--foo', 'tst', 'de']],
            'module with a path' => [['../x', 'de']],
            'reference language with a path' => [['tst', '../de']],
            'a fourth argument' => [['tst', 'de', 'out']],
        ];
    }
 
    #[DataProvider('invalidArgumentsProvider')]
    public function testInvalidArgumentsFailWithExitOneAndWriteNothing(array $arguments): void
    {
        $root = $this->buildFixtureRepo();
        $this->writeLangFile($root, 'de', "tst#:#a#:#A\n");
        $before = self::langSnapshot($root);
 
        [$exit_code, $stdout, $stderr] = $this->runToolAt($this->toolPathOf($root), ...$arguments, ...[$root . '/newout']);
 
        $this->assertSame(1, $exit_code, $stdout . $stderr);
        $this->assertNotSame('', $stderr);
        $this->assertSame($before, self::langSnapshot($root));
        $this->assertDirectoryDoesNotExist($root . '/newout');
        $this->assertDirectoryDoesNotExist($root . '/x');
    }
 
    public function testWithoutTheOptionTheHintNamesItAndWithItEverythingUnmigratableIsReportedAndLeftOut(): void
    {
        $root = $this->buildFixtureRepo();
        $this->writeLangFile($root, 'de', "tst#:#a#:#A\ntst#:#a#:#A\ntst#:##:#leer\ntst#:#k#1#:#V###note\n");
        $this->writeLangFile($root, 'fr', "tst#:#a#:#FA\ntst#:#c#:#C\ntst#:#c#:#C\ntst#:#x#y#:#X\ntst#:#k#1#:#FV\n");
        $before = self::langSnapshot($root);
 
        [$exit_code, , $stderr] = $this->runToolAt($this->toolPathOf($root), 'tst', 'de', $root . '/out');
        $this->assertSame(1, $exit_code);
        $this->assertStringContainsString('--skip-unmigratable-keys', $stderr);
        $this->assertSame([], glob($root . '/out/*') ?: []);
 
        [$exit_code, $stdout, $stderr] = $this->runToolAt($this->toolPathOf($root), '--skip-unmigratable-keys', 'tst', 'de', $root . '/out');
 
        $this->assertSame(0, $exit_code, $stdout . $stderr);
        $this->assertStringContainsString('WARNING', $stderr);
        $this->assertStringContainsString("  de: \"\" (empty key)\n", $stderr);
        $this->assertStringContainsString("  fr: c, x#y\n", $stderr, 'the key with # whole');
        $this->assertStringContainsString("  fr: c\n", $stderr, 'identical duplicate');
        $this->assertStringContainsString("  de: a\n", $stderr);
        $this->assertStringContainsString('round-trip identically', $stdout);
        $this->assertSame(['a', 'k#1'], self::idsOf($root . '/out/tst_de.po'), 'only the migratable keys');
        $this->assertSame(['a', 'k#1'], self::idsOf($root . '/out/tst_fr.po'));
        $this->assertSame('note', TranslationCatalog::fromPoFile($root . '/out/tst_de.po')->find(null, 'k#1')?->getExtractedComments()[0] ?? null);
        $this->assertSame($before, self::langSnapshot($root), 'without --remove-from-lang the .lang files stay');
    }
 
    public function testADuplicateWithDifferentValuesOfAKeyThatIsLeftOutAnywayOnlyWarns(): void
    {
        $root = $this->buildFixtureRepo();
        $this->writeLangFile($root, 'de', "tst#:#a#:#A\n");
        $this->writeLangFile($root, 'fr', "tst#:#a#:#B\ntst#:#x#:#1\ntst#:#x#:#2\n");
 
        [$exit_code, $stdout, $stderr] = $this->runToolAt($this->toolPathOf($root), 'tst', 'de', $root . '/out');
        $this->assertSame(1, $exit_code, $stdout . $stderr);
 
        [$exit_code, $stdout, $stderr] = $this->runToolAt($this->toolPathOf($root), '--skip-unmigratable-keys', 'tst', 'de', $root . '/out');
        $this->assertSame(0, $exit_code, $stdout . $stderr);
        $this->assertStringContainsString('WARNING', $stderr);
        $this->assertStringContainsString("  fr: x\n", $stderr);
        $this->assertSame(['a'], self::idsOf($root . '/out/tst_fr.po'));
    }
 
    public function testTheSingularKeyGoesToTheFormThatServesOnlyOneWhateverItsNumber(): void
    {
        $root = $this->buildFixtureRepo();
        foreach (['de' => ['Eintraege', 'Ein Eintrag'], 'es' => ['Entradas', 'Una entrada'], 'ar' => ['AR viele', 'AR eins']] as $lang_key => [$plural, $singular]) {
            $this->writeLangFile($root, $lang_key, "tst#:#item#:#$plural\ntst#:#item_singular#:#$singular\n");
        }
        $this->writePluralsConfig(
            $root,
            [
                'de' => 'nplurals=2; plural=(n != 1);',
                'es' => 'nplurals=3; plural=(n == 1) ? 0 : ((n != 0 && n % 1000000 == 0) ? 1 : 2);',
                'ar' => 'nplurals=6; plural=(n == 0) ? 0 : ((n == 1) ? 1 : ((n == 2) ? 2 : ((n % 100 >= 3 && n % 100 <= 10) ? 3 : ((n % 100 >= 11 && n % 100 <= 99) ? 4 : 5))));',
            ],
            ['tst' => ['item' => ['singular' => 'item_singular']]]
        );
 
        [$exit_code, $stdout, $stderr] = $this->runToolAt($this->toolPathOf($root), 'tst', 'de', $root . '/out');
 
        $this->assertSame(0, $exit_code, $stdout . $stderr);
        $forms = static fn(string $lang_key): ?array => TranslationCatalog::fromPoFile($root . "/out/tst_$lang_key.po")->find(null, 'item')?->getPluralTranslations();
        $this->assertSame(['Ein Eintrag', 'Eintraege'], $forms('de'));
        $this->assertSame(['Una entrada', 'Entradas', 'Entradas'], $forms('es'));
        $this->assertSame(['AR viele', 'AR eins', 'AR viele', 'AR viele', 'AR viele', 'AR viele'], $forms('ar'));
    }
 
    public function testATranslatedSingularEqualToTheOwnValueIsNotFuzzy(): void
    {
        $root = $this->buildFixtureRepo();
        $this->writeLangFile($root, 'de', "tst#:#item#:#Eintraege\ntst#:#item_singular#:#Ein Eintrag\n");
        $this->writeLangFile($root, 'fr', "tst#:#item#:#Photo\ntst#:#item_singular#:#Photo\n");
        $this->writePluralsConfig(
            $root,
            ['de' => 'nplurals=2; plural=(n != 1);', 'fr' => 'nplurals=2; plural=(n != 1);'],
            ['tst' => ['item' => ['singular' => 'item_singular']]]
        );
 
        [$exit_code, $stdout, $stderr] = $this->runToolAt($this->toolPathOf($root), 'tst', 'de', $root . '/out');
 
        $this->assertSame(0, $exit_code, $stdout . $stderr);
        $item = TranslationCatalog::fromPoFile($root . '/out/tst_fr.po')->find(null, 'item');
        $this->assertSame(['Photo', 'Photo'], $item?->getPluralTranslations());
        $this->assertFalse($item->hasFlag('fuzzy'), 'both forms are translated, they just are equal');
    }
 
    public function testAKeyWithTheSyntaxOfAPluralFormIsRejectedOrLeftOut(): void
    {
        $root = $this->buildFixtureRepo();
        $this->writeLangFile($root, 'de', "tst#:#a#:#A\ntst#:#item [0]#:#Form\n");
 
        [$exit_code, $stdout, $stderr] = $this->runToolAt($this->toolPathOf($root), 'tst', 'de', $root . '/out');
        $this->assertSame(1, $exit_code, $stdout . $stderr);
        $this->assertStringContainsString('FAILURE', $stderr);
        $this->assertStringContainsString('item [0]', $stderr);
        $this->assertSame([], glob($root . '/out/*') ?: [], 'nothing was written');
 
        [$exit_code, $stdout, $stderr] = $this->runToolAt($this->toolPathOf($root), '--skip-unmigratable-keys', 'tst', 'de', $root . '/out');
        $this->assertSame(0, $exit_code, $stdout . $stderr);
        $this->assertStringContainsString('item [0]', $stderr);
        $this->assertSame(['a'], self::idsOf($root . '/out/tst_de.po'));
    }
 
    public function testRemoveFromLangRemovesExactlyTheModulesLinesAndKeepsEveryOtherByte(): void
    {
        $root = $this->buildFixtureRepo();
        $out = $this->addRegisteredComponent($root, 'crs');
        $start = self::START;
        $this->writeLangFile($root, 'de', "# header\n$start\ncrs#:#a#:#A\ncrsr#:#a#:#Other\ncrs#:#b#:#B###c\nxcrs#:#a#:#X\nmeta#:#crs#:#crs#:#M\n");
        $this->writeLangFile($root, 'fr', "# header\r\n$start\r\ncrs#:#a#:#FA\r\ncrs#:#b#:#FB\r\ncrsr#:#a#:#R\r\n");
        $this->writeLangFile($root, 'en', "$start\ncrsr#:#a#:#R\ncrs#:#a#:#EA\ncrs#:#b#:#EB");
        $this->writeLangFile($root, 'es', "crs#:#a#:#SA\ncrs#:#b#:#SB\nkeep#:#k#:#K\n");
        $this->writeLangFile($root, 'it', "$start\nmeta#:#x#:#y\n");
        $this->writeLangFile($root, 'ABC', "$start\ncrs#:#a#:#ignored\n");
        chmod($root . '/lang/ilias_de.lang', 0640);
        $before = self::langSnapshot($root);
 
        [$exit_code, $stdout, $stderr] = $this->runToolAt($this->toolPathOf($root), '--remove-from-lang', 'crs', 'de', $out);
 
        $this->assertSame(0, $exit_code, $stdout . $stderr);
        $after = self::langSnapshot($root);
        $this->assertSame("# header\n$start\ncrsr#:#a#:#Other\nxcrs#:#a#:#X\nmeta#:#crs#:#crs#:#M\n", $after['ilias_de.lang'][0]);
        $this->assertSame("# header\r\n$start\r\ncrsr#:#a#:#R\r\n", $after['ilias_fr.lang'][0]);
        $this->assertSame("$start\ncrsr#:#a#:#R", $after['ilias_en.lang'][0], 'no final line break stays none');
        $this->assertSame("$start\nkeep#:#k#:#K\n", $after['ilias_es.lang'][0]);
        $this->assertSame($before['ilias_it.lang'], $after['ilias_it.lang']);
        $this->assertSame($before['ilias_ABC.lang'], $after['ilias_ABC.lang']);
        $this->assertSame(0640, $after['ilias_de.lang'][1] & 07777);
        $this->assertSame(array_keys($before), array_keys($after), 'no temporary file left behind');
        $this->assertStringContainsString(sprintf("removed %5d line(s) of 'crs' from lang/ilias_de.lang", 2), $stdout);
        $this->assertStringContainsString(sprintf("removed %5d line(s) of 'crs' from lang/ilias_en.lang", 2), $stdout);
        $this->assertStringNotContainsString('ilias_it.lang', $stdout);
        $this->assertFileExists($out . '/crs_de.po');
        $this->assertFileExists($out . '/crs.pot');
    }
 
    public function testRemoveFromLangAlsoRemovesTheLeftOutLines(): void
    {
        $root = $this->buildFixtureRepo();
        $out = $this->addRegisteredComponent($root, 'crs');
        $start = self::START;
        $this->writeLangFile($root, 'de', "$start\ncrs#:#a#:#A\ncrs#:#a#:#A\ncrs#:##:#leer\ncrs#:#b#:#B\nkeep#:#k#:#K\n");
        $this->writeLangFile($root, 'fr', "$start\ncrs#:#a#:#FA\ncrs#:#extra#:#E\nkeep#:#k#:#K2\n");
 
        [$exit_code, $stdout, $stderr] = $this->runToolAt(
            $this->toolPathOf($root),
            '--skip-unmigratable-keys',
            '--remove-from-lang',
            'crs',
            'de',
            $out
        );
 
        $this->assertSame(0, $exit_code, $stdout . $stderr);
        $after = self::langSnapshot($root);
        $this->assertSame("$start\nkeep#:#k#:#K\n", $after['ilias_de.lang'][0]);
        $this->assertSame("$start\nkeep#:#k#:#K2\n", $after['ilias_fr.lang'][0]);
        $this->assertSame(['a', 'b'], self::idsOf($out . '/crs_fr.po'));
    }
 
    public function testALineAboveTheStartMarkerIsNeitherConvertedNorRemoved(): void
    {
        $root = $this->buildFixtureRepo();
        $out = $this->addRegisteredComponent($root, 'crs');
        $start = self::START;
        // the header line would fail twice if it was read: a key the reference language lacks, a Latin-1 byte
        $header = "crs#:#x#:#Kopfzeile \xFC\n";
        $this->writeLangFile($root, 'de', "$start\ncrs#:#a#:#A\ncrs#:#b#:#B\n");
        $this->writeLangFile($root, 'fr', "$header$start\ncrs#:#b#:#FB\n");
 
        [$exit_code, $stdout, $stderr] = $this->runToolAt($this->toolPathOf($root), '--remove-from-lang', 'crs', 'de', $out);
 
        $this->assertSame(0, $exit_code, $stdout . $stderr);
        $after = self::langSnapshot($root);
        $this->assertSame("$header$start\n", $after['ilias_fr.lang'][0]);
        $this->assertSame("$start\n", $after['ilias_de.lang'][0]);
        $ids = self::idsOf($out . '/crs_fr.po');
        sort($ids);
        $this->assertSame(['a', 'b'], $ids, '"x" of the header line is no key');
        $this->assertSame('FB', TranslationCatalog::fromPoFile($out . '/crs_fr.po')->find(null, 'b')?->getTranslation());
    }
 
    public function testAFileWithoutTheStartMarkerIsSkippedAndRefusedByRemoveFromLang(): void
    {
        $root = $this->buildFixtureRepo();
        $out = $this->addRegisteredComponent($root, 'crs');
        $this->writeLangFile($root, 'de', self::START . "\ncrs#:#a#:#A\n");
        file_put_contents($root . '/lang/ilias_fr.lang', "crs#:#a#:#FA\ncrs#:#x#:#X\n");
        $before = self::langSnapshot($root);
 
        [$exit_code, $stdout, $stderr] = $this->runToolAt($this->toolPathOf($root), '--remove-from-lang', 'crs', 'de', $out);
 
        $this->assertSame(1, $exit_code, $stdout . $stderr);
        $this->assertStringContainsString('ilias_fr.lang', $stderr);
        $this->assertStringContainsString('nothing was written', $stderr);
        $this->assertSame($before, self::langSnapshot($root));
        $this->assertSame([], glob($out . '/*') ?: []);
 
        [$exit_code, $stdout, $stderr] = $this->runToolAt($this->toolPathOf($root), 'crs', 'de', $root . '/out');
 
        $this->assertSame(0, $exit_code, $stdout . $stderr);
        $this->assertStringContainsString('WARNING: skipping ' . $root . '/lang/ilias_fr.lang', $stderr);
        $this->assertFileDoesNotExist($root . '/out/crs_fr.po', '"x" would have failed the run if the file was read');
        $this->assertSame($before, self::langSnapshot($root));
    }
 
    public function testALatinOneLangFileFailsTheRunAndKeepsPoAndLangFilesByteIdentical(): void
    {
        $root = $this->buildFixtureRepo();
        $out = $this->addRegisteredComponent($root, 'crs');
        $start = self::START;
        $this->writeLangFile($root, 'de', "$start\ncrs#:#a#:#Gr\xC3\xBC\xC3\x9Fe\n");
        $this->writeLangFile($root, 'fr', "$start\ncrs#:#a#:#Gr\xFC\xDFe\n");
        file_put_contents($out . '/crs_de.po', "existing de\n");
        file_put_contents($out . '/crs_fr.po', "existing fr\n");
        file_put_contents($out . '/crs.pot', "existing pot\n");
        $lang_before = self::langSnapshot($root);
        $out_before = self::files($out);
 
        [$exit_code, $stdout, $stderr] = $this->runToolAt($this->toolPathOf($root), '--remove-from-lang', 'crs', 'de', $out);
 
        $this->assertSame(1, $exit_code, $stdout . $stderr);
        $this->assertStringContainsString('not valid UTF-8', $stderr);
        $this->assertStringContainsString('fr: a', $stderr);
        $this->assertSame($lang_before, self::langSnapshot($root));
        $this->assertSame($out_before, self::files($out));
    }
 
    public function testAnUnreadableExistingPoIsWarnedAboutAndReplaced(): void
    {
        $root = $this->buildFixtureRepo();
        $this->writeLangFile($root, 'de', "crs#:#a#:#A\n");
        file_put_contents($root . '/out/crs_de.po', "msgid \"kaputt\n");
 
        [$exit_code, $stdout, $stderr] = $this->runToolAt($this->toolPathOf($root), 'crs', 'de', $root . '/out');
 
        $this->assertSame(0, $exit_code, $stdout . $stderr);
        $this->assertStringContainsString('WARNING: the existing ' . $root . '/out/crs_de.po is not readable', $stderr);
        $this->assertSame(['a'], self::idsOf($root . '/out/crs_de.po'));
    }
 
    public function testAMissingOutputDirFailsAndIsNotCreated(): void
    {
        $root = $this->buildFixtureRepo();
        $this->writeLangFile($root, 'de', "crs#:#a#:#A\n");
 
        [$exit_code, $stdout, $stderr] = $this->runToolAt($this->toolPathOf($root), 'crs', 'de', $root . '/typo/lang');
 
        $this->assertSame(1, $exit_code, $stdout . $stderr);
        $this->assertStringContainsString("outputDir '$root/typo/lang' does not exist. Nothing was written.", $stderr);
        $this->assertDirectoryDoesNotExist($root . '/typo');
    }
 
    public function testAValueWithMarkupIsKeptUnlessTheBuildWouldCleanItToNothing(): void
    {
        $root = $this->buildFixtureRepo();
        $this->writeLangFile(
            $root,
            'en',
            "tst#:#role#:#ILIAS role name\ntst#:#bad#:#Bad <b onclick=\"x\">en</b>\ntst#:#open#:#Open\ntst#:#none#:#\n"
        );
        $this->writeLangFile(
            $root,
            'it',
            "tst#:#role#:#<nome del Ruolo ILIAS\ntst#:#bad#:#Male\ntst#:#open#:#Apri <a href=\"x\">qui\ntst#:#none#:#<niente\n"
        );
 
        [$exit_code, $stdout, $stderr] = $this->runToolAt($this->toolPathOf($root), 'tst', 'en', $root . '/out');
 
        $this->assertSame(0, $exit_code, $stdout . $stderr);
        $this->assertStringContainsString("empty once cleaned, replaced by the reference value (fuzzy):\n  it: role (", $stderr);
        $this->assertStringContainsString("empty once cleaned, left empty like a missing value:\n  it: none (", $stderr);
        $this->assertMatchesRegularExpression('/kept, the build cleans it:\n(  .*\n)*  en: bad \‍(/', $stderr);
        $this->assertMatchesRegularExpression('/kept, the build cleans it:\n(  .*\n)*  it: open \‍(/', $stderr);
        $it = \ILIAS\Language\ComponentTranslation\Catalog\TranslationCatalog::fromPoFile($root . '/out/tst_it.po');
        $this->assertSame('ILIAS role name', $it->find(null, 'role')?->getTranslation());
        $this->assertTrue($it->find(null, 'role')->hasFlag('fuzzy'));
        $this->assertSame('Apri <a href="x">qui', $it->find(null, 'open')?->getTranslation(), 'kept, the build cleans it');
        $this->assertFalse($it->find(null, 'open')->hasFlag('fuzzy'));
        $this->assertSame('', $it->find(null, 'none')?->getTranslation());
        $this->assertFalse($it->find(null, 'none')->hasFlag('fuzzy'));
        $this->assertSame('Male', $it->find(null, 'bad')?->getTranslation());
        $this->assertFalse($it->find(null, 'bad')->hasFlag('fuzzy'));
        $this->assertMatchesRegularExpression('/^it\s+4\s+0\s+1\s+yes$/m', $stdout);
        $en = \ILIAS\Language\ComponentTranslation\Catalog\TranslationCatalog::fromPoFile($root . '/out/tst_en.po');
        $this->assertSame('Bad <b onclick="x">en</b>', $en->find(null, 'bad')?->getTranslation(), 'the reference value is kept');
        $this->assertFalse($en->find(null, 'bad')->hasFlag('fuzzy'));
    }
 
    public function testMarkupOfTheSingularKeyInAPluralFormPassesTheSelfCheck(): void
    {
        $root = $this->buildFixtureRepo();
        $this->writeLangFile($root, 'en', "tst#:#item#:#Items\ntst#:#item_singular#:#One <b>item\n");
        $this->writeLangFile($root, 'de', "tst#:#item#:#Eintraege\ntst#:#item_singular#:#Ein <b>Eintrag\n");
        $this->writePluralsConfig(
            $root,
            ['en' => 'nplurals=2; plural=(n != 1);', 'de' => 'nplurals=2; plural=(n != 1);'],
            ['tst' => ['item' => ['singular' => 'item_singular']]]
        );
 
        [$exit_code, $stdout, $stderr] = $this->runToolAt($this->toolPathOf($root), 'tst', 'en', $root . '/out');
 
        $this->assertSame(0, $exit_code, $stdout . $stderr);
        foreach (['en' => ['One <b>item', 'Items'], 'de' => ['Ein <b>Eintrag', 'Eintraege']] as $lang_key => $forms) {
            $item = \ILIAS\Language\ComponentTranslation\Catalog\TranslationCatalog::fromPoFile($root . "/out/tst_$lang_key.po")
                ->find(null, 'item');
            $this->assertSame($forms, $item?->getPluralTranslations(), $lang_key);
        }
    }
 
    public function testFuzzyMarkerBehindFourHashesIsFuzzyAndTwoHashesStayInTheValue(): void
    {
        $root = $this->buildFixtureRepo();
        $this->writeLangFile($root, 'en', "tst#:#a#:#A\ntst#:#b#:#B\n");
        $this->writeLangFile($root, 'sv', "tst#:#a#:#Ä####24 10 2013 new variable\ntst#:#b#:#Bb##24 10 2013 new variable\n");
 
        [$exit_code, $stdout, $stderr] = $this->runToolAt($this->toolPathOf($root), 'tst', 'en', $root . '/out');
 
        $this->assertSame(0, $exit_code, $stdout . $stderr);
        $sv = \ILIAS\Language\ComponentTranslation\Catalog\TranslationCatalog::fromPoFile($root . '/out/tst_sv.po');
        $this->assertTrue($sv->find(null, 'a')?->hasFlag('fuzzy'));
        $this->assertSame([], $sv->find(null, 'a')->getTranslatorComments());
        $this->assertFalse($sv->find(null, 'b')?->hasFlag('fuzzy'));
        $this->assertSame('Bb##24 10 2013 new variable', $sv->find(null, 'b')->getTranslation());
    }
 
    public function testAnOwnNoteIsATranslatorCommentAndTheReferenceNoteAnExtractedOne(): void
    {
        $root = $this->buildFixtureRepo();
        $this->writeLangFile($root, 'en', "tst#:#a#:#A###en note\ntst#:#b#:#B###same note\n");
        $this->writeLangFile($root, 'sv', "tst#:#a#:#Ä###egen anteckning\ntst#:#b#:#Bb###same note\n");
 
        [$exit_code, $stdout, $stderr] = $this->runToolAt($this->toolPathOf($root), 'tst', 'en', $root . '/out');
 
        $this->assertSame(0, $exit_code, $stdout . $stderr);
        $pot = \ILIAS\Language\ComponentTranslation\Catalog\TranslationCatalog::fromPoFile($root . '/out/tst.pot');
        $this->assertSame(['en note'], $pot->find(null, 'a')?->getExtractedComments());
        $en = \ILIAS\Language\ComponentTranslation\Catalog\TranslationCatalog::fromPoFile($root . '/out/tst_en.po');
        $this->assertSame([], $en->find(null, 'a')?->getTranslatorComments());
        $this->assertSame(['en note'], $en->find(null, 'a')->getExtractedComments());
        $sv = \ILIAS\Language\ComponentTranslation\Catalog\TranslationCatalog::fromPoFile($root . '/out/tst_sv.po');
        $this->assertSame(['egen anteckning'], $sv->find(null, 'a')?->getTranslatorComments());
        $this->assertSame(['en note'], $sv->find(null, 'a')->getExtractedComments());
        $this->assertSame([], $sv->find(null, 'b')?->getTranslatorComments(), 'a note equal to the reference note is not repeated');
    }
 
    public static function runsWithoutAModule(): array
    {
        return [
            'no argument' => [[]],
            'only options' => [['--skip-unmigratable-keys']],
        ];
    }
 
    #[DataProvider('runsWithoutAModule')]
    public function testARunWithoutAModuleFailsAndWritesNothing(array $arguments): void
    {
        $root = $this->buildFixtureRepo();
        $this->writeLangFile($root, 'en', self::START . "\ntos#:#a#:#A\n");
        $before = self::langSnapshot($root);
 
        [$exit_code, $stdout, $stderr] = $this->runToolAt($this->toolPathOf($root), ...$arguments);
 
        $this->assertSame(1, $exit_code, $stdout . $stderr);
        $this->assertStringContainsString('the module is required', $stderr);
        $this->assertSame($before, self::langSnapshot($root));
        $this->assertSame([], glob($root . '/out/*') ?: []);
    }
 
    public function testASecondRunForAMigratedModuleFailsAndKeepsThePoFilesByteIdentical(): void
    {
        $root = $this->buildFixtureRepo();
        $out = $this->addRegisteredComponent($root, 'crs');
        $this->writeLangFile($root, 'de', self::START . "\ncrs#:#a#:#A\n");
        $this->writeLangFile($root, 'fr', self::START . "\ncrs#:#a#:#FA\n");
        [$exit_code, $stdout, $stderr] = $this->runToolAt($this->toolPathOf($root), '--remove-from-lang', 'crs', 'de', $out);
        $this->assertSame(0, $exit_code, $stdout . $stderr);
        $po_files = self::files($out);
        $this->assertCount(3, $po_files);
        $lang_files = self::langSnapshot($root);
 
        [$exit_code, $stdout, $stderr] = $this->runToolAt($this->toolPathOf($root), '--remove-from-lang', 'crs', 'de', $out);
 
        $this->assertSame(1, $exit_code, $stdout . $stderr);
        $this->assertStringContainsString('has no lines in any of the 2 lang/ilias_*.lang files', $stderr);
        $this->assertStringContainsString('most likely it is migrated already', $stderr);
        $this->assertSame($po_files, self::files($out));
        $this->assertSame($lang_files, self::langSnapshot($root));
    }
 
    public static function refusedTargetProvider(): array
    {
        $registered = self::componentSource(self::contribution('tst'));
 
        return [
            'no outputDir' => [null, $registered, [], 'the outputDir argument is required'],
            'outputDir does not exist' => ['{root}/components/ILIAS/Comp/missing', $registered, [], 'does not exist'],
            'outputDir outside of components' => ['{root}/out', $registered, [], 'is not components/<Vendor>/<Component>/lang'],
            'outputDir is the component, not its lang/' => ['{root}/components/ILIAS/Comp', $registered, [], 'is not components/<Vendor>/<Component>/lang'],
            'component class missing' => ['{root}/components/ILIAS/Comp/lang', null, [], 'Comp.php was not found'],
            'contribution only in a comment' => [
                '{root}/components/ILIAS/Comp/lang',
                self::componentSource("// " . self::contribution('tst') . "\n        /* " . self::contribution('tst') . ' */'),
                [],
                "contributes no ComponentLanguageFileDirectory for module 'tst'",
            ],
            'contribution for another module' => [
                '{root}/components/ILIAS/Comp/lang',
                self::componentSource(self::contribution('tstx')),
                [],
                "contributes no ComponentLanguageFileDirectory for module 'tst'",
            ],
            'contributed path is not lang/' => [
                '{root}/components/ILIAS/Comp/lang',
                self::componentSource(self::contribution('tst', ", 'translations/'")),
                [],
                "from 'translations/', not from lang/",
            ],
            'contributed pattern differs from the contribution default' => [
                '{root}/components/ILIAS/Comp/lang',
                self::componentSource(self::contribution('tst', ", 'lang/', 'x_%s'")),
                [],
                "pattern 'x_%s', but the run uses 'tst_%s'",
            ],
            '--pattern differs from the contribution' => [
                '{root}/components/ILIAS/Comp/lang',
                $registered,
                ['--pattern=ilias_%s'],
                "but the run uses 'ilias_%s'",
            ],
        ];
    }
 
    #[DataProvider('refusedTargetProvider')]
    public function testRemoveFromLangRefusesATargetThatTheInstallationWouldNotReadAndWritesNothing(
        ?string $output,
        ?string $component_source,
        array $options,
        string $expected_stderr
    ): void {
        $root = $this->buildFixtureRepo();
        $component_lang = $this->addComponent($root, $component_source);
        $this->writeLangFile($root, 'de', self::START . "\ntst#:#a#:#A\n");
        $this->writeLangFile($root, 'fr', self::START . "\ntst#:#a#:#FA\n");
        $before = self::langSnapshot($root);
        $arguments = ['tst', 'de', ...($output === null ? [] : [str_replace('{root}', $root, $output)])];
 
        [$exit_code, $stdout, $stderr] = $this->runToolAt($this->toolPathOf($root), '--remove-from-lang', ...$options, ...$arguments);
 
        $this->assertSame(1, $exit_code, $stdout . $stderr);
        $this->assertStringContainsString($expected_stderr, $stderr);
        $this->assertStringContainsString('Nothing was written.', $stderr);
        $this->assertSame($before, self::langSnapshot($root));
        $this->assertSame([], glob($component_lang . '/*') ?: []);
        $this->assertSame([], glob($root . '/out/*') ?: []);
    }
 
    public static function acceptedTargetProvider(): array
    {
        return [
            'one line, defaults' => [self::componentSource(self::contribution('tst')), [], 'tst_de.po'],
            'multi-line with fully qualified names and a trailing comma' => [
                self::componentSource(
                    "\$contribute[\\ILIAS\\Language\\ComponentTranslation\\LanguageFileDirectory::class] = fn(): \\X\\LanguageFileDirectory => \n"
                    . "            new \\ILIAS\\Language\\ComponentTranslation\\ComponentLanguageFileDirectory(\n"
                    . "                \$this,\n                'tst',\n                'lang/',\n                'x_%s',\n            );"
                ),
                ['--pattern=x_%s'],
                'x_de.po',
            ],
            'a comment with another module does not matter' => [
                self::componentSource('// ' . self::contribution('tstx') . "\n        " . self::contribution('tst', ", 'lang'")),
                [],
                'tst_de.po',
            ],
        ];
    }
 
    #[DataProvider('acceptedTargetProvider')]
    public function testRemoveFromLangAcceptsAContributionInEveryNotationOfTheComponentClass(string $component_source, array $options, string $written): void
    {
        $root = $this->buildFixtureRepo();
        $component_lang = $this->addComponent($root, $component_source);
        $this->writeLangFile($root, 'de', self::START . "\ntst#:#a#:#A\n");
 
        [$exit_code, $stdout, $stderr] = $this->runToolAt($this->toolPathOf($root), '--remove-from-lang', ...$options, ...['tst', 'de', $component_lang]);
 
        $this->assertSame(0, $exit_code, $stdout . $stderr);
        $this->assertFileExists($component_lang . '/' . $written);
        $this->assertSame(self::START . "\n", self::langSnapshot($root)['ilias_de.lang'][0]);
    }
 
    public function testRemoveFromLangAcceptsASymbolicLinkThatResolvesToTheComponentLangDirectory(): void
    {
        $root = $this->buildFixtureRepo();
        $component_lang = $this->addRegisteredComponent($root, 'tst');
        symlink($component_lang, $root . '/link');
        $this->writeLangFile($root, 'de', self::START . "\ntst#:#a#:#A\n");
 
        [$exit_code, $stdout, $stderr] = $this->runToolAt($this->toolPathOf($root), '--remove-from-lang', 'tst', 'de', $root . '/link');
 
        $this->assertSame(0, $exit_code, $stdout . $stderr);
        $this->assertFileExists($component_lang . '/tst_de.po');
    }
 
    public function testRemoveFromLangRefusesASymbolicLinkInLangButTheOptionlessRunStillReadsIt(): void
    {
        $root = $this->buildFixtureRepo();
        $component_lang = $this->addRegisteredComponent($root, 'tst');
        $this->writeLangFile($root, 'de', self::START . "\ntst#:#a#:#A\n");
        symlink($root . '/lang/ilias_de.lang', $root . '/lang/ilias_zz.lang');
        $before = self::langSnapshot($root);
 
        [$exit_code, $stdout, $stderr] = $this->runToolAt($this->toolPathOf($root), '--remove-from-lang', 'tst', 'de', $component_lang);
 
        $this->assertSame(1, $exit_code, $stdout . $stderr);
        $this->assertStringContainsString('ilias_zz.lang', $stderr);
        $this->assertSame($before, self::langSnapshot($root));
        $this->assertTrue(is_link($root . '/lang/ilias_zz.lang'));
        $this->assertSame([], glob($component_lang . '/*') ?: []);
 
        [$exit_code, $stdout, $stderr] = $this->runToolAt($this->toolPathOf($root), 'tst', 'de', $root . '/out');
 
        $this->assertSame(0, $exit_code, $stdout . $stderr);
        $this->assertFileExists($root . '/out/tst_zz.po');
        $this->assertSame($before, self::langSnapshot($root));
    }
 
    private function writeMetaPo(string $root, string $content): void
    {
        mkdir($root . '/components/ILIAS/Meta/lang', 0775, true);
        file_put_contents($root . '/components/ILIAS/Meta/lang/meta_en.po', $content);
    }
 
    public function testLanguageTeamFallsBackToAShippedMetaPoAndAnUnreadableOneOnlyWarns(): void
    {
        $root = $this->buildFixtureRepo();
        $this->writeLangFile($root, 'de', "tst#:#a#:#A\n");
        $this->writeLangFile($root, 'en', "tst#:#a#:#A\n");
        $this->writeMetaPo($root, "msgid \"\"\nmsgstr \"\"\n\"Content-Type: text/plain; charset=UTF-8\\n\"\n\nmsgid \"meta_l_de\"\nmsgstr \"German\"\n");
 
        [$exit_code, $stdout, $stderr] = $this->runToolAt($this->toolPathOf($root), 'tst', 'de', $root . '/out');
 
        $this->assertSame(0, $exit_code, $stdout . $stderr);
        $this->assertSame('German', TranslationCatalog::fromPoFile($root . '/out/tst_de.po')->getHeader('Language-Team'));
        $this->assertNull(TranslationCatalog::fromPoFile($root . '/out/tst_en.po')->getHeader('Language-Team'));
 
        file_put_contents($root . '/components/ILIAS/Meta/lang/meta_en.po', "msgid \"meta_l_de\"\nmsgstr \"unterminated\n\"x\n garbage");
        MigratedPoFixture::removeDirectory($root . '/out');
        mkdir($root . '/out');
 
        [$exit_code, $stdout, $stderr] = $this->runToolAt($this->toolPathOf($root), 'tst', 'de', $root . '/out');
 
        $this->assertSame(0, $exit_code, $stdout . $stderr);
        $this->assertStringContainsString('meta_en.po cannot be read for the language names', $stderr);
        $this->assertFileExists($root . '/out/tst_de.po');
    }
}