ContentObjectRendererTest.php

Go to the documentation of this file.

<?php
 
declare(strict_types=1);
 
/*
 * This file is part of the TYPO3 CMS project.
 *
 * It is free software; you can redistribute it and/or modify it under
 * the terms of the GNU General Public License, either version 2
 * of the License, or any later version.
 *
 * For the full copyright and license information, please read the
 * LICENSE.txt file that was distributed with this source code.
 *
 * The TYPO3 project - inspiring people to share!
 */
 
namespace ‪TYPO3\CMS\Frontend\Tests\Unit\ContentObject;
 
use PHPUnit\Framework\Exception;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\MockObject\Rule\InvocationOrder;
use Psr\EventDispatcher\EventDispatcherInterface;
use Psr\Http\Message\ServerRequestInterface;
use Psr\Log\NullLogger;
use Symfony\Component\DependencyInjection\Container;
use ‪TYPO3\CMS\Core\Cache\CacheManager;
use ‪TYPO3\CMS\Core\Cache\Frontend\FrontendInterface as CacheFrontendInterface;
use ‪TYPO3\CMS\Core\Cache\Frontend\NullFrontend;
use ‪TYPO3\CMS\Core\Configuration\Features;
use ‪TYPO3\CMS\Core\Configuration\SiteConfiguration;
use ‪TYPO3\CMS\Core\Context\Context;
use ‪TYPO3\CMS\Core\Context\DateTimeAspect;
use ‪TYPO3\CMS\Core\Context\UserAspect;
use ‪TYPO3\CMS\Core\Context\WorkspaceAspect;
use ‪TYPO3\CMS\Core\Core\ApplicationContext;
use ‪TYPO3\CMS\Core\Core\Environment;
use ‪TYPO3\CMS\Core\Crypto\Random;
use ‪TYPO3\CMS\Core\Domain\Repository\PageRepository;
use ‪TYPO3\CMS\Core\EventDispatcher\NoopEventDispatcher;
use ‪TYPO3\CMS\Core\ExpressionLanguage\DefaultProvider;
use ‪TYPO3\CMS\Core\ExpressionLanguage\ProviderConfigurationLoader;
use ‪TYPO3\CMS\Core\Http\ServerRequest;
use ‪TYPO3\CMS\Core\Information\Typo3Version;
use ‪TYPO3\CMS\Core\LinkHandling\LinkService;
use TYPO3\CMS\Core\LinkHandling\TypoLinkCodecService;
use ‪TYPO3\CMS\Core\Localization\LanguageService;
use ‪TYPO3\CMS\Core\Localization\LanguageServiceFactory;
use ‪TYPO3\CMS\Core\Log\Logger;
use TYPO3\CMS\Core\Package\PackageManager;
use TYPO3\CMS\Core\Page\PageRenderer;
use ‪TYPO3\CMS\Core\Resource\Exception\InvalidPathException;
use ‪TYPO3\CMS\Core\Resource\File;
use ‪TYPO3\CMS\Core\Resource\ResourceFactory;
use ‪TYPO3\CMS\Core\Resource\ResourceStorage;
use ‪TYPO3\CMS\Core\Service\DependencyOrderingService;
use ‪TYPO3\CMS\Core\Site\Entity\Site;
use ‪TYPO3\CMS\Core\Site\SiteFinder;
use ‪TYPO3\CMS\Core\TimeTracker\TimeTracker;
use ‪TYPO3\CMS\Core\Type\DocType;
use ‪TYPO3\CMS\Core\TypoScript\AST\AstBuilder;
use ‪TYPO3\CMS\Core\TypoScript\AST\Node\RootNode;
use ‪TYPO3\CMS\Core\TypoScript\FrontendTypoScript;
use ‪TYPO3\CMS\Core\TypoScript\Tokenizer\LossyTokenizer;
use ‪TYPO3\CMS\Core\Utility\DebugUtility;
use ‪TYPO3\CMS\Core\Utility\GeneralUtility;
use ‪TYPO3\CMS\Core\Utility\StringUtility;
use ‪TYPO3\CMS\Frontend\Authentication\FrontendUserAuthentication;
use ‪TYPO3\CMS\Frontend\ContentObject\AbstractContentObject;
use ‪TYPO3\CMS\Frontend\ContentObject\CaseContentObject;
use ‪TYPO3\CMS\Frontend\ContentObject\ContentContentObject;
use ‪TYPO3\CMS\Frontend\ContentObject\ContentDataProcessor;
use ‪TYPO3\CMS\Frontend\ContentObject\ContentObjectArrayContentObject;
use ‪TYPO3\CMS\Frontend\ContentObject\ContentObjectArrayInternalContentObject;
use ‪TYPO3\CMS\Frontend\ContentObject\ContentObjectFactory;
use ‪TYPO3\CMS\Frontend\ContentObject\ContentObjectGetImageResourceHookInterface;
use TYPO3\CMS\Frontend\ContentObject\ContentObjectRenderer;
use ‪TYPO3\CMS\Frontend\ContentObject\ContentObjectStdWrapHookInterface;
use ‪TYPO3\CMS\Frontend\ContentObject\Exception\ProductionExceptionHandler;
use ‪TYPO3\CMS\Frontend\ContentObject\FilesContentObject;
use ‪TYPO3\CMS\Frontend\ContentObject\FluidTemplateContentObject;
use ‪TYPO3\CMS\Frontend\ContentObject\HierarchicalMenuContentObject;
use ‪TYPO3\CMS\Frontend\ContentObject\ImageContentObject;
use ‪TYPO3\CMS\Frontend\ContentObject\ImageResourceContentObject;
use ‪TYPO3\CMS\Frontend\ContentObject\LoadRegisterContentObject;
use ‪TYPO3\CMS\Frontend\ContentObject\RecordsContentObject;
use ‪TYPO3\CMS\Frontend\ContentObject\RestoreRegisterContentObject;
use ‪TYPO3\CMS\Frontend\ContentObject\ScalableVectorGraphicsContentObject;
use ‪TYPO3\CMS\Frontend\ContentObject\TextContentObject;
use ‪TYPO3\CMS\Frontend\ContentObject\UserContentObject;
use ‪TYPO3\CMS\Frontend\ContentObject\UserInternalContentObject;
use ‪TYPO3\CMS\Frontend\Controller\TypoScriptFrontendController;
use ‪TYPO3\CMS\Frontend\DataProcessing\DataProcessorRegistry;
use ‪TYPO3\CMS\Frontend\Tests\Unit\ContentObject\Fixtures\TestSanitizerBuilder;
use ‪TYPO3\CMS\Frontend\Typolink\LinkFactory;
use TYPO3\CMS\Frontend\Typolink\LinkResult;
use ‪TYPO3\CMS\Frontend\Typolink\LinkResultInterface;
use TYPO3\TestingFramework\Core\AccessibleObjectInterface;
use TYPO3\TestingFramework\Core\Unit\UnitTestCase;
 
class ‪ContentObjectRendererTest extends UnitTestCase
{
    use ‪ContentObjectRendererTestTrait;
 
    protected bool ‪$resetSingletonInstances = true;
 
    protected ContentObjectRenderer&MockObject&AccessibleObjectInterface ‪$subject;
 
    protected ‪TypoScriptFrontendController&MockObject&AccessibleObjectInterface ‪$frontendControllerMock;
 
    protected array ‪$contentObjectMap = [
        'TEXT' => TextContentObject::class,
        'CASE' => CaseContentObject::class,
        'COBJ_ARRAY' => ContentObjectArrayContentObject::class,
        'COA' => ContentObjectArrayContentObject::class,
        'COA_INT' => ContentObjectArrayInternalContentObject::class,
        'USER' => UserContentObject::class,
        'USER_INT' => UserInternalContentObject::class,
        'FILES' => FilesContentObject::class,
        'IMAGE' => ImageContentObject::class,
        'IMG_RESOURCE' => ImageResourceContentObject::class,
        'CONTENT' => ContentContentObject::class,
        'RECORDS' => RecordsContentObject::class,
        'HMENU' => HierarchicalMenuContentObject::class,
        'CASEFUNC' => CaseContentObject::class,
        'LOAD_REGISTER' => LoadRegisterContentObject::class,
        'RESTORE_REGISTER' => RestoreRegisterContentObject::class,
        'FLUIDTEMPLATE' => FluidTemplateContentObject::class,
        'SVG' => ScalableVectorGraphicsContentObject::class,
    ];
 
    protected MockObject&‪CacheManager ‪$cacheManagerMock;
 
    protected bool ‪$backupEnvironment = true;
 
    protected function ‪setUp(): void
    {
        parent::setUp();
 
        $site = $this->‪createSiteWithLanguage([
            'base' => '/',
            'languageId' => 2,
            'locale' => 'en_UK',
        ]);
 
        ‪$GLOBALS['SIM_ACCESS_TIME'] = 1534278180;
        $pageRepositoryMock =
            $this->getAccessibleMock(PageRepository::class, ['getRawRecord', 'getMountPointInfo']);
        $this->frontendControllerMock =
            $this->getAccessibleMock(
                TypoScriptFrontendController::class,
                ['sL'],
                [],
                '',
                false
            );
        $this->frontendControllerMock->_set('context', GeneralUtility::makeInstance(Context::class));
        $this->frontendControllerMock->config = [];
        $this->frontendControllerMock->page = [];
        $this->frontendControllerMock->sys_page = $pageRepositoryMock;
        $this->frontendControllerMock->_set('language', $site->getLanguageById(2));
        ‪$GLOBALS['TSFE'] = ‪$this->frontendControllerMock;
 
        $this->cacheManagerMock = $this->getMockBuilder(CacheManager::class)->disableOriginalConstructor()->getMock();
        GeneralUtility::setSingletonInstance(CacheManager::class, $this->cacheManagerMock);
 
        $this->subject = $this->getAccessibleMock(
            ContentObjectRenderer::class,
            ['getResourceFactory', 'getEnvironmentVariable'],
            [$this->frontendControllerMock]
        );
 
        $logger = new NullLogger();
        $this->subject->setLogger($logger);
        $request = new ‪ServerRequest();
        $this->subject->setRequest($request);
 
        $contentObjectFactoryMock = $this->createContentObjectFactoryMock();
        $cObj = ‪$this->subject;
        foreach ($this->contentObjectMap as $name => $className) {
            $contentObjectFactoryMock->addGetContentObjectCallback(
                $name,
                $className,
                $request,
                $cObj,
                $this->getMockBuilder(DataProcessorRegistry::class)->disableOriginalConstructor()->getMock()
            );
        }
        $container = new Container();
        $container->set(ContentObjectFactory::class, $contentObjectFactoryMock);
        GeneralUtility::setContainer($container);
 
        $this->subject->start([], 'tt_content');
    }
 
    // Utility functions
 
    protected function ‪getFrontendController(): ‪TypoScriptFrontendController
    {
        return ‪$GLOBALS['TSFE'];
    }
 
    protected function ‪getLinkFactory(‪SiteConfiguration $siteConfiguration = null, $linkService = null): ‪LinkFactory
    {
        $linkService ??= new ‪LinkService();
        $typoLinkCodecService = new TypoLinkCodecService();
        if ($siteConfiguration) {
            $siteFinder = new ‪SiteFinder($siteConfiguration);
        } else {
            $siteFinder = $this->getMockBuilder(SiteFinder::class)->disableOriginalConstructor()->getMock();
        }
        $linkFactory = new ‪LinkFactory(
            $linkService,
            new class () implements EventDispatcherInterface {
                public function dispatch(object $event)
                {
                    return $event;
                }
            },
            $typoLinkCodecService,
            new ‪NullFrontend('runtime'),
            $siteFinder
        );
        $linkFactory->setLogger(new NullLogger());
        return $linkFactory;
    }
 
    protected function ‪handleCharset(string &‪$subject, string &$expected): void
    {
        ‪$subject = mb_convert_encoding(‪$subject, 'utf-8', 'iso-8859-1');
        $expected = mb_convert_encoding($expected, 'utf-8', 'iso-8859-1');
    }
 
    // Tests concerning the getImgResource hook
 
    public function ‪getImgResourceCallsGetImgResourcePostProcessHook(): void
    {
        ‪$cacheManagerMock = $this->getMockBuilder(CacheManager::class)->disableOriginalConstructor()->getMock();
        $cacheMock = $this->getMockBuilder(CacheFrontendInterface::class)->disableOriginalConstructor()->getMock();
        $cacheMock->method('get')->willReturn(false);
        $cacheMock->method('set')->willReturn(false);
        ‪$cacheManagerMock->method('getCache')->with('imagesizes')->willReturn($cacheMock);
        GeneralUtility::setSingletonInstance(CacheManager::class, ‪$cacheManagerMock);
 
        $resourceFactory = $this->createMock(ResourceFactory::class);
        $this->subject->method('getResourceFactory')->willReturn($resourceFactory);
 
        $className = ‪StringUtility::getUniqueId('tx_coretest');
        $getImgResourceHookMock = $this->getMockBuilder(ContentObjectGetImageResourceHookInterface::class)
            ->onlyMethods(['getImgResourcePostProcess'])
            ->setMockClassName($className)
            ->getMock();
        $getImgResourceHookMock
            ->expects(self::once())
            ->method('getImgResourcePostProcess')
            ->willReturnCallback([$this, 'isGetImgResourceHookCalledCallback']);
        $getImgResourceHookObjects = [$getImgResourceHookMock];
        $this->subject->_set('getImgResourceHookObjects', $getImgResourceHookObjects);
        $this->subject->getImgResource('typo3/sysext/core/Tests/Unit/Utility/Fixtures/clear.gif', []);
    }
 
    public function ‪isGetImgResourceHookCalledCallback(
        string $file,
        array $fileArray,
        array $imageResource,
        ContentObjectRenderer $parent
    ): array {
        self::assertEquals('typo3/sysext/core/Tests/Unit/Utility/Fixtures/clear.gif', $file);
        self::assertEquals('typo3/sysext/core/Tests/Unit/Utility/Fixtures/clear.gif', $imageResource['origFile']);
        self::assertIsArray($fileArray);
        self::assertInstanceOf(ContentObjectRenderer::class, $parent);
        return $imageResource;
    }
 
    // Tests related to getContentObject
 
    public function ‪willReturnNullForUnregisteredObject(): void
    {
        $object = $this->subject->getContentObject('FOO');
        self::assertNull($object);
    }
 
    // Tests concerning crop
 
    public function ‪cropIsMultibyteSafe(): void
    {
        self::assertEquals('бла', $this->subject->crop('бла', '3|...'));
    }
 
 
    // Tests concerning cropHTML
 
    public static function ‪cropHTMLDataProvider(): array
    {
        $plainText = 'Kasper Sk' . chr(229) . 'rh' . chr(248)
            . 'j implemented the original version of the crop function.';
        $textWithMarkup = '<strong><a href="mailto:kasper@typo3.org">Kasper Sk'
            . chr(229) . 'rh' . chr(248) . 'j</a> implemented</strong> the '
            . 'original version of the crop function.';
        $textWithEntities = 'Kasper Sk&aring;rh&oslash;j implemented the; '
            . 'original version of the crop function.';
        $textWithLinebreaks = "Lorem ipsum dolor sit amet,\n"
            . "consetetur sadipscing elitr,\n"
            . 'sed diam nonumy eirmod tempor invidunt ut labore e'
            . 't dolore magna aliquyam';
        $textWith2000Chars = 'Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Aenean commodo ligula eget dolor. Aenean massa. Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Donec quam felis, ultricies nec, pellentesque eu, pretium quis, sem. Nulla consequat massa quis enim. Donec pede justo, fringilla vel, aliquet nec, vulputate eget, arcu. In enim justo, rhoncus ut, imperdiet a, venenatis vitae, justo. Nullam dictum felis eu pede mollis pretium. Integer tincidunt. Cras dapibus. Vivamus elementum semper nisi. Aenean vulputate eleifend tellus. Aenean leo ligula, porttitor eu, consequat vitae, eleifend ac, enim. Aliquam lorem ante, dapibus in, viverra quis, feugiat a, tellus. Phasellus viverra nulla ut metus varius laoreet. Quisque rutrum. Aenean imperdiet. Etiam ultricies nisi vel augue. Curabitur ullamcorper ultricies nisi. Nam eget dui. Etiam rhoncus. Maecenas tempus, tellus eget condimentum rhoncus, sem quam semper libero, sit amet adipiscing sem neque sed ips &amp;. Nam quam nunc, blandit vel, luctus pulvinar, hendrerit id, lorem. Maecenas nec odio et ante tincidunt tempus. Donec vitae sapien ut libero venenatis faucibus. Nullam quis ante. Etiam sit amet orci eget eros faucibus tincidunt. Duis leo. Sed fringilla mauris sit amet nibh. Donec sodales sagittis magna. Sed consequat, leo eget bibendum sodales, augue velit cursus nunc, quis gravida magna mi a libero. Fusce vulputate eleifend sapien. Vestibulum purus quam, scelerisque ut, mollis sed, nonummy id, metus. Nullam accumsan lorem in dui. Cras ultricies mi eu turpis hendrerit fringilla. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia Curae; In ac dui quis mi consectetuer lacinia. Nam pretium turpis et arcu. Duis arcu tortor, suscipit eget, imperdiet nec, imperdiet iaculis, ipsum. Sed aliquam ultrices mauris. Integer ante arcu, accumsan a, consectetuer eget, posuere ut, mauris. Praesent adipiscing. Phasellus ullamcorper ipsum rutrum nunc. Nunc nonummy metus. Vesti&amp;';
        $textWith1000AmpHtmlEntity = str_repeat('&amp;', 1000);
        $textWith2000AmpHtmlEntity = str_repeat('&amp;', 2000);
 
        return [
            'plain text; 11|...' => [
                'Kasper Sk' . chr(229) . 'r...',
                $plainText,
                '11|...',
            ],
            'plain text; -58|...' => [
                '...h' . chr(248) . 'j implemented the original version of '
                . 'the crop function.',
                $plainText,
                '-58|...',
            ],
            'plain text; 4|...|1' => [
                'Kasp...',
                $plainText,
                '4|...|1',
            ],
            'plain text; 20|...|1' => [
                'Kasper Sk' . chr(229) . 'rh' . chr(248) . 'j...',
                $plainText,
                '20|...|1',
            ],
            'plain text; -5|...|1' => [
                '...tion.',
                $plainText,
                '-5|...|1',
            ],
            'plain text; -49|...|1' => [
                '...the original version of the crop function.',
                $plainText,
                '-49|...|1',
            ],
            'text with markup; 11|...' => [
                '<strong><a href="mailto:kasper@typo3.org">Kasper Sk'
                . chr(229) . 'r...</a></strong>',
                $textWithMarkup,
                '11|...',
            ],
            'text with markup; 13|...' => [
                '<strong><a href="mailto:kasper@typo3.org">Kasper Sk'
                . chr(229) . 'rh' . chr(248) . '...</a></strong>',
                $textWithMarkup,
                '13|...',
            ],
            'text with markup; 14|...' => [
                '<strong><a href="mailto:kasper@typo3.org">Kasper Sk'
                . chr(229) . 'rh' . chr(248) . 'j</a>...</strong>',
                $textWithMarkup,
                '14|...',
            ],
            'text with markup; 15|...' => [
                '<strong><a href="mailto:kasper@typo3.org">Kasper Sk'
                . chr(229) . 'rh' . chr(248) . 'j</a> ...</strong>',
                $textWithMarkup,
                '15|...',
            ],
            'text with markup; 29|...' => [
                '<strong><a href="mailto:kasper@typo3.org">Kasper Sk'
                . chr(229) . 'rh' . chr(248) . 'j</a> implemented</strong> '
                . 'th...',
                $textWithMarkup,
                '29|...',
            ],
            'text with markup; -58|...' => [
                '<strong><a href="mailto:kasper@typo3.org">...h' . chr(248)
                . 'j</a> implemented</strong> the original version of the crop '
                . 'function.',
                $textWithMarkup,
                '-58|...',
            ],
            'text with markup 4|...|1' => [
                '<strong><a href="mailto:kasper@typo3.org">Kasp...</a>'
                . '</strong>',
                $textWithMarkup,
                '4|...|1',
            ],
            'text with markup; 11|...|1' => [
                '<strong><a href="mailto:kasper@typo3.org">Kasper...</a>'
                . '</strong>',
                $textWithMarkup,
                '11|...|1',
            ],
            'text with markup; 13|...|1' => [
                '<strong><a href="mailto:kasper@typo3.org">Kasper...</a>'
                . '</strong>',
                $textWithMarkup,
                '13|...|1',
            ],
            'text with markup; 14|...|1' => [
                '<strong><a href="mailto:kasper@typo3.org">Kasper Sk'
                . chr(229) . 'rh' . chr(248) . 'j</a>...</strong>',
                $textWithMarkup,
                '14|...|1',
            ],
            'text with markup; 15|...|1' => [
                '<strong><a href="mailto:kasper@typo3.org">Kasper Sk'
                . chr(229) . 'rh' . chr(248) . 'j</a>...</strong>',
                $textWithMarkup,
                '15|...|1',
            ],
            'text with markup; 29|...|1' => [
                '<strong><a href="mailto:kasper@typo3.org">Kasper Sk'
                . chr(229) . 'rh' . chr(248) . 'j</a> implemented</strong>...',
                $textWithMarkup,
                '29|...|1',
            ],
            'text with markup; -66|...|1' => [
                '<strong><a href="mailto:kasper@typo3.org">...Sk' . chr(229)
                . 'rh' . chr(248) . 'j</a> implemented</strong> the original v'
                . 'ersion of the crop function.',
                $textWithMarkup,
                '-66|...|1',
            ],
            'text with entities 9|...' => [
                'Kasper Sk...',
                $textWithEntities,
                '9|...',
            ],
            'text with entities 10|...' => [
                'Kasper Sk&aring;...',
                $textWithEntities,
                '10|...',
            ],
            'text with entities 11|...' => [
                'Kasper Sk&aring;r...',
                $textWithEntities,
                '11|...',
            ],
            'text with entities 13|...' => [
                'Kasper Sk&aring;rh&oslash;...',
                $textWithEntities,
                '13|...',
            ],
            'text with entities 14|...' => [
                'Kasper Sk&aring;rh&oslash;j...',
                $textWithEntities,
                '14|...',
            ],
            'text with entities 15|...' => [
                'Kasper Sk&aring;rh&oslash;j ...',
                $textWithEntities,
                '15|...',
            ],
            'text with entities 16|...' => [
                'Kasper Sk&aring;rh&oslash;j i...',
                $textWithEntities,
                '16|...',
            ],
            'text with entities -57|...' => [
                '...j implemented the; original version of the crop function.',
                $textWithEntities,
                '-57|...',
            ],
            'text with entities -58|...' => [
                '...&oslash;j implemented the; original version of the crop '
                . 'function.',
                $textWithEntities,
                '-58|...',
            ],
            'text with entities -59|...' => [
                '...h&oslash;j implemented the; original version of the crop '
                . 'function.',
                $textWithEntities,
                '-59|...',
            ],
            'text with entities 4|...|1' => [
                'Kasp...',
                $textWithEntities,
                '4|...|1',
            ],
            'text with entities 9|...|1' => [
                'Kasper...',
                $textWithEntities,
                '9|...|1',
            ],
            'text with entities 10|...|1' => [
                'Kasper...',
                $textWithEntities,
                '10|...|1',
            ],
            'text with entities 11|...|1' => [
                'Kasper...',
                $textWithEntities,
                '11|...|1',
            ],
            'text with entities 13|...|1' => [
                'Kasper...',
                $textWithEntities,
                '13|...|1',
            ],
            'text with entities 14|...|1' => [
                'Kasper Sk&aring;rh&oslash;j...',
                $textWithEntities,
                '14|...|1',
            ],
            'text with entities 15|...|1' => [
                'Kasper Sk&aring;rh&oslash;j...',
                $textWithEntities,
                '15|...|1',
            ],
            'text with entities 16|...|1' => [
                'Kasper Sk&aring;rh&oslash;j...',
                $textWithEntities,
                '16|...|1',
            ],
            'text with entities -57|...|1' => [
                '...implemented the; original version of the crop function.',
                $textWithEntities,
                '-57|...|1',
            ],
            'text with entities -58|...|1' => [
                '...implemented the; original version of the crop function.',
                $textWithEntities,
                '-58|...|1',
            ],
            'text with entities -59|...|1' => [
                '...implemented the; original version of the crop function.',
                $textWithEntities,
                '-59|...|1',
            ],
            'text with dash in html-element 28|...|1' => [
                'Some text with a link to <link email.address@example.org - '
                . 'mail "Open email window">my...</link>',
                'Some text with a link to <link email.address@example.org - m'
                . 'ail "Open email window">my email.address@example.org<'
                . '/link> and text after it',
                '28|...|1',
            ],
            'html elements with dashes in attributes' => [
                '<em data-foo="x">foobar</em>foo',
                '<em data-foo="x">foobar</em>foo',
                '9',
            ],
            'html elements with iframe embedded 24|...|1' => [
                'Text with iframe <iframe src="//what.ever/"></iframe> and...',
                'Text with iframe <iframe src="//what.ever/">'
                . '</iframe> and text after it',
                '24|...|1',
            ],
            'html elements with script tag embedded 24|...|1' => [
                'Text with script <script>alert(\'foo\');</script> and...',
                'Text with script <script>alert(\'foo\');</script> '
                . 'and text after it',
                '24|...|1',
            ],
            'text with linebreaks' => [
                "Lorem ipsum dolor sit amet,\nconsetetur sadipscing elitr,\ns"
                . 'ed diam nonumy eirmod tempor invidunt ut labore e'
                . 't dolore magna',
                $textWithLinebreaks,
                '121',
            ],
            'long text under the crop limit' => [
                'Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Aenean commodo ligula eget dolor. Aenean massa. Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Donec quam felis, ultricies nec, pellentesque eu, pretium quis, sem. Nulla consequat massa quis enim. Donec pede justo, fringilla vel, aliquet nec, vulputate eget, arcu. In enim justo, rhoncus ut, imperdiet a, venenatis vitae, justo. Nullam dictum felis eu pede mollis pretium. Integer tincidunt. Cras dapibus. Vivamus elementum semper nisi. Aenean vulputate eleifend tellus. Aenean leo ligula, porttitor eu, consequat vitae, eleifend ac, enim. Aliquam lorem ante, dapibus in, viverra quis, feugiat a, tellus. Phasellus viverra nulla ut metus varius laoreet. Quisque rutrum. Aenean imperdiet. Etiam ultricies nisi vel augue. Curabitur ullamcorper ultricies nisi. Nam eget dui. Etiam rhoncus. Maecenas tempus, tellus eget condimentum rhoncus, sem quam semper libero, sit' . ' ...',
                $textWith2000Chars,
                '962|...',
            ],
            'long text above the crop limit' => [
                'Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Aenean commodo ligula eget dolor. Aenean massa. Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Donec quam felis, ultricies nec, pellentesque eu, pretium quis, sem. Nulla consequat massa quis enim. Donec pede justo, fringilla vel, aliquet nec, vulputate eget, arcu. In enim justo, rhoncus ut, imperdiet a, venenatis vitae, justo. Nullam dictum felis eu pede mollis pretium. Integer tincidunt. Cras dapibus. Vivamus elementum semper nisi. Aenean vulputate eleifend tellus. Aenean leo ligula, porttitor eu, consequat vitae, eleifend ac, enim. Aliquam lorem ante, dapibus in, viverra quis, feugiat a, tellus. Phasellus viverra nulla ut metus varius laoreet. Quisque rutrum. Aenean imperdiet. Etiam ultricies nisi vel augue. Curabitur ullamcorper ultricies nisi. Nam eget dui. Etiam rhoncus. Maecenas tempus, tellus eget condimentum rhoncus, sem quam semper libero, sit amet adipiscing sem neque sed ips &amp;. N' . '...',
                $textWith2000Chars,
                '1000|...',
            ],
            'long text above the crop limit #2' => [
                'Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Aenean commodo ligula eget dolor. Aenean massa. Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Donec quam felis, ultricies nec, pellentesque eu, pretium quis, sem. Nulla consequat massa quis enim. Donec pede justo, fringilla vel, aliquet nec, vulputate eget, arcu. In enim justo, rhoncus ut, imperdiet a, venenatis vitae, justo. Nullam dictum felis eu pede mollis pretium. Integer tincidunt. Cras dapibus. Vivamus elementum semper nisi. Aenean vulputate eleifend tellus. Aenean leo ligula, porttitor eu, consequat vitae, eleifend ac, enim. Aliquam lorem ante, dapibus in, viverra quis, feugiat a, tellus. Phasellus viverra nulla ut metus varius laoreet. Quisque rutrum. Aenean imperdiet. Etiam ultricies nisi vel augue. Curabitur ullamcorper ultricies nisi. Nam eget dui. Etiam rhoncus. Maecenas tempus, tellus eget condimentum rhoncus, sem quam semper libero, sit amet adipiscing sem neque sed ips &amp;. Nam quam nunc, blandit vel, luctus pulvinar, hendrerit id, lorem. Maecenas nec odio et ante tincidunt tempus. Donec vitae sapien ut libero venenatis faucibus. Nullam quis ante. Etiam sit amet orci eget eros faucibus tincidunt. Duis leo. Sed fringilla mauris sit amet nibh. Donec sodales sagittis magna. Sed consequat, leo eget bibendum sodales, augue velit cursus nunc, quis gravida magna mi a libero. Fusce vulputate eleifend sapien. Vestibulum purus quam, scelerisque ut, mollis sed, nonummy id, metus. Nullam accumsan lorem in dui. Cras ultricies mi eu turpis hendrerit fringilla. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia Curae; In ac dui quis mi consectetuer lacinia. Nam pretium turpis et arcu. Duis arcu tortor, suscipit eget, imperdiet nec, imperdiet iaculis, ipsum. Sed aliquam ultrices mauris. Integer ante arcu, accumsan a, consectetuer eget, posuere ut, mauris. Praesent adipiscing. Phasellus ullamcorper ipsum rutrum nunc. Nunc nonummy metus. Vesti&amp;' . '...',
                $textWith2000Chars . $textWith2000Chars,
                '2000|...',
            ],
            // ensure that large number of html entities do not break the the regexp splittin
            'long text with large number of html entities' => [
                $textWith1000AmpHtmlEntity . '...',
                $textWith2000AmpHtmlEntity,
                '1000|...',
            ],
        ];
    }
 
    public function ‪cropHTML(string $expect, string $content, string $conf): void
    {
        $this->‪handleCharset($content, $expect);
        self::assertSame(
            $expect,
            $this->subject->cropHTML($content, $conf)
        );
    }
 
    public static function ‪roundDataProvider(): array
    {
        return [
            // floats
            'down' => [1.0, 1.11, []],
            'up' => [2.0, 1.51, []],
            'rounds up from x.50' => [2.0, 1.50, []],
            'down with decimals' => [0.12, 0.1231, ['decimals' => 2]],
            'up with decimals' => [0.13, 0.1251, ['decimals' => 2]],
            'ceil' => [1.0, 0.11, ['roundType' => 'ceil']],
            'ceil does not accept decimals' => [
                1.0,
                0.111,
                [
                    'roundType' => 'ceil',
                    'decimals' => 2,
                ],
            ],
            'floor' => [2.0, 2.99, ['roundType' => 'floor']],
            'floor does not accept decimals' => [
                2.0,
                2.999,
                [
                    'roundType' => 'floor',
                    'decimals' => 2,
                ],
            ],
            'round, down' => [1.0, 1.11, ['roundType' => 'round']],
            'round, up' => [2.0, 1.55, ['roundType' => 'round']],
            'round does accept decimals' => [
                5.56,
                5.5555,
                [
                    'roundType' => 'round',
                    'decimals' => 2,
                ],
            ],
            // strings
            'emtpy string' => [0.0, '', []],
            'word string' => [0.0, 'word', []],
            'float string' => [1.0, '1.123456789', []],
            // other types
            'null' => [0.0, null, []],
            'false' => [0.0, false, []],
            'true' => [1.0, true, []],
        ];
    }
 
    public function ‪round(float $expect, mixed $content, array $conf): void
    {
        self::assertSame(
            $expect,
            $this->subject->_call('round', $content, $conf)
        );
    }
 
    public function ‪recursiveStdWrapProperlyRendersBasicString(): void
    {
        $stdWrapConfiguration = [
            'noTrimWrap' => '|| 123|',
            'stdWrap.' => [
                'wrap' => '<b>|</b>',
            ],
        ];
        self::assertSame(
            '<b>Test</b> 123',
            $this->subject->stdWrap('Test', $stdWrapConfiguration)
        );
    }
 
    public function ‪recursiveStdWrapIsOnlyCalledOnce(): void
    {
        $stdWrapConfiguration = [
            'append' => 'TEXT',
            'append.' => [
                'data' => 'register:Counter',
            ],
            'stdWrap.' => [
                'append' => 'LOAD_REGISTER',
                'append.' => [
                    'Counter.' => [
                        'prioriCalc' => 'intval',
                        'cObject' => 'TEXT',
                        'cObject.' => [
                            'data' => 'register:Counter',
                            'wrap' => '|+1',
                        ],
                    ],
                ],
            ],
        ];
        self::assertSame(
            'Counter:1',
            $this->subject->stdWrap('Counter:', $stdWrapConfiguration)
        );
    }
 
    public static function ‪numberFormatDataProvider(): array
    {
        return [
            'testing decimals' => [
                '0.80',
                0.8,
                ['decimals' => 2],
            ],
            'testing decimals with input as string' => [
                '0.80',
                '0.8',
                ['decimals' => 2],
            ],
            'testing dec_point' => [
                '0,8',
                0.8,
                ['decimals' => 1, 'dec_point' => ','],
            ],
            'testing thousands_sep' => [
                '1.000',
                999.99,
                [
                    'decimals' => 0,
                    'thousands_sep.' => ['char' => 46],
                ],
            ],
            'testing mixture' => [
                '1.281.731,5',
                1281731.45,
                [
                    'decimals' => 1,
                    'dec_point.' => ['char' => 44],
                    'thousands_sep.' => ['char' => 46],
                ],
            ],
        ];
    }
 
    public function ‪numberFormat(string $expects, mixed $content, array $conf): void
    {
        self::assertSame(
            $expects,
            $this->subject->numberFormat($content, $conf)
        );
    }
 
    public static function ‪replacementDataProvider(): array
    {
        return [
            'multiple replacements, including regex' => [
                'There is an animal, an animal and an animal around the block! Yeah!',
                'There_is_a_cat,_a_dog_and_a_tiger_in_da_hood!_Yeah!',
                [
                    '20.' => [
                        'search' => '_',
                        'replace.' => ['char' => '32'],
                    ],
                    '120.' => [
                        'search' => 'in da hood',
                        'replace' => 'around the block',
                    ],
                    '130.' => [
                        'search' => '#a (Cat|Dog|Tiger)#i',
                        'replace' => 'an animal',
                        'useRegExp' => '1',
                    ],
                ],
            ],
            'replacement with optionSplit, normal pattern' => [
                'There1is2a3cat,3a3dog3and3a3tiger3in3da3hood!3Yeah!',
                'There_is_a_cat,_a_dog_and_a_tiger_in_da_hood!_Yeah!',
                [
                    '10.' => [
                        'search' => '_',
                        'replace' => '1 || 2 || 3',
                        'useOptionSplitReplace' => '1',
                        'useRegExp' => '0',
                    ],
                ],
            ],
            'replacement with optionSplit, using regex' => [
                'There is a tiny cat, a midsized dog and a big tiger in da hood! Yeah!',
                'There is a cat, a dog and a tiger in da hood! Yeah!',
                [
                    '10.' => [
                        'search' => '#(a) (Cat|Dog|Tiger)#i',
                        'replace' => '${1} tiny ${2} || ${1} midsized ${2} || ${1} big ${2}',
                        'useOptionSplitReplace' => '1',
                        'useRegExp' => '1',
                    ],
                ],
            ],
        ];
    }
 
    public function ‪replacement(string $expects, string $content, array $conf): void
    {
        self::assertSame(
            $expects,
            $this->subject->_call('replacement', $content, $conf)
        );
    }
 
    public static function ‪calcAgeDataProvider(): array
    {
        return [
            'minutes' => [
                '2 min',
                120,
                ' min| hrs| days| yrs',
            ],
            'hours' => [
                '2 hrs',
                7200,
                ' min| hrs| days| yrs',
            ],
            'days' => [
                '7 days',
                604800,
                ' min| hrs| days| yrs',
            ],
            'day with provided singular labels' => [
                '1 day',
                86400,
                ' min| hrs| days| yrs| min| hour| day| year',
            ],
            'years' => [
                '45 yrs',
                1417997800,
                ' min| hrs| days| yrs',
            ],
            'different labels' => [
                '2 Minutes',
                120,
                ' Minutes| Hrs| Days| Yrs',
            ],
            'negative values' => [
                '-7 days',
                -604800,
                ' min| hrs| days| yrs',
            ],
            'default label values for wrong label input' => [
                '2 min',
                121,
                '10',
            ],
            'default singular label values for wrong label input' => [
                '1 year',
                31536000,
                '10',
            ],
        ];
    }
 
    public function ‪calcAge(string $expect, int $timestamp, string $labels): void
    {
        self::assertSame(
            $expect,
            $this->subject->calcAge($timestamp, $labels)
        );
    }
 
    public static function ‪stdWrapReturnsExpectationDataProvider(): array
    {
        return [
            'Prevent silent bool conversion' => [
                '1+1',
                [
                    'prioriCalc.' => [
                        'wrap' => '|',
                    ],
                ],
                '1+1',
            ],
        ];
    }
 
    public function ‪stdWrapReturnsExpectation(string $content, array $configuration, string $expectation): void
    {
        self::assertSame($expectation, $this->subject->stdWrap($content, $configuration));
    }
 
    public static function ‪stdWrapDoesOnlyCallIfEmptyIfTheTrimmedContentIsEmptyOrZeroDataProvider(): array
    {
        return [
            'ifEmpty is not called if content is present as an non-empty string' => [
                'content' => 'some content',
                'ifEmptyShouldBeCalled' => false,
            ],
            'ifEmpty is not called if content is present as the string "1"' => [
                'content' => '1',
                'ifEmptyShouldBeCalled' => false,
            ],
            'ifEmpty is called if content is present as an empty string' => [
                'content' => '',
                'ifEmptyShouldBeCalled' => true,
            ],
            'ifEmpty is called if content is present as the string "0"' => [
                'content' => '0',
                'ifEmptyShouldBeCalled' => true,
            ],
        ];
    }
 
    public function ‪stdWrapDoesOnlyCallIfEmptyIfTheTrimmedContentIsEmptyOrZero(string $content, bool $ifEmptyShouldBeCalled): void
    {
        $conf = [
            'ifEmpty.' => [
                'cObject' => 'TEXT',
            ],
        ];
 
        ‪$subject = $this->getAccessibleMock(ContentObjectRenderer::class, ['stdWrap_ifEmpty']);
        $request = new ‪ServerRequest();
        ‪$subject->setRequest($request);
        ‪$subject->expects(self::exactly(($ifEmptyShouldBeCalled ? 1 : 0)))
            ->method('stdWrap_ifEmpty');
 
        ‪$subject->stdWrap($content, $conf);
    }
 
    public static function ‪substringDataProvider(): array
    {
        return [
            'sub -1' => ['g', 'substring', '-1'],
            'sub -1,0' => ['g', 'substring', '-1,0'],
            'sub -1,-1' => ['', 'substring', '-1,-1'],
            'sub -1,1' => ['g', 'substring', '-1,1'],
            'sub 0' => ['substring', 'substring', '0'],
            'sub 0,0' => ['substring', 'substring', '0,0'],
            'sub 0,-1' => ['substrin', 'substring', '0,-1'],
            'sub 0,1' => ['s', 'substring', '0,1'],
            'sub 1' => ['ubstring', 'substring', '1'],
            'sub 1,0' => ['ubstring', 'substring', '1,0'],
            'sub 1,-1' => ['ubstrin', 'substring', '1,-1'],
            'sub 1,1' => ['u', 'substring', '1,1'],
            'sub' => ['substring', 'substring', ''],
        ];
    }
 
    public function ‪substring(string $expect, string $content, string $conf): void
    {
        self::assertSame($expect, $this->subject->substring($content, $conf));
    }
 
    public static function ‪getDataWithTypeGpDataProvider(): array
    {
        return [
            'Value in get-data' => ['onlyInGet', 'GetValue'],
            'Value in post-data' => ['onlyInPost', 'PostValue'],
            'Value in post-data overriding get-data' => ['inGetAndPost', 'ValueInPost'],
        ];
    }
 
    public function ‪getDataWithTypeGp(string $key, string $expectedValue): void
    {
        $queryArguments = [
            'onlyInGet' => 'GetValue',
            'inGetAndPost' => 'ValueInGet',
        ];
        $postParameters = [
            'onlyInPost' => 'PostValue',
            'inGetAndPost' => 'ValueInPost',
        ];
        $request = new ‪ServerRequest('https://example.com');
        $request = $request->withQueryParams($queryArguments)
            ->withParsedBody($postParameters);
        $this->subject->setRequest($request);
        self::assertEquals($expectedValue, $this->subject->getData('gp:' . $key));
    }
 
    public function ‪getDataWithTypeTsfe(): void
    {
        ‪$GLOBALS['TSFE']->linkVars = 'foo';
        self::assertEquals(‪$GLOBALS['TSFE']->linkVars, $this->subject->getData('tsfe:linkVars'));
    }
 
    public function ‪getDataWithTypeGetenv(): void
    {
        $envName = ‪StringUtility::getUniqueId('frontendtest');
        $value = ‪StringUtility::getUniqueId('someValue');
        putenv($envName . '=' . $value);
        self::assertEquals($value, $this->subject->getData('getenv:' . $envName));
    }
 
    public function ‪getDataWithTypeGetindpenv(): void
    {
        $this->subject->expects(self::once())->method('getEnvironmentVariable')
            ->with(self::equalTo('SCRIPT_FILENAME'))->willReturn('dummyPath');
        self::assertEquals('dummyPath', $this->subject->getData('getindpenv:SCRIPT_FILENAME'));
    }
 
    public function ‪getDataWithTypeField(): void
    {
        $key = 'someKey';
        $value = 'someValue';
        $field = [$key => $value];
 
        self::assertEquals($value, $this->subject->getData('field:' . $key, $field));
    }
 
    public function ‪getDataWithTypeFieldAndFieldIsMultiDimensional(): void
    {
        $key = 'somekey|level1|level2';
        $value = 'somevalue';
        $field = ['somekey' => ['level1' => ['level2' => 'somevalue']]];
 
        self::assertEquals($value, $this->subject->getData('field:' . $key, $field));
    }
 
    public static function ‪getDataWithTypeFileReturnsUidOfFileObjectDataProvider(): array
    {
        return [
            'no whitespace' => [
                'typoScriptPath' => 'file:current:uid',
            ],
            'always whitespace' => [
                'typoScriptPath' => 'file : current : uid',
            ],
            'mixed whitespace' => [
                'typoScriptPath' => 'file:current : uid',
            ],
        ];
    }
 
    public function ‪getDataWithTypeFileReturnsUidOfFileObject(string $typoScriptPath): void
    {
        ‪$uid = ‪StringUtility::getUniqueId();
        $file = $this->createMock(File::class);
        $file->expects(self::once())->method('getUid')->willReturn(‪$uid);
        $this->subject->setCurrentFile($file);
        self::assertEquals(‪$uid, $this->subject->getData($typoScriptPath));
    }
 
    public function ‪getDataWithTypeParameters(): void
    {
        $key = ‪StringUtility::getUniqueId('someKey');
        $value = ‪StringUtility::getUniqueId('someValue');
        $this->subject->parameters[$key] = $value;
 
        self::assertEquals($value, $this->subject->getData('parameters:' . $key));
    }
 
    public function ‪getDataWithTypeRegister(): void
    {
        $key = ‪StringUtility::getUniqueId('someKey');
        $value = ‪StringUtility::getUniqueId('someValue');
        ‪$GLOBALS['TSFE']->register[$key] = $value;
 
        self::assertEquals($value, $this->subject->getData('register:' . $key));
    }
 
    public function ‪getDataWithTypeSession(): void
    {
        $frontendUser = $this->getMockBuilder(FrontendUserAuthentication::class)
            ->onlyMethods(['getSessionData'])
            ->getMock();
        $frontendUser->expects(self::once())->method('getSessionData')->with('myext')->willReturn([
            'mydata' => [
                'someValue' => 42,
            ],
        ]);
        ‪$GLOBALS['TSFE']->fe_user = $frontendUser;
 
        self::assertEquals(42, $this->subject->getData('session:myext|mydata|someValue'));
    }
 
    public function ‪getDataWithTypeLevel(): void
    {
        $rootline = [
            0 => ['uid' => 1, 'title' => 'title1'],
            1 => ['uid' => 2, 'title' => 'title2'],
            2 => ['uid' => 3, 'title' => 'title3'],
        ];
        ‪$GLOBALS['TSFE']->config['rootLine'] = $rootline;
        self::assertEquals(2, $this->subject->getData('level'));
    }
 
    public function ‪getDataWithTypeLeveltitle(): void
    {
        $rootline = [
            0 => ['uid' => 1, 'title' => 'title1'],
            1 => ['uid' => 2, 'title' => 'title2'],
            2 => ['uid' => 3, 'title' => ''],
        ];
        ‪$GLOBALS['TSFE']->config['rootLine'] = $rootline;
        self::assertEquals('', $this->subject->getData('leveltitle:-1'));
        // since "title3" is not set, it will slide to "title2"
        self::assertEquals('title2', $this->subject->getData('leveltitle:-1,slide'));
    }
 
    public function ‪getDataWithTypeLevelmedia(): void
    {
        $rootline = [
            0 => ['uid' => 1, 'title' => 'title1', 'media' => 'media1'],
            1 => ['uid' => 2, 'title' => 'title2', 'media' => 'media2'],
            2 => ['uid' => 3, 'title' => 'title3', 'media' => ''],
        ];
        ‪$GLOBALS['TSFE']->config['rootLine'] = $rootline;
        self::assertEquals('', $this->subject->getData('levelmedia:-1'));
        // since "title3" is not set, it will slide to "title2"
        self::assertEquals('media2', $this->subject->getData('levelmedia:-1,slide'));
    }
 
    public function ‪getDataWithTypeLeveluid(): void
    {
        $rootline = [
            0 => ['uid' => 1, 'title' => 'title1'],
            1 => ['uid' => 2, 'title' => 'title2'],
            2 => ['uid' => 3, 'title' => 'title3'],
        ];
        ‪$GLOBALS['TSFE']->config['rootLine'] = $rootline;
        self::assertEquals(3, $this->subject->getData('leveluid:-1'));
        // every element will have a uid - so adding slide doesn't really make sense, just for completeness
        self::assertEquals(3, $this->subject->getData('leveluid:-1,slide'));
    }
 
    public function ‪getDataWithTypeLevelfield(): void
    {
        $rootline = [
            0 => ['uid' => 1, 'title' => 'title1', 'testfield' => 'field1'],
            1 => ['uid' => 2, 'title' => 'title2', 'testfield' => 'field2'],
            2 => ['uid' => 3, 'title' => 'title3', 'testfield' => ''],
        ];
        ‪$GLOBALS['TSFE']->config['rootLine'] = $rootline;
        self::assertEquals('', $this->subject->getData('levelfield:-1,testfield'));
        self::assertEquals('field2', $this->subject->getData('levelfield:-1,testfield,slide'));
    }
 
    public function ‪getDataWithTypeFullrootline(): void
    {
        $rootline1 = [
            0 => ['uid' => 1, 'title' => 'title1', 'testfield' => 'field1'],
        ];
        $rootline2 = [
            0 => ['uid' => 1, 'title' => 'title1', 'testfield' => 'field1'],
            1 => ['uid' => 2, 'title' => 'title2', 'testfield' => 'field2'],
            2 => ['uid' => 3, 'title' => 'title3', 'testfield' => 'field3'],
        ];
 
        ‪$GLOBALS['TSFE']->config['rootLine'] = $rootline1;
        ‪$GLOBALS['TSFE']->rootLine = $rootline2;
        self::assertEquals('field2', $this->subject->getData('fullrootline:-1,testfield'));
    }
 
    public function ‪getDataWithTypeDate(): void
    {
        $format = 'Y-M-D';
        $defaultFormat = 'd/m Y';
 
        self::assertEquals(date($format, ‪$GLOBALS['EXEC_TIME']), $this->subject->getData('date:' . $format));
        self::assertEquals(date($defaultFormat, ‪$GLOBALS['EXEC_TIME']), $this->subject->getData('date'));
    }
 
    public function ‪getDataWithTypePage(): void
    {
        ‪$uid = random_int(0, mt_getrandmax());
        ‪$GLOBALS['TSFE']->page['uid'] = ‪$uid;
        self::assertEquals(‪$uid, $this->subject->getData('page:uid'));
    }
 
    public function ‪getDataWithTypeCurrent(): void
    {
        $key = ‪StringUtility::getUniqueId('someKey');
        $value = ‪StringUtility::getUniqueId('someValue');
        $this->subject->data[$key] = $value;
        $this->subject->currentValKey = $key;
        self::assertEquals($value, $this->subject->getData('current'));
    }
 
    public function ‪getDataWithTypeDbReturnsCorrectTitle()
    {
        $dummyRecord = ['uid' => 5, 'title' => 'someTitle'];
        ‪$GLOBALS['TSFE']->sys_page->expects(self::once())->method('getRawRecord')->with('tt_content', '106')->willReturn($dummyRecord);
        self::assertSame('someTitle', $this->subject->getData('db:tt_content:106:title'));
    }
 
    public static function ‪getDataWithTypeDbDataProvider(): array
    {
        return [
            'identifier with missing table, uid and column' => [
                'identifier' => 'db',
                'expectsMethodCall' => self::never(),
            ],
            'identifier with empty table, missing uid and column' => [
                'identifier' => 'db:',
                'expectsMethodCall' => self::never(),
            ],
            'identifier with missing table and column' => [
                'identifier' => 'db:tt_content',
                'expectsMethodCall' => self::never(),
            ],
            'identifier with empty table and missing uid and column' => [
                'identifier' => 'db:tt_content:',
                'expectsMethodCall' => self::never(),
            ],
            'identifier with empty uid and missing column' => [
                'identifier' => 'db:tt_content:106',
                'expectsMethodCall' => self::once(),
            ],
            'identifier with empty uid and column' => [
                'identifier' => 'db:tt_content:106:',
                'expectsMethodCall' => self::once(),
            ],
            'identifier with empty uid and not existing column' => [
                'identifier' => 'db:tt_content:106:not_existing_column',
                'expectsMethodCall' => self::once(),
            ],
        ];
    }
 
    public function ‪getDataWithTypeDbReturnsEmptyStringOnInvalidIdentifiers(string ‪$identifier, InvocationOrder $expectsMethodCall): void
    {
        $dummyRecord = ['uid' => 5, 'title' => 'someTitle'];
        ‪$GLOBALS['TSFE']->sys_page->expects($expectsMethodCall)->method('getRawRecord')->with('tt_content', '106')->willReturn($dummyRecord);
        self::assertSame('', $this->subject->getData(‪$identifier));
    }
 
    public function ‪getDataWithTypeLll(): void
    {
        $key = ‪StringUtility::getUniqueId('someKey');
        $value = ‪StringUtility::getUniqueId('someValue');
        $languageServiceFactory = $this->createMock(LanguageServiceFactory::class);
        $languageServiceMock = $this->createMock(LanguageService::class);
        $languageServiceFactory->expects(self::once())->method('createFromSiteLanguage')->with(self::anything())->willReturn($languageServiceMock);
        GeneralUtility::addInstance(LanguageServiceFactory::class, $languageServiceFactory);
        $languageServiceMock->expects(self::once())->method('sL')->with('LLL:' . $key)->willReturn($value);
        self::assertEquals($value, $this->subject->getData('lll:' . $key));
    }
 
    public function ‪getDataWithTypePath(): void
    {
        $filenameIn = 'typo3/sysext/frontend/Public/Icons/Extension.svg';
        self::assertEquals($filenameIn, $this->subject->getData('path:' . $filenameIn));
    }
 
    public function ‪getDataWithTypeContext(): void
    {
        $context = new ‪Context([
            'workspace' => new WorkspaceAspect(3),
            'frontend.user' => new UserAspect(new FrontendUserAuthentication(), [0, -1]),
        ]);
        GeneralUtility::setSingletonInstance(Context::class, $context);
        self::assertEquals(3, $this->subject->getData('context:workspace:id'));
        self::assertEquals('0,-1', $this->subject->getData('context:frontend.user:groupIds'));
        self::assertFalse($this->subject->getData('context:frontend.user:isLoggedIn'));
        self::assertSame('', $this->subject->getData('context:frontend.user:foozball'));
    }
 
    public function ‪getDataWithTypeSite(): void
    {
        $site = new Site('my-site', 123, [
            'base' => 'http://example.com',
            'custom' => [
                'config' => [
                    'nested' => 'yeah',
                ],
            ],
        ]);
        $this->frontendControllerMock->_set('site', $site);
        self::assertEquals('http://example.com', $this->subject->getData('site:base'));
        self::assertEquals('yeah', $this->subject->getData('site:custom.config.nested'));
    }
 
    public function ‪getDataWithTypeSiteWithBaseVariants(): void
    {
        $packageManager = new PackageManager(new DependencyOrderingService());
        GeneralUtility::addInstance(ProviderConfigurationLoader::class, new ProviderConfigurationLoader(
            $packageManager,
            new NullFrontend('core'),
            'ExpressionLanguageProviders'
        ));
        GeneralUtility::addInstance(DefaultProvider::class, new DefaultProvider(new Typo3Version(), new Context(), new Features()));
 
        putenv('LOCAL_DEVELOPMENT=1');
 
        $site = new Site('my-site', 123, [
            'base' => 'http://prod.com',
            'baseVariants' => [
                [
                    'base' => 'http://staging.com',
                    'condition' => 'applicationContext == "Production/Staging"',
                ],
                [
                    'base' => 'http://dev.com',
                    'condition' => 'getenv("LOCAL_DEVELOPMENT") == 1',
                ],
            ],
        ]);
 
        $this->frontendControllerMock->_set('site', $site);
        self::assertEquals('http://dev.com', $this->subject->getData('site:base'));
    }
 
    public function ‪getDataWithTypeSiteLanguage(): void
    {
        $site = $this->‪createSiteWithLanguage([
            'base' => '/',
            'languageId' => 1,
            'locale' => 'de_DE',
            'title' => 'languageTitle',
            'navigationTitle' => 'German',
        ]);
        $language = $site->getLanguageById(1);
        $this->frontendControllerMock->_set('language', $language);
        self::assertEquals('German', $this->subject->getData('siteLanguage:navigationTitle'));
        self::assertEquals('de', $this->subject->getData('siteLanguage:twoLetterIsoCode'));
        self::assertEquals('de', $this->subject->getData('siteLanguage:locale:languageCode'));
        self::assertEquals('de-DE', $this->subject->getData('siteLanguage:hreflang'));
        self::assertEquals('de-DE', $this->subject->getData('siteLanguage:locale:full'));
    }
 
    public function ‪getDataWithTypeParentRecordNumber(): void
    {
        $recordNumber = random_int(0, mt_getrandmax());
        $this->subject->parentRecordNumber = $recordNumber;
        self::assertEquals($recordNumber, $this->subject->getData('cobj:parentRecordNumber'));
    }
 
    public function ‪getDataWithTypeDebugRootline(): void
    {
        $rootline = [
            0 => ['uid' => 1, 'title' => 'title1'],
            1 => ['uid' => 2, 'title' => 'title2'],
            2 => ['uid' => 3, 'title' => ''],
        ];
        $expectedResult = 'array(3items)0=>array(2items)uid=>1(integer)title=>"title1"(6chars)1=>array(2items)uid=>2(integer)title=>"title2"(6chars)2=>array(2items)uid=>3(integer)title=>""(0chars)';
        ‪$GLOBALS['TSFE']->config['rootLine'] = $rootline;
 
        ‪DebugUtility::useAnsiColor(false);
        $result = $this->subject->getData('debug:rootLine');
        $cleanedResult = str_replace(["\r", "\n", "\t", ' '], '', $result);
 
        self::assertEquals($expectedResult, $cleanedResult);
    }
 
    public function ‪getDataWithTypeDebugFullRootline(): void
    {
        $rootline = [
            0 => ['uid' => 1, 'title' => 'title1'],
            1 => ['uid' => 2, 'title' => 'title2'],
            2 => ['uid' => 3, 'title' => ''],
        ];
        $expectedResult = 'array(3items)0=>array(2items)uid=>1(integer)title=>"title1"(6chars)1=>array(2items)uid=>2(integer)title=>"title2"(6chars)2=>array(2items)uid=>3(integer)title=>""(0chars)';
        ‪$GLOBALS['TSFE']->rootLine = $rootline;
 
        ‪DebugUtility::useAnsiColor(false);
        $result = $this->subject->getData('debug:fullRootLine');
        $cleanedResult = str_replace(["\r", "\n", "\t", ' '], '', $result);
 
        self::assertEquals($expectedResult, $cleanedResult);
    }
 
    public function ‪getDataWithTypeDebugData(): void
    {
        $key = ‪StringUtility::getUniqueId('someKey');
        $value = ‪StringUtility::getUniqueId('someValue');
        $this->subject->data = [$key => $value];
 
        $expectedResult = 'array(1item)' . $key . '=>"' . $value . '"(' . strlen($value) . 'chars)';
 
        ‪DebugUtility::useAnsiColor(false);
        $result = $this->subject->getData('debug:data');
        $cleanedResult = str_replace(["\r", "\n", "\t", ' '], '', $result);
 
        self::assertEquals($expectedResult, $cleanedResult);
    }
 
    public function ‪getDataWithTypeDebugRegister(): void
    {
        $key = ‪StringUtility::getUniqueId('someKey');
        $value = ‪StringUtility::getUniqueId('someValue');
        ‪$GLOBALS['TSFE']->register = [$key => $value];
 
        $expectedResult = 'array(1item)' . $key . '=>"' . $value . '"(' . strlen($value) . 'chars)';
 
        ‪DebugUtility::useAnsiColor(false);
        $result = $this->subject->getData('debug:register');
        $cleanedResult = str_replace(["\r", "\n", "\t", ' '], '', $result);
 
        self::assertEquals($expectedResult, $cleanedResult);
    }
 
    public function ‪getDataWithTypeDebugPage(): void
    {
        ‪$uid = random_int(0, mt_getrandmax());
        ‪$GLOBALS['TSFE']->page = ['uid' => ‪$uid];
 
        $expectedResult = 'array(1item)uid=>' . ‪$uid . '(integer)';
 
        ‪DebugUtility::useAnsiColor(false);
        $result = $this->subject->getData('debug:page');
        $cleanedResult = str_replace(["\r", "\n", "\t", ' '], '', $result);
 
        self::assertEquals($expectedResult, $cleanedResult);
    }
 
    public function ‪renderingContentObjectThrowsException(): void
    {
        $this->expectException(\LogicException::class);
        $this->expectExceptionCode(1414513947);
        $contentObjectFixture = $this->‪createContentObjectThrowingExceptionFixture(false);
        $this->subject->render($contentObjectFixture, []);
    }
 
    public function ‪exceptionHandlerIsEnabledByDefaultInProductionContext(): void
    {
        ‪Environment::initialize(
            new ApplicationContext('Production'),
            true,
            false,
            ‪Environment::getProjectPath(),
            ‪Environment::getPublicPath(),
            ‪Environment::getVarPath(),
            ‪Environment::getConfigPath(),
            ‪Environment::getPublicPath() . '/index.php',
            ‪Environment::isWindows() ? 'WINDOWS' : 'UNIX'
        );
        $contentObjectFixture = $this->‪createContentObjectThrowingExceptionFixture();
        $this->subject->render($contentObjectFixture, []);
    }
 
    public function ‪renderingContentObjectDoesNotThrowExceptionIfExceptionHandlerIsConfiguredLocally(): void
    {
        $contentObjectFixture = $this->‪createContentObjectThrowingExceptionFixture();
 
        $configuration = [
            'exceptionHandler' => '1',
        ];
        $this->subject->render($contentObjectFixture, $configuration);
    }
 
    public function ‪renderingContentObjectDoesNotThrowExceptionIfExceptionHandlerIsConfiguredGlobally(): void
    {
        $contentObjectFixture = $this->‪createContentObjectThrowingExceptionFixture();
 
        $this->frontendControllerMock->config['config']['contentObjectExceptionHandler'] = '1';
        $this->subject->render($contentObjectFixture, []);
    }
 
    public function ‪globalExceptionHandlerConfigurationCanBeOverriddenByLocalConfiguration(): void
    {
        $contentObjectFixture = $this->‪createContentObjectThrowingExceptionFixture(false);
        $this->expectException(\LogicException::class);
        $this->expectExceptionCode(1414513947);
        $this->frontendControllerMock->config['config']['contentObjectExceptionHandler'] = '1';
        $configuration = [
            'exceptionHandler' => '0',
        ];
        $this->subject->render($contentObjectFixture, $configuration);
    }
 
    public function ‪renderedErrorMessageCanBeCustomized(): void
    {
        $contentObjectFixture = $this->‪createContentObjectThrowingExceptionFixture();
 
        $configuration = [
            'exceptionHandler' => '1',
            'exceptionHandler.' => [
                'errorMessage' => 'New message for testing',
            ],
        ];
 
        self::assertSame('New message for testing', $this->subject->render($contentObjectFixture, $configuration));
    }
 
    public function ‪localConfigurationOverridesGlobalConfiguration(): void
    {
        $contentObjectFixture = $this->‪createContentObjectThrowingExceptionFixture();
 
        $this->frontendControllerMock
            ->config['config']['contentObjectExceptionHandler.'] = [
            'errorMessage' => 'Global message for testing',
        ];
        $configuration = [
            'exceptionHandler' => '1',
            'exceptionHandler.' => [
                'errorMessage' => 'New message for testing',
            ],
        ];
 
        self::assertSame('New message for testing', $this->subject->render($contentObjectFixture, $configuration));
    }
 
    public function ‪specificExceptionsCanBeIgnoredByExceptionHandler(): void
    {
        $contentObjectFixture = $this->‪createContentObjectThrowingExceptionFixture();
 
        $configuration = [
            'exceptionHandler' => '1',
            'exceptionHandler.' => [
                'ignoreCodes.' => ['10.' => '1414513947'],
            ],
        ];
        $this->expectException(\LogicException::class);
        $this->expectExceptionCode(1414513947);
        $this->subject->render($contentObjectFixture, $configuration);
    }
 
    protected function ‪createContentObjectThrowingExceptionFixture(bool $addProductionExceptionHandlerInstance = true): ‪AbstractContentObject&MockObject
    {
        $contentObjectFixture = $this->getMockBuilder(AbstractContentObject::class)
            ->getMock();
        $contentObjectFixture->expects(self::once())
            ->method('render')
            ->willReturnCallback(static function () {
                throw new \LogicException('Exception during rendering', 1414513947);
            });
        $contentObjectFixture->‪setContentObjectRenderer($this->subject);
        if ($addProductionExceptionHandlerInstance) {
            GeneralUtility::addInstance(
                ProductionExceptionHandler::class,
                new ‪ProductionExceptionHandler(new ‪Context(), new ‪Random(), new NullLogger())
            );
        }
        return $contentObjectFixture;
    }
 
    protected function ‪getLibParseFunc(): array
    {
        return [
            'makelinks' => '1',
            'makelinks.' => [
                'http.' => [
                    'keep' => '{$styles.content.links.keep}',
                    'extTarget' => '',
                    'mailto.' => [
                        'keep' => 'path',
                    ],
                ],
            ],
            'tags' => [
                'link' => 'TEXT',
                'link.' => [
                    'current' => '1',
                    'typolink.' => [
                        'parameter.' => [
                            'data' => 'parameters : allParams',
                        ],
                    ],
                    'parseFunc.' => [
                        'constants' => '1',
                    ],
                ],
            ],
 
            'allowTags' => 'a, abbr, acronym, address, article, aside, b, bdo, big, blockquote, br, caption, center, cite, code, col, colgroup, dd, del, dfn, dl, div, dt, em, font, footer, header, h1, h2, h3, h4, h5, h6, hr, i, img, ins, kbd, label, li, link, meta, nav, ol, p, pre, q, samp, sdfield, section, small, span, strike, strong, style, sub, sup, table, thead, tbody, tfoot, td, th, tr, title, tt, u, ul, var',
            'denyTags' => '*',
            'sword' => '<span class="csc-sword">|</span>',
            'constants' => '1',
            'nonTypoTagStdWrap.' => [
                'HTMLparser' => '1',
                'HTMLparser.' => [
                    'keepNonMatchedTags' => '1',
                    'htmlSpecialChars' => '2',
                ],
            ],
        ];
    }
 
    public function ‪_parseFuncReturnsCorrectHtmlDataProvider(): array
    {
        return [
            'Text without tag is wrapped with <p> tag' => [
                'Text without tag',
                $this->‪getLibParseFunc_RTE(),
                '<p class="bodytext">Text without tag</p>',
                false,
            ],
            'Text wrapped with <p> tag remains the same' => [
                '<p class="myclass">Text with &lt;p&gt; tag</p>',
                $this->‪getLibParseFunc_RTE(),
                '<p class="myclass">Text with &lt;p&gt; tag</p>',
                false,
            ],
            'Text with absolute external link' => [
                'Text with <link http://example.com/foo/>external link</link>',
                $this->‪getLibParseFunc_RTE(),
                '<p class="bodytext">Text with <a href="http://example.com/foo/">external link</a></p>',
                (new LinkResult(‪LinkService::TYPE_URL, 'http://example.com/foo/'))->withLinkText('external link'),
            ],
            'Empty lines are not duplicated' => [
                LF,
                $this->‪getLibParseFunc_RTE(),
                '<p class="bodytext">&nbsp;</p>',
                false,
            ],
            'Multiple empty lines with no text' => [
                LF . LF . LF,
                $this->‪getLibParseFunc_RTE(),
                '<p class="bodytext">&nbsp;</p>' . LF . '<p class="bodytext">&nbsp;</p>' . LF . '<p class="bodytext">&nbsp;</p>',
                false,
            ],
            'Empty lines are not duplicated at the end of content' => [
                'test' . LF . LF,
                $this->‪getLibParseFunc_RTE(),
                '<p class="bodytext">test</p>' . LF . '<p class="bodytext">&nbsp;</p>',
                false,
            ],
            'Empty lines are not trimmed' => [
                LF . 'test' . LF,
                $this->‪getLibParseFunc_RTE(),
                '<p class="bodytext">&nbsp;</p>' . LF . '<p class="bodytext">test</p>' . LF . '<p class="bodytext">&nbsp;</p>',
                false,
            ],
        ];
    }
 
    public function ‪stdWrap_parseFuncReturnsParsedHtml(string $value, array $configuration, string $expectedResult, ‪LinkResultInterface|false $linkResult): void
    {
        if ($linkResult !== false) {
            $linkFactory = $this->getMockBuilder(LinkFactory::class)->disableOriginalConstructor()->getMock();
            $linkFactory->method('create')->willReturn($linkResult);
            GeneralUtility::addInstance(LinkFactory::class, $linkFactory);
        }
        self::assertEquals($expectedResult, $this->subject->stdWrap_parseFunc($value, $configuration));
    }
 
    public static function ‪_parseFuncParsesNestedTagsProperlyDataProvider(): array
    {
        $defaultListItemParseFunc = [
            'parseFunc'  => '',
            'parseFunc.' => [
                'tags.' => [
                    'li'  => 'TEXT',
                    'li.' => [
                        'wrap'    => '<li>LI:|</li>',
                        'current' => '1',
                    ],
                ],
            ],
        ];
 
        return [
            'parent & child tags with same beginning are processed' => [
                '<div><any data-skip><anyother data-skip>content</anyother></any></div>',
                [
                    'parseFunc'  => '',
                    'parseFunc.' => [
                        'tags.' => [
                            'any' => 'TEXT',
                            'any.' => [
                                'wrap' => '<any data-processed>|</any>',
                                'current' => 1,
                            ],
                            'anyother' => 'TEXT',
                            'anyother.' => [
                                'wrap' => '<anyother data-processed>|</anyother>',
                                'current' => 1,
                            ],
                        ],
                        'htmlSanitize' => true,
                        'htmlSanitize.' => [
                            'build' => TestSanitizerBuilder::class,
                        ],
                    ],
                ],
                '<div><any data-processed><anyother data-processed>content</anyother></any></div>',
            ],
            'list with empty and filled li' => [
                '<ul>
    <li></li>
    <li>second</li>
</ul>',
                $defaultListItemParseFunc,
                '<ul>
    <li>LI:</li>
    <li>LI:second</li>
</ul>',
            ],
            'list with filled li wrapped by a div containing text' => [
                '<div>text<ul><li></li><li>second</li></ul></div>',
                $defaultListItemParseFunc,
                '<div>text<ul><li>LI:</li><li>LI:second</li></ul></div>',
            ],
            'link list with empty li modification' => [
                '<ul>
    <li>
        <ul>
            <li></li>
        </ul>
    </li>
</ul>',
                $defaultListItemParseFunc,
                '<ul>
    <li>LI:
        <ul>
            <li>LI:</li>
        </ul>
    </li>
</ul>',
            ],
 
            'link list with li modifications' => [
                '<ul>
    <li>first</li>
    <li>second
        <ul>
            <li>first sub</li>
            <li>second sub</li>
        </ul>
    </li>
</ul>',
                $defaultListItemParseFunc,
                '<ul>
    <li>LI:first</li>
    <li>LI:second
        <ul>
            <li>LI:first sub</li>
            <li>LI:second sub</li>
        </ul>
    </li>
</ul>',
            ],
            'link list with li modifications and no text' => [
                '<ul>
    <li>first</li>
    <li>
        <ul>
            <li>first sub</li>
            <li>second sub</li>
        </ul>
    </li>
</ul>',
                $defaultListItemParseFunc,
                '<ul>
    <li>LI:first</li>
    <li>LI:
        <ul>
            <li>LI:first sub</li>
            <li>LI:second sub</li>
        </ul>
    </li>
</ul>',
            ],
            'link list with li modifications on third level' => [
                '<ul>
    <li>first</li>
    <li>second
        <ul>
            <li>first sub
                <ul>
                    <li>first sub sub</li>
                    <li>second sub sub</li>
                </ul>
            </li>
            <li>second sub</li>
        </ul>
    </li>
</ul>',
                $defaultListItemParseFunc,
                '<ul>
    <li>LI:first</li>
    <li>LI:second
        <ul>
            <li>LI:first sub
                <ul>
                    <li>LI:first sub sub</li>
                    <li>LI:second sub sub</li>
                </ul>
            </li>
            <li>LI:second sub</li>
        </ul>
    </li>
</ul>',
            ],
            'link list with li modifications on third level no text' => [
                '<ul>
    <li>first</li>
    <li>
        <ul>
            <li>
                <ul>
                    <li>first sub sub</li>
                    <li>first sub sub</li>
                </ul>
            </li>
            <li>second sub</li>
        </ul>
    </li>
</ul>',
                $defaultListItemParseFunc,
                '<ul>
    <li>LI:first</li>
    <li>LI:
        <ul>
            <li>LI:
                <ul>
                    <li>LI:first sub sub</li>
                    <li>LI:first sub sub</li>
                </ul>
            </li>
            <li>LI:second sub</li>
        </ul>
    </li>
</ul>',
            ],
            'link list with ul and li modifications' => [
                '<ul>
    <li>first</li>
    <li>second
        <ul>
            <li>first sub</li>
            <li>second sub</li>
        </ul>
    </li>
</ul>',
                [
                    'parseFunc'  => '',
                    'parseFunc.' => [
                        'tags.' => [
                            'ul'  => 'TEXT',
                            'ul.' => [
                                'wrap'    => '<ul><li>intro</li>|<li>outro</li></ul>',
                                'current' => '1',
                            ],
                            'li'  => 'TEXT',
                            'li.' => [
                                'wrap'    => '<li>LI:|</li>',
                                'current' => '1',
                            ],
                        ],
                    ],
                ],
                '<ul><li>intro</li>
    <li>LI:first</li>
    <li>LI:second
        <ul><li>intro</li>
            <li>LI:first sub</li>
            <li>LI:second sub</li>
        <li>outro</li></ul>
    </li>
<li>outro</li></ul>',
            ],
 
            'link list with li containing p tag and sub list' => [
                '<ul>
    <li>first</li>
    <li>
        <ul>
            <li>
                <span>
                    <ul>
                        <li>first sub sub</li>
                        <li>first sub sub</li>
                    </ul>
                </span>
            </li>
            <li>second sub</li>
        </ul>
    </li>
</ul>',
                $defaultListItemParseFunc,
                '<ul>
    <li>LI:first</li>
    <li>LI:
        <ul>
            <li>LI:
                <span>
                    <ul>
                        <li>LI:first sub sub</li>
                        <li>LI:first sub sub</li>
                    </ul>
                </span>
            </li>
            <li>LI:second sub</li>
        </ul>
    </li>
</ul>',
            ],
        ];
    }
 
    public function ‪parseFuncParsesNestedTagsProperly(string $value, array $configuration, string $expectedResult): void
    {
        self::assertEquals($expectedResult, $this->subject->stdWrap_parseFunc($value, $configuration));
    }
 
    public static function ‪httpMakelinksDataProvider(): array
    {
        return [
            'http link' => [
                'Some text with a link http://example.com',
                [
                ],
                'Some text with a link <a href="http://example.com">example.com</a>',
                (new LinkResult(‪LinkService::TYPE_URL, 'http://example.com'))->withLinkText('example.com'),
            ],
            'http link with path' => [
                'Some text with a link http://example.com/path/to/page',
                [
                ],
                'Some text with a link <a href="http://example.com/path/to/page">example.com</a>',
                (new LinkResult(‪LinkService::TYPE_URL, 'http://example.com/path/to/page'))->withLinkText('example.com'),
            ],
            'http link with query parameter' => [
                'Some text with a link http://example.com?foo=bar',
                [
                ],
                'Some text with a link <a href="http://example.com?foo=bar">example.com</a>',
                (new LinkResult(‪LinkService::TYPE_URL, 'http://example.com?foo=bar'))->withLinkText('example.com'),
            ],
            'http link with question mark' => [
                'Some text with a link http://example.com?',
                [
                ],
                'Some text with a link <a href="http://example.com">example.com</a>?',
                (new LinkResult(‪LinkService::TYPE_URL, 'http://example.com'))->withLinkText('example.com'),
            ],
            'http link with period' => [
                'Some text with a link http://example.com.',
                [
                ],
                'Some text with a link <a href="http://example.com">example.com</a>.',
                (new LinkResult(‪LinkService::TYPE_URL, 'http://example.com'))->withLinkText('example.com'),
            ],
            'http link with fragment' => [
                'Some text with a link http://example.com#',
                [
                ],
                'Some text with a link <a href="http://example.com#">example.com</a>',
                (new LinkResult(‪LinkService::TYPE_URL, 'http://example.com#'))->withLinkText('example.com'),
            ],
            'http link with query parameter and fragment' => [
                'Some text with a link http://example.com?foo=bar#top',
                [
                ],
                'Some text with a link <a href="http://example.com?foo=bar#top">example.com</a>',
                (new LinkResult(‪LinkService::TYPE_URL, 'http://example.com?foo=bar#top'))->withLinkText('example.com'),
            ],
            'http link with query parameter and keep scheme' => [
                'Some text with a link http://example.com/path/to/page?foo=bar',
                [
                    'keep' => 'scheme',
                ],
                'Some text with a link <a href="http://example.com/path/to/page?foo=bar">http://example.com</a>',
                (new LinkResult(‪LinkService::TYPE_URL, 'http://example.com/path/to/page?foo=bar'))->withLinkText('http://example.com'),
            ],
            'http link with query parameter and keep path' => [
                'Some text with a link http://example.com/path/to/page?foo=bar',
                [
                    'keep' => 'path',
                ],
                'Some text with a link <a href="http://example.com/path/to/page?foo=bar">example.com/path/to/page</a>',
                (new LinkResult(‪LinkService::TYPE_URL, 'http://example.com/path/to/page?foo=bar'))->withLinkText('example.com/path/to/page'),
            ],
            'http link with query parameter and keep path with trailing slash' => [
                'Some text with a link http://example.com/path/to/page/?foo=bar',
                [
                    'keep' => 'path',
                ],
                'Some text with a link <a href="http://example.com/path/to/page/?foo=bar">example.com/path/to/page/</a>',
                (new LinkResult(‪LinkService::TYPE_URL, 'http://example.com/path/to/page/?foo=bar'))->withLinkText('example.com/path/to/page/'),
            ],
            'http link with trailing slash and keep path with trailing slash' => [
                'Some text with a link http://example.com/',
                [
                    'keep' => 'path',
                ],
                'Some text with a link <a href="http://example.com/">example.com</a>',
                (new LinkResult(‪LinkService::TYPE_URL, 'http://example.com/'))->withLinkText('example.com'),
            ],
            'http link with query parameter and keep scheme,path' => [
                'Some text with a link http://example.com/path/to/page?foo=bar',
                [
                    'keep' => 'scheme,path',
                ],
                'Some text with a link <a href="http://example.com/path/to/page?foo=bar">http://example.com/path/to/page</a>',
                (new LinkResult(‪LinkService::TYPE_URL, 'http://example.com/path/to/page?foo=bar'))->withLinkText('http://example.com/path/to/page'),
            ],
            'http link with multiple query parameters' => [
                'Some text with a link http://example.com?foo=bar&fuz=baz',
                [
                    'keep' => 'scheme,path,query',
                ],
                'Some text with a link <a href="http://example.com?foo=bar&amp;fuz=baz">http://example.com?foo=bar&fuz=baz</a>',
                (new LinkResult(‪LinkService::TYPE_URL, 'http://example.com?foo=bar&fuz=baz'))->withLinkText('http://example.com?foo=bar&fuz=baz'),
            ],
            'http link with query parameter and keep scheme,path,query' => [
                'Some text with a link http://example.com/path/to/page?foo=bar',
                [
                    'keep' => 'scheme,path,query',
                ],
                'Some text with a link <a href="http://example.com/path/to/page?foo=bar">http://example.com/path/to/page?foo=bar</a>',
                (new LinkResult(‪LinkService::TYPE_URL, 'http://example.com/path/to/page?foo=bar'))->withLinkText('http://example.com/path/to/page?foo=bar'),
            ],
            'https link' => [
                'Some text with a link https://example.com',
                [
                ],
                'Some text with a link <a href="https://example.com">example.com</a>',
                (new LinkResult(‪LinkService::TYPE_URL, 'https://example.com'))->withLinkText('example.com'),
            ],
            'http link with www' => [
                'Some text with a link http://www.example.com',
                [
                ],
                'Some text with a link <a href="http://www.example.com">www.example.com</a>',
                (new LinkResult(‪LinkService::TYPE_URL, 'http://www.example.com'))->withLinkText('www.example.com'),
            ],
            'https link with www' => [
                'Some text with a link https://www.example.com',
                [
                ],
                'Some text with a link <a href="https://www.example.com">www.example.com</a>',
                (new LinkResult(‪LinkService::TYPE_URL, 'https://www.example.com'))->withLinkText('www.example.com'),
            ],
        ];
    }
 
    public function ‪httpMakelinksReturnsLink(string $data, array $configuration, string $expectedResult, LinkResult $linkResult): void
    {
        $linkFactory = $this->getMockBuilder(LinkFactory::class)->disableOriginalConstructor()->getMock();
        $linkFactory->method('create')->willReturn($linkResult);
        GeneralUtility::addInstance(LinkFactory::class, $linkFactory);
 
        self::assertSame($expectedResult, $this->subject->_call('http_makelinks', $data, $configuration));
    }
 
    public static function ‪invalidHttpMakelinksDataProvider(): array
    {
        return [
            'only http protocol' => [
                'http://',
                [
                ],
                'http://',
            ],
            'only https protocol' => [
                'https://',
                [
                ],
                'https://',
            ],
            'ftp link' => [
                'ftp://user@password:example.com',
                [
                ],
                'ftp://user@password:example.com',
            ],
        ];
    }
 
    public function ‪httpMakelinksReturnsNoLink(string $data, array $configuration, string $expectedResult): void
    {
        self::assertSame($expectedResult, $this->subject->_call('http_makelinks', $data, $configuration));
    }
 
    public static function ‪mailtoMakelinksDataProvider(): array
    {
        return [
            'mailto link' => [
                'Some text with an email address mailto:john@example.com',
                [
                ],
                'Some text with an email address <a href="mailto:john@example.com">john@example.com</a>',
                (new LinkResult(‪LinkService::TYPE_EMAIL, 'mailto:john@example.com'))->withLinkText('john@example.com'),
            ],
            'mailto link with subject parameter' => [
                'Some text with an email address mailto:john@example.com?subject=hi',
                [
                ],
                'Some text with an email address <a href="mailto:john@example.com?subject=hi">john@example.com</a>',
                (new LinkResult(‪LinkService::TYPE_EMAIL, 'mailto:john@example.com?subject=hi'))->withLinkText('john@example.com'),
            ],
            'mailto link with multiple parameters' => [
                'Some text with an email address mailto:john@example.com?subject=Greetings&body=Hi+John',
                [
                ],
                'Some text with an email address <a href="mailto:john@example.com?subject=Greetings&amp;body=Hi+John">john@example.com</a>',
                (new LinkResult(‪LinkService::TYPE_EMAIL, 'mailto:john@example.com?subject=Greetings&body=Hi+John'))->withLinkText('john@example.com'),
            ],
            'mailto link with question mark' => [
                'Some text with an email address mailto:john@example.com?',
                [
                ],
                'Some text with an email address <a href="mailto:john@example.com">john@example.com</a>?',
                (new LinkResult(‪LinkService::TYPE_EMAIL, 'mailto:john@example.com'))->withLinkText('john@example.com'),
            ],
            'mailto link with period' => [
                'Some text with an email address mailto:john@example.com.',
                [
                ],
                'Some text with an email address <a href="mailto:john@example.com">john@example.com</a>.',
                (new LinkResult(‪LinkService::TYPE_EMAIL, 'mailto:john@example.com'))->withLinkText('john@example.com'),
            ],
            'mailto link with wrap' => [
                'Some text with an email address mailto:john@example.com.',
                [
                    'wrap' => '<span>|</span>',
                ],
                'Some text with an email address <span><a href="mailto:john@example.com">john@example.com</a></span>.',
                (new LinkResult(‪LinkService::TYPE_EMAIL, 'mailto:john@example.com'))->withLinkText('john@example.com'),
            ],
            'mailto link with ATagBeforeWrap' => [
                'Some text with an email address mailto:john@example.com.',
                [
                    'wrap' => '<span>|</span>',
                    'ATagBeforeWrap' => 1,
                ],
                'Some text with an email address <a href="mailto:john@example.com"><span>john@example.com</span></a>.',
                (new LinkResult(‪LinkService::TYPE_EMAIL, 'mailto:john@example.com'))->withLinkText('john@example.com'),
            ],
            'mailto link with ATagParams' => [
                'Some text with an email address mailto:john@example.com.',
                [
                    'ATagParams' => 'class="email"',
                ],
                'Some text with an email address <a href="mailto:john@example.com" class="email">john@example.com</a>.',
                (new LinkResult(‪LinkService::TYPE_EMAIL, 'mailto:john@example.com'))->withAttribute('class', 'email')->withLinkText('john@example.com'),
            ],
        ];
    }
 
    public function ‪mailtoMakelinksReturnsMailToLink(string $data, array $configuration, string $expectedResult, LinkResult $linkResult): void
    {
        $linkFactory = $this->getMockBuilder(LinkFactory::class)->disableOriginalConstructor()->getMock();
        $linkFactory->method('create')->willReturn($linkResult);
        GeneralUtility::addInstance(LinkFactory::class, $linkFactory);
 
        self::assertSame($expectedResult, $this->subject->_call('mailto_makelinks', $data, $configuration));
    }
 
    public function ‪mailtoMakelinksReturnsNoMailToLink(): void
    {
        self::assertSame('mailto:', $this->subject->_call('mailto_makelinks', 'mailto:', []));
    }
 
    public static function ‪typolinkReturnsCorrectLinksForEmailsAndUrlsDataProvider(): array
    {
        return [
            'Link to url' => [
                'TYPO3',
                [
                    'directImageLink' => false,
                    'parameter' => 'http://typo3.org',
                ],
                '<a href="http://typo3.org">TYPO3</a>',
            ],
            'Link to url without schema' => [
                'TYPO3',
                [
                    'directImageLink' => false,
                    'parameter' => 'typo3.org',
                ],
                '<a href="http://typo3.org">TYPO3</a>',
            ],
            'Link to url without link text' => [
                '',
                [
                    'directImageLink' => false,
                    'parameter' => 'http://typo3.org',
                ],
                '<a href="http://typo3.org">http://typo3.org</a>',
            ],
            'Link to url with attributes' => [
                'TYPO3',
                [
                    'parameter' => 'http://typo3.org',
                    'ATagParams' => 'class="url-class"',
                    'extTarget' => '_blank',
                    'title' => 'Open new window',
                ],
                '<a href="http://typo3.org" target="_blank" class="url-class" rel="noreferrer" title="Open new window">TYPO3</a>',
            ],
            'Link to url with attributes and custom target name' => [
                'TYPO3',
                [
                    'parameter' => 'http://typo3.org',
                    'ATagParams' => 'class="url-class"',
                    'extTarget' => 'someTarget',
                    'title' => 'Open new window',
                ],
                '<a href="http://typo3.org" target="someTarget" class="url-class" rel="noreferrer" title="Open new window">TYPO3</a>',
            ],
            'Link to url with attributes in parameter' => [
                'TYPO3',
                [
                    'parameter' => 'http://typo3.org _blank url-class "Open new window"',
                ],
                '<a href="http://typo3.org" target="_blank" rel="noreferrer" title="Open new window" class="url-class">TYPO3</a>',
            ],
            'Link to url with attributes in parameter and custom target name' => [
                'TYPO3',
                [
                    'parameter' => 'http://typo3.org someTarget url-class "Open new window"',
                ],
                '<a href="http://typo3.org" target="someTarget" rel="noreferrer" title="Open new window" class="url-class">TYPO3</a>',
            ],
            'Link to url with script tag' => [
                '',
                [
                    'directImageLink' => false,
                    'parameter' => 'http://typo3.org<script>alert(123)</script>',
                ],
                '<a href="http://typo3.org&lt;script&gt;alert(123)&lt;/script&gt;">http://typo3.org&lt;script&gt;alert(123)&lt;/script&gt;</a>',
            ],
            'Link to email address' => [
                'Email address',
                [
                    'parameter' => 'foo@bar.org',
                ],
                '<a href="mailto:foo@bar.org">Email address</a>',
            ],
            'Link to email address with subject + cc' => [
                'Email address',
                [
                    'parameter' => 'foo@bar.org?subject=This%20is%20a%20test',
                ],
                '<a href="mailto:foo@bar.org?subject=This%20is%20a%20test">Email address</a>',
            ],
            'Link to email address without link text' => [
                '',
                [
                    'parameter' => 'foo@bar.org',
                ],
                '<a href="mailto:foo@bar.org">foo@bar.org</a>',
            ],
            'Link to email with attributes' => [
                'Email address',
                [
                    'parameter' => 'foo@bar.org',
                    'ATagParams' => 'class="email-class"',
                    'title' => 'Write an email',
                ],
                '<a href="mailto:foo@bar.org" class="email-class" title="Write an email">Email address</a>',
            ],
            'Link to email with attributes in parameter' => [
                'Email address',
                [
                    'parameter' => 'foo@bar.org - email-class "Write an email"',
                ],
                '<a href="mailto:foo@bar.org" title="Write an email" class="email-class">Email address</a>',
            ],
            'Link url using stdWrap' => [
                'TYPO3',
                [
                    'parameter' => 'http://typo3.org',
                    'parameter.' => [
                        'cObject' => 'TEXT',
                        'cObject.' => [
                            'value' => 'http://typo3.com',
                        ],
                    ],
                ],
                '<a href="http://typo3.com">TYPO3</a>',
            ],
            'Link url using stdWrap with class attribute in parameter' => [
                'TYPO3',
                [
                    'parameter' => 'http://typo3.org - url-class',
                    'parameter.' => [
                        'cObject' => 'TEXT',
                        'cObject.' => [
                            'value' => 'http://typo3.com',
                        ],
                    ],
                ],
                '<a href="http://typo3.com" class="url-class">TYPO3</a>',
            ],
            'Link url using stdWrap with class attribute in parameter and overridden target' => [
                'TYPO3',
                [
                    'parameter' => 'http://typo3.org default-target url-class',
                    'parameter.' => [
                        'cObject' => 'TEXT',
                        'cObject.' => [
                            'value' => 'http://typo3.com new-target different-url-class',
                        ],
                    ],
                ],
                '<a href="http://typo3.com" target="new-target" rel="noreferrer" class="different-url-class">TYPO3</a>',
            ],
            'Link url using stdWrap with class attribute in parameter and overridden target and returnLast' => [
                'TYPO3',
                [
                    'parameter' => 'http://typo3.org default-target url-class',
                    'parameter.' => [
                        'cObject' => 'TEXT',
                        'cObject.' => [
                            'value' => 'http://typo3.com new-target different-url-class',
                        ],
                    ],
                    'returnLast' => 'url',
                ],
                'http://typo3.com',
            ],
        ];
    }
 
    public function ‪typolinkReturnsCorrectLinksForEmailsAndUrls(string $linkText, array $configuration, string $expectedResult): void
    {
        $typoScriptFrontendControllerMockObject = $this->createMock(TypoScriptFrontendController::class);
        $typoScriptFrontendControllerMockObject->config = [
            'config' => [],
        ];
        ‪$GLOBALS['TSFE'] = $typoScriptFrontendControllerMockObject;
 
        $this->cacheManagerMock->method('getCache')->willReturnMap([
            ['runtime', new ‪NullFrontend('dummy')],
            ['core', new ‪NullFrontend('runtime')],
        ]);
 
        $siteConfiguration = new ‪SiteConfiguration(
            ‪Environment::getConfigPath() . '/sites',
            new class () implements EventDispatcherInterface {
                public function dispatch(object $event)
                {
                    return $event;
                }
            },
            new NullFrontend('dummy')
        );
        $this->subject->_set('typoScriptFrontendController', $typoScriptFrontendControllerMockObject);
        GeneralUtility::addInstance(ProviderConfigurationLoader::class, $this->createMock(ProviderConfigurationLoader::class));
        GeneralUtility::addInstance(DefaultProvider::class, new DefaultProvider(new Typo3Version(), new ‪Context(), new Features()));
        GeneralUtility::addInstance(LinkFactory::class, $this->‪getLinkFactory($siteConfiguration));
 
        self::assertEquals($expectedResult, $this->subject->typoLink($linkText, $configuration));
        // This can vanish when the condition provider have been moved towards service provider setup
        GeneralUtility::purgeInstances();
    }
 
    public function ‪typoLinkEncodesMailAddressForSpamProtection(
        array $settings,
        string $linkText,
        string $mailAddress,
        string $expected
    ): void {
        $this->‪getFrontendController()->config['config'] = $settings;
        $typoScript = ['parameter' => $mailAddress];
        GeneralUtility::addInstance(LinkFactory::class, $this->‪getLinkFactory());
        self::assertEquals($expected, $this->subject->typoLink($linkText, $typoScript));
    }
 
    public static function ‪typoLinkEncodesMailAddressForSpamProtectionDataProvider(): array
    {
        return [
            'plain mail without mailto scheme' => [
                [
                    'spamProtectEmailAddresses' => 0,
                    'spamProtectEmailAddresses_atSubst' => '',
                    'spamProtectEmailAddresses_lastDotSubst' => '',
                ],
                'some.body@test.typo3.org',
                'some.body@test.typo3.org',
                '<a href="mailto:some.body@test.typo3.org">some.body@test.typo3.org</a>',
            ],
            'plain mail with mailto scheme' => [
                [
                    'spamProtectEmailAddresses' => 0,
                    'spamProtectEmailAddresses_atSubst' => '',
                    'spamProtectEmailAddresses_lastDotSubst' => '',
                ],
                'some.body@test.typo3.org',
                'mailto:some.body@test.typo3.org',
                '<a href="mailto:some.body@test.typo3.org">some.body@test.typo3.org</a>',
            ],
            'plain with at and dot substitution' => [
                [
                    'spamProtectEmailAddresses' => 0,
                    'spamProtectEmailAddresses_atSubst' => '(at)',
                    'spamProtectEmailAddresses_lastDotSubst' => '(dot)',
                ],
                'some.body@test.typo3.org',
                'mailto:some.body@test.typo3.org',
                '<a href="mailto:some.body@test.typo3.org">some.body@test.typo3.org</a>',
            ],
            'mono-alphabetic substitution offset +1' => [
                [
                    'spamProtectEmailAddresses' => 1,
                    'spamProtectEmailAddresses_atSubst' => '',
                    'spamProtectEmailAddresses_lastDotSubst' => '',
                ],
                'some.body@test.typo3.org',
                'mailto:some.body@test.typo3.org',
                '<a href="#" data-mailto-token="nbjmup+tpnf/cpezAuftu/uzqp4/psh" data-mailto-vector="1">some.body(at)test.typo3.org</a>',
            ],
            'mono-alphabetic substitution offset +1 with at substitution' => [
                [
                    'spamProtectEmailAddresses' => 1,
                    'spamProtectEmailAddresses_atSubst' => '@',
                    'spamProtectEmailAddresses_lastDotSubst' => '',
                ],
                'some.body@test.typo3.org',
                'mailto:some.body@test.typo3.org',
                '<a href="#" data-mailto-token="nbjmup+tpnf/cpezAuftu/uzqp4/psh" data-mailto-vector="1">some.body@test.typo3.org</a>',
            ],
            'mono-alphabetic substitution offset +1 with at and dot substitution' => [
                [
                    'spamProtectEmailAddresses' => 1,
                    'spamProtectEmailAddresses_atSubst' => '(at)',
                    'spamProtectEmailAddresses_lastDotSubst' => '(dot)',
                ],
                'some.body@test.typo3.org',
                'mailto:some.body@test.typo3.org',
                '<a href="#" data-mailto-token="nbjmup+tpnf/cpezAuftu/uzqp4/psh" data-mailto-vector="1">some.body(at)test.typo3(dot)org</a>',
            ],
            'mono-alphabetic substitution offset -1 with at and dot substitution' => [
                [
                    'spamProtectEmailAddresses' => -1,
                    'spamProtectEmailAddresses_atSubst' => '(at)',
                    'spamProtectEmailAddresses_lastDotSubst' => '(dot)',
                ],
                'some.body@test.typo3.org',
                'mailto:some.body@test.typo3.org',
                '<a href="#" data-mailto-token="lzhksn9rnld-ancxZsdrs-sxon2-nqf" data-mailto-vector="-1">some.body(at)test.typo3(dot)org</a>',
            ],
            'mono-alphabetic substitution offset -1 with at and dot markup substitution' => [
                [
                    'spamProtectEmailAddresses' => -1,
                    'spamProtectEmailAddresses_atSubst' => '<span class="at"></span>',
                    'spamProtectEmailAddresses_lastDotSubst' => '<span class="dot"></span>',
                ],
                'some.body@test.typo3.org',
                'mailto:some.body@test.typo3.org',
                '<a href="#" data-mailto-token="lzhksn9rnld-ancxZsdrs-sxon2-nqf" data-mailto-vector="-1">some.body<span class="at"></span>test.typo3<span class="dot"></span>org</a>',
            ],
            'mono-alphabetic substitution offset 2 with at and dot substitution and encoded subject' => [
                [
                    'spamProtectEmailAddresses' => 2,
                    'spamProtectEmailAddresses_atSubst' => '(at)',
                    'spamProtectEmailAddresses_lastDotSubst' => '(dot)',
                ],
                'some.body@test.typo3.org',
                'mailto:some.body@test.typo3.org?subject=foo%20bar',
                '<a href="#" data-mailto-token="ocknvq,uqog0dqfaBvguv0varq50qti?uwdlgev=hqq%42dct" data-mailto-vector="2">some.body(at)test.typo3(dot)org</a>',
            ],
        ];
    }
 
    public static function ‪typolinkReturnsCorrectLinksFilesDataProvider(): array
    {
        return [
            'Link to file' => [
                'My file',
                [
                    'directImageLink' => false,
                    'parameter' => 'fileadmin/foo.bar',
                ],
                '<a href="fileadmin/foo.bar">My file</a>',
            ],
            'Link to file without link text' => [
                '',
                [
                    'directImageLink' => false,
                    'parameter' => 'fileadmin/foo.bar',
                ],
                '<a href="fileadmin/foo.bar">fileadmin/foo.bar</a>',
            ],
            'Link to file with attributes' => [
                'My file',
                [
                    'parameter' => 'fileadmin/foo.bar',
                    'ATagParams' => 'class="file-class"',
                    'fileTarget' => '_blank',
                    'title' => 'Title of the file',
                ],
                '<a href="fileadmin/foo.bar" target="_blank" class="file-class" title="Title of the file">My file</a>',
            ],
            'Link to file with attributes and additional href' => [
                'My file',
                [
                    'parameter' => 'fileadmin/foo.bar',
                    'ATagParams' => 'href="foo-bar"',
                    'fileTarget' => '_blank',
                    'title' => 'Title of the file',
                ],
                '<a href="fileadmin/foo.bar" target="_blank" title="Title of the file">My file</a>',
            ],
            'Link to file with attributes and additional href and class' => [
                'My file',
                [
                    'parameter' => 'fileadmin/foo.bar',
                    'ATagParams' => 'href="foo-bar" class="file-class"',
                    'fileTarget' => '_blank',
                    'title' => 'Title of the file',
                ],
                '<a href="fileadmin/foo.bar" target="_blank" class="file-class" title="Title of the file">My file</a>',
            ],
            'Link to file with attributes and additional class and href' => [
                'My file',
                [
                    'parameter' => 'fileadmin/foo.bar',
                    'ATagParams' => 'class="file-class" href="foo-bar"',
                    'fileTarget' => '_blank',
                    'title' => 'Title of the file',
                ],
                '<a href="fileadmin/foo.bar" target="_blank" class="file-class" title="Title of the file">My file</a>',
            ],
            'Link to file with attributes and additional class and href and title' => [
                'My file',
                [
                    'parameter' => 'fileadmin/foo.bar',
                    'ATagParams' => 'class="file-class" href="foo-bar" title="foo-bar"',
                    'fileTarget' => '_blank',
                    'title' => 'Title of the file',
                ],
                '<a href="fileadmin/foo.bar" target="_blank" class="file-class" title="Title of the file">My file</a>',
            ],
            'Link to file with attributes and empty ATagParams' => [
                'My file',
                [
                    'parameter' => 'fileadmin/foo.bar',
                    'ATagParams' => '',
                    'fileTarget' => '_blank',
                    'title' => 'Title of the file',
                ],
                '<a href="fileadmin/foo.bar" target="_blank" title="Title of the file">My file</a>',
            ],
            'Link to file with attributes in parameter' => [
                'My file',
                [
                    'parameter' => 'fileadmin/foo.bar _blank file-class "Title of the file"',
                ],
                '<a href="fileadmin/foo.bar" target="_blank" title="Title of the file" class="file-class">My file</a>',
            ],
            'Link to file with script tag in name' => [
                '',
                [
                    'directImageLink' => false,
                    'parameter' => 'fileadmin/<script>alert(123)</script>',
                ],
                '<a href="fileadmin/&lt;script&gt;alert(123)&lt;/script&gt;">fileadmin/&lt;script&gt;alert(123)&lt;/script&gt;</a>',
            ],
        ];
    }
 
    public function ‪typolinkReturnsCorrectLinksFiles(string $linkText, array $configuration, string $expectedResult): void
    {
        $typoScriptFrontendControllerMockObject = $this->createMock(TypoScriptFrontendController::class);
        $typoScriptFrontendControllerMockObject->config = [
            'config' => [],
        ];
        ‪$GLOBALS['TSFE'] = $typoScriptFrontendControllerMockObject;
 
        $resourceFactory = $this->getMockBuilder(ResourceFactory::class)->disableOriginalConstructor()->getMock();
        GeneralUtility::setSingletonInstance(ResourceFactory::class, $resourceFactory);
 
        $this->subject->_set('typoScriptFrontendController', $typoScriptFrontendControllerMockObject);
        GeneralUtility::addInstance(LinkFactory::class, $this->‪getLinkFactory());
 
        self::assertEquals($expectedResult, $this->subject->typoLink($linkText, $configuration));
    }
 
    public static function ‪typolinkReturnsCorrectLinksForFilesWithAbsRefPrefixDataProvider(): array
    {
        return [
            'Link to file' => [
                'My file',
                [
                    'directImageLink' => false,
                    'parameter' => 'fileadmin/foo.bar',
                ],
                '/',
                '<a href="/fileadmin/foo.bar">My file</a>',
            ],
            'Link to file with longer absRefPrefix' => [
                'My file',
                [
                    'directImageLink' => false,
                    'parameter' => 'fileadmin/foo.bar',
                ],
                '/sub/',
                '<a href="/sub/fileadmin/foo.bar">My file</a>',
            ],
            'Link to absolute file' => [
                'My file',
                [
                    'directImageLink' => false,
                    'parameter' => '/images/foo.bar',
                ],
                '/',
                '<a href="/images/foo.bar">My file</a>',
            ],
            'Link to absolute file with longer absRefPrefix' => [
                'My file',
                [
                    'directImageLink' => false,
                    'parameter' => '/images/foo.bar',
                ],
                '/sub/',
                '<a href="/images/foo.bar">My file</a>',
            ],
            'Link to absolute file with identical longer absRefPrefix' => [
                'My file',
                [
                    'directImageLink' => false,
                    'parameter' => '/sub/fileadmin/foo.bar',
                ],
                '/sub/',
                '<a href="/sub/fileadmin/foo.bar">My file</a>',
            ],
            'Link to file with empty absRefPrefix' => [
                'My file',
                [
                    'directImageLink' => false,
                    'parameter' => 'fileadmin/foo.bar',
                ],
                '',
                '<a href="fileadmin/foo.bar">My file</a>',
            ],
            'Link to absolute file with empty absRefPrefix' => [
                'My file',
                [
                    'directImageLink' => false,
                    'parameter' => '/fileadmin/foo.bar',
                ],
                '',
                '<a href="/fileadmin/foo.bar">My file</a>',
            ],
            'Link to file with attributes with absRefPrefix' => [
                'My file',
                [
                    'parameter' => 'fileadmin/foo.bar',
                    'ATagParams' => 'class="file-class"',
                    'fileTarget' => '_blank',
                    'title' => 'Title of the file',
                ],
                '/',
                '<a href="/fileadmin/foo.bar" target="_blank" class="file-class" title="Title of the file">My file</a>',
            ],
            'Link to file with attributes with longer absRefPrefix' => [
                'My file',
                [
                    'parameter' => 'fileadmin/foo.bar',
                    'ATagParams' => 'class="file-class"',
                    'fileTarget' => '_blank',
                    'title' => 'Title of the file',
                ],
                '/sub/',
                '<a href="/sub/fileadmin/foo.bar" target="_blank" class="file-class" title="Title of the file">My file</a>',
            ],
            'Link to absolute file with attributes with absRefPrefix' => [
                'My file',
                [
                    'parameter' => '/images/foo.bar',
                    'ATagParams' => 'class="file-class"',
                    'fileTarget' => '_blank',
                    'title' => 'Title of the file',
                ],
                '/',
                '<a href="/images/foo.bar" target="_blank" class="file-class" title="Title of the file">My file</a>',
            ],
            'Link to absolute file with attributes with longer absRefPrefix' => [
                'My file',
                [
                    'parameter' => '/images/foo.bar',
                    'ATagParams' => 'class="file-class"',
                    'fileTarget' => '_blank',
                    'title' => 'Title of the file',
                ],
                '/sub/',
                '<a href="/images/foo.bar" target="_blank" class="file-class" title="Title of the file">My file</a>',
            ],
            'Link to absolute file with attributes with identical longer absRefPrefix' => [
                'My file',
                [
                    'parameter' => '/sub/fileadmin/foo.bar',
                    'ATagParams' => 'class="file-class"',
                    'fileTarget' => '_blank',
                    'title' => 'Title of the file',
                ],
                '/sub/',
                '<a href="/sub/fileadmin/foo.bar" target="_blank" class="file-class" title="Title of the file">My file</a>',
            ],
        ];
    }
 
    public function ‪typolinkReturnsCorrectLinksForFilesWithAbsRefPrefix(string $linkText, array $configuration, string $absRefPrefix, string $expectedResult): void
    {
        $resourceFactory = $this->getMockBuilder(ResourceFactory::class)->disableOriginalConstructor()->getMock();
        GeneralUtility::setSingletonInstance(ResourceFactory::class, $resourceFactory);
 
        $typoScriptFrontendControllerMockObject = $this->createMock(TypoScriptFrontendController::class);
        $typoScriptFrontendControllerMockObject->config = [
            'config' => [],
        ];
        ‪$GLOBALS['TSFE'] = $typoScriptFrontendControllerMockObject;
        ‪$GLOBALS['TSFE']->absRefPrefix = $absRefPrefix;
        $this->subject->_set('typoScriptFrontendController', $typoScriptFrontendControllerMockObject);
        GeneralUtility::addInstance(LinkFactory::class, $this->‪getLinkFactory());
 
        self::assertEquals($expectedResult, $this->subject->typoLink($linkText, $configuration));
    }
 
    public function ‪typolinkOpensInNewWindow(): void
    {
        $siteConfiguration = new SiteConfiguration(
            ‪Environment::getConfigPath() . '/sites',
            new class () implements EventDispatcherInterface {
                public function dispatch(object $event)
                {
                    return $event;
                }
            },
            new NullFrontend('dummy')
        );
        $this->cacheManagerMock->method('getCache')->willReturnMap([
            ['runtime', new NullFrontend('dummy')],
            ['core', new NullFrontend('runtime')],
        ]);
        GeneralUtility::addInstance(ProviderConfigurationLoader::class, $this->createMock(ProviderConfigurationLoader::class));
        GeneralUtility::addInstance(DefaultProvider::class, new DefaultProvider(new Typo3Version(), new ‪Context(), new Features()));
        $linkFactory = $this->‪getLinkFactory($siteConfiguration);
        GeneralUtility::addInstance(LinkFactory::class, $linkFactory);
        $linkText = 'Nice Text';
        $configuration = [
            'parameter' => 'https://example.com 13x84:target=myexample',
        ];
        $expectedResult = '<a href="https://example.com" target="myexample" data-window-url="https://example.com" data-window-target="myexample" data-window-features="width=13,height=84" rel="noreferrer">Nice Text</a>';
        self::assertEquals($expectedResult, $this->subject->typoLink($linkText, $configuration));
        GeneralUtility::addInstance(LinkFactory::class, $linkFactory);
        $linkText = 'Nice Text with default window name';
        $configuration = [
            'parameter' => 'https://example.com 13x84',
        ];
        $expectedResult = '<a href="https://example.com" target="FEopenLink" data-window-url="https://example.com" data-window-target="FEopenLink" data-window-features="width=13,height=84" rel="noreferrer">Nice Text with default window name</a>';
        self::assertEquals($expectedResult, $this->subject->typoLink($linkText, $configuration));
        GeneralUtility::addInstance(LinkFactory::class, $linkFactory);
 
        $linkText = 'Nice Text with default window name';
        $configuration = [
            'parameter' => 'https://example.com 13x84',
        ];
        $expectedResult = '<a href="https://example.com" target="FEopenLink" data-window-url="https://example.com" data-window-target="FEopenLink" data-window-features="width=13,height=84" rel="noreferrer">Nice Text with default window name</a>';
        self::assertEquals($expectedResult, $this->subject->typoLink($linkText, $configuration));
        // This can vanish when the condition provider have been moved towards service provider setup
        GeneralUtility::purgeInstances();
    }
 
    public function ‪typoLinkReturnsOnlyLinkTextIfNoLinkResolvingIsPossible(): void
    {
        $linkService = $this->getMockBuilder(LinkService::class)->disableOriginalConstructor()->getMock();
        $linkService->method('resolve')->with('foo')->willThrowException(new InvalidPathException('', 1666303735));
        $linkFactory = $this->‪getLinkFactory(null, $linkService);
        GeneralUtility::addInstance(LinkFactory::class, $linkFactory);
        self::assertSame('foo', $this->subject->typoLink('foo', ['parameter' => 'foo']));
    }
 
    public function ‪typoLinkLogsErrorIfNoLinkResolvingIsPossible(): void
    {
        $linkService = $this->getMockBuilder(LinkService::class)->disableOriginalConstructor()->getMock();
        $linkService->method('resolve')->with('foo')->willThrowException(new InvalidPathException('', 1666303765));
        $linkFactory = $this->‪getLinkFactory(null, $linkService);
        $logger = $this->getMockBuilder(Logger::class)->disableOriginalConstructor()->getMock();
        $logger->expects(self::atLeastOnce())->method('warning')->with('The link could not be generated', self::anything());
        $linkFactory->setLogger($logger);
        GeneralUtility::addInstance(LinkFactory::class, $linkFactory);
 
        $this->subject->typoLink('foo', ['parameter' => 'foo']);
    }
 
    public function ‪typolinkLinkResult(): void
    {
        $typoScriptFrontendControllerMockObject = $this->createMock(TypoScriptFrontendController::class);
        $typoScriptFrontendControllerMockObject->config = [
            'config' => [],
        ];
        ‪$GLOBALS['TSFE'] = $typoScriptFrontendControllerMockObject;
 
        $resourceFactory = $this->getMockBuilder(ResourceFactory::class)->disableOriginalConstructor()->getMock();
        GeneralUtility::setSingletonInstance(ResourceFactory::class, $resourceFactory);
 
        $this->cacheManagerMock->method('getCache')->willReturnMap([
            ['runtime', new NullFrontend('dummy')],
            ['core', new NullFrontend('runtime')],
        ]);
 
        $siteConfiguration = new SiteConfiguration(
            ‪Environment::getConfigPath() . '/sites',
            new class () implements EventDispatcherInterface {
                public function dispatch(object $event)
                {
                    return $event;
                }
            },
            new NullFrontend('dummy')
        );
        GeneralUtility::addInstance(ProviderConfigurationLoader::class, $this->createMock(ProviderConfigurationLoader::class));
        GeneralUtility::addInstance(DefaultProvider::class, new DefaultProvider(new Typo3Version(), new Context(), new Features()));
        $linkFactory = $this->‪getLinkFactory($siteConfiguration);
        GeneralUtility::addInstance(LinkFactory::class, $linkFactory);
 
        $this->subject->_set('typoScriptFrontendController', $typoScriptFrontendControllerMockObject);
 
        $linkResult = $this->subject->typoLink(
            '',
            [
                'parameter' => 'https://example.tld',
                'returnLast' => 'result',
            ]
        );
        self::assertInstanceOf(LinkResultInterface::class, $linkResult);
        self::assertEquals(json_encode([
            'href' => 'https://example.tld',
            'target' => null,
            'class' => null,
            'title' => null,
            'linkText' => 'https://example.tld',
            'additionalAttributes' => [], ]), json_encode($linkResult));
        self::assertEquals(json_encode([
            'href' => 'https://example.tld',
            'target' => null,
            'class' => null,
            'title' => null,
            'linkText' => 'https://example.tld',
            'additionalAttributes' => [], ]), (string)$linkResult);
        // This can vanish when the condition provider have been moved towards service provider setup
        GeneralUtility::purgeInstances();
    }
 
    public function ‪typoLinkProperlyEncodesLinkResult(string $linkText, array $configuration, string $expectedResult): void
    {
        $typoScriptFrontendControllerMockObject = $this->createMock(TypoScriptFrontendController::class);
        $typoScriptFrontendControllerMockObject->config = [
            'config' => [],
        ];
        ‪$GLOBALS['TSFE'] = $typoScriptFrontendControllerMockObject;
 
        $resourceFactory = $this->getMockBuilder(ResourceFactory::class)->disableOriginalConstructor()->getMock();
        GeneralUtility::setSingletonInstance(ResourceFactory::class, $resourceFactory);
 
        $this->cacheManagerMock->method('getCache')->willReturnMap([
            ['runtime', new NullFrontend('dummy')],
            ['core', new NullFrontend('runtime')],
        ]);
 
        $siteConfiguration = new SiteConfiguration(
            ‪Environment::getConfigPath() . '/sites',
            new class () implements EventDispatcherInterface {
                public function dispatch(object $event)
                {
                    return $event;
                }
            },
            new NullFrontend('dummy')
        );
        GeneralUtility::addInstance(ProviderConfigurationLoader::class, $this->createMock(ProviderConfigurationLoader::class));
        GeneralUtility::addInstance(DefaultProvider::class, new DefaultProvider(new Typo3Version(), new Context(), new Features()));
        $linkFactory = $this->‪getLinkFactory($siteConfiguration);
        GeneralUtility::addInstance(LinkFactory::class, $linkFactory);
        $this->subject->_set('typoScriptFrontendController', $typoScriptFrontendControllerMockObject);
 
        self::assertEquals($expectedResult, (string)$this->subject->typoLink($linkText, $configuration));
        // This can vanish when the condition provider have been moved towards service provider setup
        GeneralUtility::purgeInstances();
    }
 
    public static function ‪typoLinkProperlyEncodesLinkResultDataProvider(): array
    {
        return [
            'Link to file' => [
                'My file',
                [
                    'directImageLink' => false,
                    'parameter' => '/fileadmin/foo.bar',
                    'returnLast' => 'result',
                ],
                json_encode([
                    'href' => '/fileadmin/foo.bar',
                    'target' => null,
                    'class' => null,
                    'title' => null,
                    'linkText' => 'My file',
                    'additionalAttributes' => [],
                ]),
            ],
            'Link example' => [
                'My example',
                [
                    'directImageLink' => false,
                    'parameter' => 'https://example.tld',
                    'returnLast' => 'result',
                ],
                json_encode([
                    'href' => 'https://example.tld',
                    'target' => null,
                    'class' => null,
                    'title' => null,
                    'linkText' => 'My example',
                    'additionalAttributes' => [],
                ]),
            ],
            'Link to file with attributes' => [
                'My file',
                [
                    'parameter' => '/fileadmin/foo.bar',
                    'fileTarget' => '_blank',
                    'returnLast' => 'result',
                ],
                json_encode([
                    'href' => '/fileadmin/foo.bar',
                    'target' => '_blank',
                    'class' => null,
                    'title' => null,
                    'linkText' => 'My file',
                    'additionalAttributes' => [],
                ]),
            ],
            'Link parsing' => [
                'Url',
                [
                    'parameter' => 'https://example.com _blank css-class "test title"',
                    'returnLast' => 'result',
                ],
                json_encode([
                    'href' => 'https://example.com',
                    'target' => '_blank',
                    'class' => 'css-class',
                    'title' => 'test title',
                    'linkText' => 'Url',
                    'additionalAttributes' => ['rel' => 'noreferrer'],
                ]),
            ],
        ];
    }
 
    public function ‪stdWrap_splitObjReturnsCount(): void
    {
        $conf = [
            'token' => ',',
            'returnCount' => 1,
        ];
        $expectedResult = 5;
        $amountOfEntries = $this->subject->splitObj('1, 2, 3, 4, 5', $conf);
        self::assertSame(
            $expectedResult,
            $amountOfEntries
        );
    }
 
    public static function ‪calculateCacheKeyDataProvider(): array
    {
        $value = ‪StringUtility::getUniqueId('value');
        $wrap = [‪StringUtility::getUniqueId('wrap')];
        $valueConf = ['key' => $value];
        $wrapConf = ['key.' => $wrap];
        $conf = array_merge($valueConf, $wrapConf);
        $will = ‪StringUtility::getUniqueId('stdWrap');
 
        return [
            'no conf' => [
                '',
                [],
                0,
                null,
                null,
                null,
            ],
            'value conf only' => [
                $value,
                $valueConf,
                0,
                null,
                null,
                null,
            ],
            'wrap conf only' => [
                $will,
                $wrapConf,
                1,
                '',
                $wrap,
                $will,
            ],
            'full conf' => [
                $will,
                $conf,
                1,
                $value,
                $wrap,
                $will,
            ],
        ];
    }
 
    public function ‪calculateCacheKey(string $expect, array $conf, int $times, ?string $with, ?array $withWrap, ?string $will): void
    {
        ‪$subject = $this->getAccessibleMock(ContentObjectRenderer::class, ['stdWrap']);
        ‪$subject->expects(self::exactly($times))
            ->method('stdWrap')
            ->with($with, $withWrap)
            ->willReturn($will);
 
        $result = ‪$subject->_call('calculateCacheKey', $conf);
        self::assertSame($expect, $result);
    }
 
    public static function ‪getFromCacheDataProvider(): array
    {
        $conf = [‪StringUtility::getUniqueId('conf')];
        return [
            'empty cache key' => [
                false,
                $conf,
                '',
                0,
                null,
            ],
            'non-empty cache key' => [
                'value',
                $conf,
                'non-empty-key',
                1,
                'value',
            ],
        ];
    }
 
    public function ‪getFromCache(string|bool $expect, array $conf, string $cacheKey, int $times, ?string $cached): void
    {
        ‪$subject = $this->getAccessibleMock(
            ContentObjectRenderer::class,
            ['calculateCacheKey']
        );
        ‪$subject
            ->expects(self::once())
            ->method('calculateCacheKey')
            ->with($conf)
            ->willReturn($cacheKey);
        $cacheFrontend = $this->createMock(CacheFrontendInterface::class);
        $cacheFrontend
            ->expects(self::exactly($times))
            ->method('get')
            ->with($cacheKey)
            ->willReturn($cached);
        $cacheManager = $this->createMock(CacheManager::class);
        $cacheManager
            ->method('getCache')
            ->willReturn($cacheFrontend);
        GeneralUtility::setSingletonInstance(
            CacheManager::class,
            $cacheManager
        );
        self::assertSame($expect, ‪$subject->_call('getFromCache', $conf));
    }
 
    public static function ‪getFieldValDataProvider(): array
    {
        return [
            'invalid single key' => [null, 'invalid'],
            'single key of null' => [null, 'null'],
            'single key of empty string' => ['', 'empty'],
            'single key of non-empty string' => ['string 1', 'string1'],
            'single key of boolean false' => [false, 'false'],
            'single key of boolean true' => [true, 'true'],
            'single key of integer 0' => [0, 'zero'],
            'single key of integer 1' => [1, 'one'],
            'single key to be trimmed' => ['string 1', ' string1 '],
 
            'split nothing' => ['', '//'],
            'split one before' => ['string 1', 'string1//'],
            'split one after' => ['string 1', '//string1'],
            'split two ' => ['string 1', 'string1//string2'],
            'split three ' => ['string 1', 'string1//string2//string3'],
            'split to be trimmed' => ['string 1', ' string1 // string2 '],
            '0 is not empty' => [0, '// zero'],
            '1 is not empty' => [1, '// one'],
            'true is not empty' => [true, '// true'],
            'false is empty' => ['', '// false'],
            'null is empty' => ['', '// null'],
            'empty string is empty' => ['', '// empty'],
            'string is not empty' => ['string 1', '// string1'],
            'first non-empty winns' => [0, 'false//empty//null//zero//one'],
            'empty string is fallback' => ['', 'false // empty // null'],
        ];
    }
 
    public function ‪getFieldVal(mixed $expect, string ‪$fields): void
    {
        $data = [
            'string1' => 'string 1',
            'string2' => 'string 2',
            'string3' => 'string 3',
            'empty' => '',
            'null' => null,
            'false' => false,
            'true' => true,
            'zero' => 0,
            'one' => 1,
        ];
        $this->subject->_set('data', $data);
        self::assertSame($expect, $this->subject->getFieldVal(‪$fields));
    }
 
    public static function ‪caseshiftDataProvider(): array
    {
        return [
            'lower' => ['x y', 'X Y', 'lower'],
            'upper' => ['X Y', 'x y', 'upper'],
            'capitalize' => ['One Two', 'one two', 'capitalize'],
            'ucfirst' => ['One two', 'one two', 'ucfirst'],
            'lcfirst' => ['oNE TWO', 'ONE TWO', 'lcfirst'],
            'uppercamelcase' => ['CamelCase', 'camel_case', 'uppercamelcase'],
            'lowercamelcase' => ['camelCase', 'camel_case', 'lowercamelcase'],
        ];
    }
 
    public function ‪caseshift(string $expect, string $content, string $case): void
    {
        self::assertSame(
            $expect,
            $this->subject->caseshift($content, $case)
        );
    }
 
    public static function ‪HTMLcaseshiftDataProvider(): array
    {
        $case = ‪StringUtility::getUniqueId('case');
        return [
            'simple text' => [
                'TEXT',
                'text',
                $case,
                [['text', $case]],
                ['TEXT'],
            ],
            'simple tag' => [
                '<i>TEXT</i>',
                '<i>text</i>',
                $case,
                [['', $case], ['text', $case]],
                ['', 'TEXT'],
            ],
            'multiple nested tags with classes' => [
                '<div class="typo3">'
                . '<p>A <b>BOLD<\b> WORD.</p>'
                . '<p>AN <i>ITALIC<\i> WORD.</p>'
                . '</div>',
                '<div class="typo3">'
                . '<p>A <b>bold<\b> word.</p>'
                . '<p>An <i>italic<\i> word.</p>'
                . '</div>',
                $case,
                [
                    ['', $case],
                    ['', $case],
                    ['A ', $case],
                    ['bold', $case],
                    [' word.', $case],
                    ['', $case],
                    ['An ', $case],
                    ['italic', $case],
                    [' word.', $case],
                    ['', $case],
                ],
                ['', '', 'A ', 'BOLD', ' WORD.', '', 'AN ', 'ITALIC', ' WORD.', ''],
            ],
        ];
    }
 
    public function ‪HTMLcaseshift(string $expect, string $content, string $case, array $with, array $will): void
    {
        ‪$subject = $this->getMockBuilder(ContentObjectRenderer::class)
            ->onlyMethods(['caseshift'])->getMock();
        ‪$subject
            ->expects(self::exactly(count($with)))
            ->method('caseshift')
            ->withConsecutive(...$with)
            ->will(self::onConsecutiveCalls(...$will));
        self::assertSame(
            $expect,
            ‪$subject->HTMLcaseshift($content, $case)
        );
    }
 
    /***************************************************************************
     * General tests for stdWrap_
     ***************************************************************************/
 
    public function ‪allStdWrapProcessorsAreCallable(): void
    {
        $callable = 0;
        $notCallable = 0;
        $processors = ['invalidProcessor'];
        foreach (array_keys($this->subject->_get('stdWrapOrder')) as $key) {
            $processors[] = strtr($key, ['.' => '']);
        }
        foreach (array_unique($processors) as $processor) {
            $method = [‪$this->subject, 'stdWrap_' . $processor];
            if (is_callable($method)) {
                ++$callable;
            } else {
                ++$notCallable;
            }
        }
        self::assertSame(1, $notCallable);
        self::assertSame(82, $callable);
    }
 
    public function ‪notAllStdWrapProcessorsAreCallableWithEmptyConfiguration(): void
    {
        $timeTrackerMock = $this->getMockBuilder(TimeTracker::class)->disableOriginalConstructor()->getMock();
        GeneralUtility::setSingletonInstance(TimeTracker::class, $timeTrackerMock);
        $linkFactory = $this->getMockBuilder(LinkFactory::class)->disableOriginalConstructor()->getMock();
        $linkFactory->expects(self::atLeastOnce())->method('create')->with(self::anything())->willReturn(new LinkResult('', ''));
        GeneralUtility::addInstance(LinkFactory::class, $linkFactory);
        $pageRendererMock = $this->getMockBuilder(PageRenderer::class)->disableOriginalConstructor()->getMock();
        $pageRendererMock->method('getDocType')->willReturn(DocType::html5);
        GeneralUtility::setSingletonInstance(PageRenderer::class, $pageRendererMock);
 
        $expectExceptions = ['numRows'];
        $count = 0;
        $processors = [];
        $exceptions = [];
        foreach (array_keys($this->subject->_get('stdWrapOrder')) as $key) {
            $processors[] = strtr($key, ['.' => '']);
        }
        foreach (array_unique($processors) as $processor) {
            ++$count;
            try {
                $conf = [$processor => '', $processor . '.' => ['table' => 'tt_content']];
                $method = 'stdWrap_' . $processor;
                $this->subject->$method('', $conf);
            } catch (\Exception $e) {
                $exceptions[] = $processor;
            }
        }
        self::assertSame($expectExceptions, $exceptions);
        self::assertSame(82, $count);
    }
 
    /***************************************************************************
     * End general tests for stdWrap_
     ***************************************************************************/
 
    /***************************************************************************
     * Tests for stdWrap_ in alphabetical order (all uppercase before lowercase)
     ***************************************************************************/
 
    public static function ‪fourTypesOfStdWrapHookObjectProcessorsDataProvider(): array
    {
        return [
            'preProcess' => [
                'stdWrap_stdWrapPreProcess',
                'stdWrapPreProcess',
            ],
            'override' => [
                'stdWrap_stdWrapOverride',
                'stdWrapOverride',
            ],
            'process' => [
                'stdWrap_stdWrapProcess',
                'stdWrapProcess',
            ],
            'postProcess' => [
                'stdWrap_stdWrapPostProcess',
                'stdWrapPostProcess',
            ],
        ];
    }
 
    public function ‪fourTypesOfStdWrapHookObjectProcessors(
        string $stdWrapMethod,
        string $hookObjectCall
    ): void {
        $conf = [‪StringUtility::getUniqueId('conf')];
        $content = ‪StringUtility::getUniqueId('content');
        $processed1 = ‪StringUtility::getUniqueId('processed1');
        $processed2 = ‪StringUtility::getUniqueId('processed2');
        $hookObject1 = $this->createMock(
            ContentObjectStdWrapHookInterface::class
        );
        $hookObject1->expects(self::once())
            ->method($hookObjectCall)
            ->with($content, $conf)
            ->willReturn($processed1);
        $hookObject2 = $this->createMock(
            ContentObjectStdWrapHookInterface::class
        );
        $hookObject2->expects(self::once())
            ->method($hookObjectCall)
            ->with($processed1, $conf)
            ->willReturn($processed2);
        $this->subject->_set(
            'stdWrapHookObjects',
            [$hookObject1, $hookObject2]
        );
        $result = $this->subject->$stdWrapMethod($content, $conf);
        self::assertSame($processed2, $result);
    }
 
    public static function ‪stdWrap_HTMLparserDataProvider(): array
    {
        $content = ‪StringUtility::getUniqueId('content');
        $parsed = ‪StringUtility::getUniqueId('parsed');
        return [
            'no config' => [
                $content,
                $content,
                [],
                0,
                $parsed,
            ],
            'no array' => [
                $content,
                $content,
                ['HTMLparser.' => 1],
                0,
                $parsed,
            ],
            'empty array' => [
                $parsed,
                $content,
                ['HTMLparser.' => []],
                1,
                $parsed,
            ],
            'non-empty array' => [
                $parsed,
                $content,
                ['HTMLparser.' => [true]],
                1,
                $parsed,
            ],
        ];
    }
 
    public function ‪stdWrap_HTMLparser(
        string $expect,
        string $content,
        array $conf,
        int $times,
        string $will
    ): void {
        ‪$subject = $this->getMockBuilder(ContentObjectRenderer::class)
            ->onlyMethods(['HTMLparser_TSbridge'])->getMock();
        ‪$subject
            ->expects(self::exactly($times))
            ->method('HTMLparser_TSbridge')
            ->with($content, $conf['HTMLparser.'] ?? [])
            ->willReturn($will);
        self::assertSame(
            $expect,
            ‪$subject->stdWrap_HTMLparser($content, $conf)
        );
    }
 
    public static function ‪stdWrap_addPageCacheTagsAddsPageTagsDataProvider(): array
    {
        return [
            'No Tag' => [
                [],
                ['addPageCacheTags' => ''],
            ],
            'Two expectedTags' => [
                ['tag1', 'tag2'],
                ['addPageCacheTags' => 'tag1,tag2'],
            ],
            'Two expectedTags plus one with stdWrap' => [
                ['tag1', 'tag2', 'tag3'],
                [
                    'addPageCacheTags' => 'tag1,tag2',
                    'addPageCacheTags.' => ['wrap' => '|,tag3'],
                ],
            ],
        ];
    }
 
    public function ‪stdWrap_addPageCacheTagsAddsPageTags(array $expectedTags, array $configuration): void
    {
        $this->subject->stdWrap_addPageCacheTags('', $configuration);
        self::assertEquals($expectedTags, $this->frontendControllerMock->_get('pageCacheTags'));
    }
 
    public function ‪stdWrap_age(): void
    {
        $now = 10;
        $content = '9';
        $conf = ['age' => ‪StringUtility::getUniqueId('age')];
        $return = ‪StringUtility::getUniqueId('return');
        $difference = $now - (int)$content;
        ‪$GLOBALS['EXEC_TIME'] = $now;
        ‪$subject = $this->getMockBuilder(ContentObjectRenderer::class)
            ->onlyMethods(['calcAge'])->getMock();
        ‪$subject
            ->expects(self::once())
            ->method('calcAge')
            ->with($difference, $conf['age'])
            ->willReturn($return);
        self::assertSame($return, ‪$subject->stdWrap_age($content, $conf));
    }
 
    public function ‪stdWrap_append(): void
    {
        $debugKey = '/stdWrap/.append';
        $content = ‪StringUtility::getUniqueId('content');
        $conf = [
            'append' => ‪StringUtility::getUniqueId('append'),
            'append.' => [‪StringUtility::getUniqueId('append.')],
        ];
        $return = ‪StringUtility::getUniqueId('return');
        ‪$subject = $this->getMockBuilder(ContentObjectRenderer::class)
            ->onlyMethods(['cObjGetSingle'])->getMock();
        ‪$subject
            ->expects(self::once())
            ->method('cObjGetSingle')
            ->with($conf['append'], $conf['append.'], $debugKey)
            ->willReturn($return);
        self::assertSame(
            $content . $return,
            ‪$subject->stdWrap_append($content, $conf)
        );
    }
 
    public static function ‪stdWrapBrDataProvider(): array
    {
        return [
            'no xhtml with LF in between' => [
                'one<br>' . LF . 'two',
                'one' . LF . 'two',
                null,
            ],
            'no xhtml with LF in between and around' => [
                '<br>' . LF . 'one<br>' . LF . 'two<br>' . LF,
                LF . 'one' . LF . 'two' . LF,
                null,
            ],
            'xhtml with LF in between' => [
                'one<br />' . LF . 'two',
                'one' . LF . 'two',
                'xhtml_strict',
            ],
            'xhtml with LF in between and around' => [
                '<br />' . LF . 'one<br />' . LF . 'two<br />' . LF,
                LF . 'one' . LF . 'two' . LF,
                'xhtml_strict',
            ],
        ];
    }
 
    public function ‪stdWrap_br(string $expected, string $input, ?string $xhtmlDoctype): void
    {
        $pageRenderer = $this->getMockBuilder(PageRenderer::class)->disableOriginalConstructor()->addMethods(['dummy'])->getMock();
        $pageRenderer->setLanguage('en');
        $pageRenderer->setDocType(DocType::createFromConfigurationKey($xhtmlDoctype));
        GeneralUtility::setSingletonInstance(PageRenderer::class, $pageRenderer);
        self::assertSame($expected, $this->subject->stdWrap_br($input));
    }
 
    public static function ‪stdWrapBrTagDataProvider(): array
    {
        $noConfig = [];
        $config1 = ['brTag' => '<br/>'];
        $config2 = ['brTag' => '<br>'];
        return [
            'no config: one break at the beginning' => [LF . 'one' . LF . 'two', 'onetwo', $noConfig],
            'no config: multiple breaks at the beginning' => [LF . LF . 'one' . LF . 'two', 'onetwo', $noConfig],
            'no config: one break at the end' => ['one' . LF . 'two' . LF, 'onetwo', $noConfig],
            'no config: multiple breaks at the end' => ['one' . LF . 'two' . LF . LF, 'onetwo', $noConfig],
 
            'config1: one break at the beginning' => [LF . 'one' . LF . 'two', '<br/>one<br/>two', $config1],
            'config1: multiple breaks at the beginning' => [
                LF . LF . 'one' . LF . 'two',
                '<br/><br/>one<br/>two',
                $config1,
            ],
            'config1: one break at the end' => ['one' . LF . 'two' . LF, 'one<br/>two<br/>', $config1],
            'config1: multiple breaks at the end' => ['one' . LF . 'two' . LF . LF, 'one<br/>two<br/><br/>', $config1],
 
            'config2: one break at the beginning' => [LF . 'one' . LF . 'two', '<br>one<br>two', $config2],
            'config2: multiple breaks at the beginning' => [
                LF . LF . 'one' . LF . 'two',
                '<br><br>one<br>two',
                $config2,
            ],
            'config2: one break at the end' => ['one' . LF . 'two' . LF, 'one<br>two<br>', $config2],
            'config2: multiple breaks at the end' => ['one' . LF . 'two' . LF . LF, 'one<br>two<br><br>', $config2],
        ];
    }
 
    public function ‪stdWrap_brTag(string $input, string $expected, array $config): void
    {
        self::assertEquals($expected, $this->subject->stdWrap_brTag($input, $config));
    }
 
    public static function ‪stdWrap_bytesDataProvider(): array
    {
        return [
            'value 1234 default' => [
                '1.21 Ki',
                '1234',
                ['labels' => '', 'base' => 0],
            ],
            'value 1234 si' => [
                '1.23 k',
                '1234',
                ['labels' => 'si', 'base' => 0],
            ],
            'value 1234 iec' => [
                '1.21 Ki',
                '1234',
                ['labels' => 'iec', 'base' => 0],
            ],
            'value 1234 a-i' => [
                '1.23b',
                '1234',
                ['labels' => 'a|b|c|d|e|f|g|h|i', 'base' => 1000],
            ],
            'value 1234 a-i invalid base' => [
                '1.21b',
                '1234',
                ['labels' => 'a|b|c|d|e|f|g|h|i', 'base' => 54],
            ],
            'value 1234567890 default' => [
                '1.15 Gi',
                '1234567890',
                ['labels' => '', 'base' => 0],
            ],
            'value 1234 iec no base' => [
                '1.21 Ki',
                '1234',
                ['labels' => 'iec'],
            ],
            'value 1234 no labels base set' => [
                '1.21 Ki',
                '1234',
                ['base' => 0],
            ],
        ];
    }
 
    public function ‪stdWrap_bytes(string $expect, string $content, array $conf): void
    {
        $locale = 'en_US.UTF-8';
        try {
            $this->setLocale(LC_NUMERIC, $locale);
        } catch (Exception $e) {
            self::markTestSkipped('Locale ' . $locale . ' is not available.');
        }
        $conf = ['bytes.' => $conf];
        self::assertSame(
            $expect,
            $this->subject->stdWrap_bytes($content, $conf)
        );
    }
 
    public function ‪stdWrap_cObject(): void
    {
        $debugKey = '/stdWrap/.cObject';
        $content = ‪StringUtility::getUniqueId('content');
        $conf = [
            'cObject' => ‪StringUtility::getUniqueId('cObject'),
            'cObject.' => [‪StringUtility::getUniqueId('cObject.')],
        ];
        $return = ‪StringUtility::getUniqueId('return');
        ‪$subject = $this->getMockBuilder(ContentObjectRenderer::class)
            ->onlyMethods(['cObjGetSingle'])->getMock();
        ‪$subject
            ->expects(self::once())
            ->method('cObjGetSingle')
            ->with($conf['cObject'], $conf['cObject.'], $debugKey)
            ->willReturn($return);
        self::assertSame(
            $return,
            ‪$subject->stdWrap_cObject($content, $conf)
        );
    }
 
    public static function ‪stdWrap_orderedStdWrapDataProvider(): array
    {
        $confA = [‪StringUtility::getUniqueId('conf A')];
        $confB = [‪StringUtility::getUniqueId('conf B')];
        return [
            'standard case: order 1, 2' => [
                $confA,
                $confB,
                ['1.' => $confA, '2.' => $confB],
            ],
            'inverted: order 2, 1' => [
                $confB,
                $confA,
                ['2.' => $confA, '1.' => $confB],
            ],
            '0 as integer: order 0, 2' => [
                $confA,
                $confB,
                ['0.' => $confA, '2.' => $confB],
            ],
            'negative integers: order 2, -2' => [
                $confB,
                $confA,
                ['2.' => $confA, '-2.' => $confB],
            ],
            'chars are casted to key 0, that is not in the array' => [
                null,
                $confB,
                ['2.' => $confB, 'xxx.' => $confA],
            ],
        ];
    }
 
    public function ‪stdWrap_orderedStdWrap(?array $firstConf, array $secondConf, array $conf): void
    {
        $content = ‪StringUtility::getUniqueId('content');
        $between = ‪StringUtility::getUniqueId('between');
        $expect = ‪StringUtility::getUniqueId('expect');
        $conf['orderedStdWrap.'] = $conf;
        ‪$subject = $this->getMockBuilder(ContentObjectRenderer::class)
            ->onlyMethods(['stdWrap'])->getMock();
        ‪$subject
            ->expects(self::exactly(2))
            ->method('stdWrap')
            ->withConsecutive([$content, $firstConf], [$between, $secondConf])
            ->will(self::onConsecutiveCalls($between, $expect));
        self::assertSame(
            $expect,
            ‪$subject->stdWrap_orderedStdWrap($content, $conf)
        );
    }
 
    public static function ‪stdWrap_cacheReadDataProvider(): array
    {
        $cacheConf = [‪StringUtility::getUniqueId('cache.')];
        $conf = ['cache.' => $cacheConf];
        return [
            'no conf' => [
                'content',
                'content',
                [],
                0,
                null,
                null,
            ],
            'no cache. conf' => [
                'content',
                'content',
                ['otherConf' => 1],
                0,
                null,
                null,
            ],
            'non-cached simulation' => [
                'content',
                'content',
                $conf,
                1,
                $cacheConf,
                false,
            ],
            'cached simulation' => [
                'cachedContent',
                'content',
                $conf,
                1,
                $cacheConf,
                'cachedContent',
            ],
        ];
    }
 
    public function ‪stdWrap_cacheRead(
        string $expect,
        string $input,
        array $conf,
        int $times,
        ?array $with,
        string|bool|null $will
    ): void {
        ‪$subject = $this->getAccessibleMock(
            ContentObjectRenderer::class,
            ['getFromCache']
        );
        ‪$subject
            ->expects(self::exactly($times))
            ->method('getFromCache')
            ->with($with)
            ->willReturn($will);
        self::assertSame(
            $expect,
            ‪$subject->stdWrap_cacheRead($input, $conf)
        );
    }
 
    public static function ‪stdWrap_cacheStoreDataProvider(): array
    {
        $confCache = [‪StringUtility::getUniqueId('cache.')];
        $key = [‪StringUtility::getUniqueId('key')];
        return [
            'Return immediate with no conf' => [
                null,
                0,
                null,
                0,
            ],
            'Return immediate with empty key' => [
                $confCache,
                1,
                '0',
                0,
            ],
            'Call all methods' => [
                $confCache,
                1,
                $key,
                1,
            ],
        ];
    }
 
    public function ‪stdWrap_cacheStore(
        ?array $confCache,
        int $timesCCK,
        mixed $key,
        int $times
    ): void {
        $content = ‪StringUtility::getUniqueId('content');
        $conf = [];
        $conf['cache.'] = $confCache;
        $tags = [‪StringUtility::getUniqueId('tags')];
        $lifetime = ‪StringUtility::getUniqueId('lifetime');
        $params = [
            'key' => $key,
            'content' => $content,
            'lifetime' => $lifetime,
            'tags' => $tags,
        ];
        ‪$subject = $this->getAccessibleMock(
            ContentObjectRenderer::class,
            [
                'calculateCacheKey',
                'calculateCacheTags',
                'calculateCacheLifetime',
            ]
        );
        ‪$subject
            ->expects(self::exactly($timesCCK))
            ->method('calculateCacheKey')
            ->with($confCache)
            ->willReturn($key);
        ‪$subject
            ->expects(self::exactly($times))
            ->method('calculateCacheTags')
            ->with($confCache)
            ->willReturn($tags);
        ‪$subject
            ->expects(self::exactly($times))
            ->method('calculateCacheLifetime')
            ->with($confCache)
            ->willReturn($lifetime);
        $cacheFrontend = $this->createMock(CacheFrontendInterface::class);
        $cacheFrontend
            ->expects(self::exactly($times))
            ->method('set')
            ->with($key, $content, $tags, $lifetime)
            ->willReturn(null);
        $cacheManager = $this->createMock(CacheManager::class);
        $cacheManager
            ->method('getCache')
            ->willReturn($cacheFrontend);
        GeneralUtility::setSingletonInstance(
            CacheManager::class,
            $cacheManager
        );
        [$countCalls, $test] = [0, $this];
        $closure = static function ($par1, $par2) use (
            $test,
            ‪$subject,
            $params,
            &$countCalls
        ) {
            $test->assertSame($params, $par1);
            $test->assertSame(‪$subject, $par2);
            $countCalls++;
        };
        ‪$GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['tslib/class.tslib_content.php']['stdWrap_cacheStore'] = [
            $closure,
            $closure,
            $closure,
        ];
        self::assertSame(
            $content,
            ‪$subject->stdWrap_cacheStore($content, $conf)
        );
        self::assertSame($times * 3, $countCalls);
    }
 
    public function ‪stdWrap_case(): void
    {
        $content = ‪StringUtility::getUniqueId();
        $conf = [
            'case' => ‪StringUtility::getUniqueId('used'),
            'case.' => [‪StringUtility::getUniqueId('discarded')],
        ];
        $return = ‪StringUtility::getUniqueId();
        ‪$subject = $this->getMockBuilder(ContentObjectRenderer::class)
            ->onlyMethods(['HTMLcaseshift'])->getMock();
        ‪$subject
            ->expects(self::once())
            ->method('HTMLcaseshift')
            ->with($content, $conf['case'])
            ->willReturn($return);
        self::assertSame(
            $return,
            ‪$subject->stdWrap_case($content, $conf)
        );
    }
 
    public function ‪stdWrap_char(): void
    {
        $input = 'discarded';
        $expected = 'C';
        self::assertEquals($expected, $this->subject->stdWrap_char($input, ['char' => '67']));
    }
 
    public function ‪stdWrap_crop(): void
    {
        $content = ‪StringUtility::getUniqueId('content');
        $conf = [
            'crop' => ‪StringUtility::getUniqueId('crop'),
            'crop.' => ‪StringUtility::getUniqueId('not used'),
        ];
        $return = ‪StringUtility::getUniqueId('return');
        ‪$subject = $this->getMockBuilder(ContentObjectRenderer::class)
            ->onlyMethods(['crop'])->getMock();
        ‪$subject
            ->expects(self::once())
            ->method('crop')
            ->with($content, $conf['crop'])
            ->willReturn($return);
        self::assertSame(
            $return,
            ‪$subject->stdWrap_crop($content, $conf)
        );
    }
 
    public function ‪stdWrap_cropHTML(): void
    {
        $content = ‪StringUtility::getUniqueId('content');
        $conf = [
            'cropHTML' => ‪StringUtility::getUniqueId('cropHTML'),
            'cropHTML.' => ‪StringUtility::getUniqueId('not used'),
        ];
        $return = ‪StringUtility::getUniqueId('return');
        ‪$subject = $this->getMockBuilder(ContentObjectRenderer::class)
            ->onlyMethods(['cropHTML'])->getMock();
        ‪$subject
            ->expects(self::once())
            ->method('cropHTML')
            ->with($content, $conf['cropHTML'])
            ->willReturn($return);
        self::assertSame(
            $return,
            ‪$subject->stdWrap_cropHTML($content, $conf)
        );
    }
 
    protected static function ‪stdWrap_formattedDateProvider(): \Generator
    {
        yield 'regular formatting - no locale' => [
            '2023.02.02 AD at 13:05:00 UTC',
            "yyyy.MM.dd G 'at' HH:mm:ss zzz",
        ];
        yield 'full - no locale' => [
            'Thursday, February 2, 2023 at 13:05:00 Coordinated Universal Time',
            'FULL',
        ];
        yield 'long - no locale' => [
            'February 2, 2023 at 13:05:00 UTC',
            'LONG',
        ];
        yield 'medium - no locale' => [
            'Feb 2, 2023, 13:05:00',
            'MEDIUM',
        ];
        yield 'medium with int - no locale' => [
            'Feb 2, 2023, 13:05:00',
            \IntlDateFormatter::MEDIUM,
        ];
        yield 'short - no locale' => [
            '2/2/23, 13:05',
            'SHORT',
        ];
        yield 'regular formatting - german locale' => [
            '2023.02.02 n. Chr. um 13:05:00 UTC',
            "yyyy.MM.dd G 'um' HH:mm:ss zzz",
            'de-DE',
        ];
        yield 'full - german locale' => [
            'Donnerstag, 2. Februar 2023 um 13:05:00 Koordinierte Weltzeit',
            'FULL',
            'de-DE',
        ];
        yield 'long - german locale' => [
            '2. Februar 2023 um 13:05:00 UTC',
            'LONG',
            'de-DE',
        ];
        yield 'medium - german locale' => [
            '02.02.2023, 13:05:00',
            'MEDIUM',
            'de-DE',
        ];
        yield 'short - german locale' => [
            '02.02.23, 13:05',
            'SHORT',
            'de-DE',
        ];
        yield 'custom date only - german locale' => [
            '02. Februar 2023',
            'dd. MMMM yyyy',
            'de-DE',
        ];
        yield 'custom time only - german locale' => [
            '13:05:00',
            'HH:mm:ss',
            'de-DE',
        ];
        yield 'given date and time - german locale' => [
            'Freitag, 20. Februar 1998 um 03:00:00 Koordinierte Weltzeit',
            'FULL',
            'de-DE',
            '1998-02-20 3:00:00',
        ];
    }
 
    public function ‪stdWrap_formattedDate(string $expected, mixed $pattern, string $locale = null, string $givenDate = null): void
    {
        $this->frontendControllerMock->getContext()->setAspect('date', new ‪DateTimeAspect(new \DateTimeImmutable('2023-02-02 13:05:00')));
        ‪$subject = new ContentObjectRenderer($this->frontendControllerMock);
        $conf = ['formattedDate' => $pattern];
        if ($locale !== null) {
            $conf['formattedDate.']['locale'] = $locale;
        }
        self::assertEquals($expected, ‪$subject->stdWrap_formattedDate((string)$givenDate, $conf));
    }
 
    public static function ‪stdWrap_csConvDataProvider(): array
    {
        return [
            'empty string from ISO-8859-15' => [
                '',
                mb_convert_encoding('', 'ISO-8859-15', 'UTF-8'),
                ['csConv' => 'ISO-8859-15'],
            ],
            'empty string from BIG-5' => [
                '',
                mb_convert_encoding('', 'BIG-5'),
                ['csConv' => 'BIG-5'],
            ],
            '"0" from ISO-8859-15' => [
                '0',
                mb_convert_encoding('0', 'ISO-8859-15', 'UTF-8'),
                ['csConv' => 'ISO-8859-15'],
            ],
            '"0" from BIG-5' => [
                '0',
                mb_convert_encoding('0', 'BIG-5'),
                ['csConv' => 'BIG-5'],
            ],
            'euro symbol from ISO-88859-15' => [
                '€',
                mb_convert_encoding('€', 'ISO-8859-15', 'UTF-8'),
                ['csConv' => 'ISO-8859-15'],
            ],
            'good morning from BIG-5' => [
                '早安',
                mb_convert_encoding('早安', 'BIG-5'),
                ['csConv' => 'BIG-5'],
            ],
        ];
    }
 
    public function ‪stdWrap_csConv(string $expected, string $input, array $conf): void
    {
        self::assertSame(
            $expected,
            $this->subject->stdWrap_csConv($input, $conf)
        );
    }
 
    public function ‪stdWrap_current(): void
    {
        $data = [
            'currentValue_kidjls9dksoje' => 'default',
            'currentValue_new' => 'new',
        ];
        $this->subject->_set('data', $data);
        self::assertSame(
            'currentValue_kidjls9dksoje',
            $this->subject->_get('currentValKey')
        );
        self::assertSame(
            'default',
            $this->subject->stdWrap_current('discarded', ['discarded'])
        );
        $this->subject->_set('currentValKey', 'currentValue_new');
        self::assertSame(
            'new',
            $this->subject->stdWrap_current('discarded', ['discarded'])
        );
    }
 
    public static function ‪stdWrap_dataDataProvider(): array
    {
        $data = [‪StringUtility::getUniqueId('data')];
        return [
            'default' => [$data, $data, ''],
        ];
    }
 
    public function ‪stdWrap_data(array $expect, array $data): void
    {
        $conf = ['data' => ‪StringUtility::getUniqueId('conf.data')];
        $return = ‪StringUtility::getUniqueId('return');
        ‪$subject = $this->getAccessibleMock(
            ContentObjectRenderer::class,
            ['getData']
        );
        ‪$subject->_set('data', $data);
        ‪$subject
            ->expects(self::once())
            ->method('getData')
            ->with($conf['data'], $expect)
            ->willReturn($return);
        self::assertSame($return, ‪$subject->stdWrap_data('discard', $conf));
    }
 
    public function ‪stdWrap_dataWrap(): void
    {
        $content = ‪StringUtility::getUniqueId('content');
        $conf = [
            'dataWrap' => ‪StringUtility::getUniqueId('dataWrap'),
            'dataWrap.' => [‪StringUtility::getUniqueId('not used')],
        ];
        $return = ‪StringUtility::getUniqueId('return');
        ‪$subject = $this->getMockBuilder(ContentObjectRenderer::class)
            ->onlyMethods(['dataWrap'])->getMock();
        ‪$subject
            ->expects(self::once())
            ->method('dataWrap')
            ->with($content, $conf['dataWrap'])
            ->willReturn($return);
        self::assertSame(
            $return,
            ‪$subject->stdWrap_dataWrap($content, $conf)
        );
    }
 
    public static function ‪stdWrap_dateDataProvider(): array
    {
        // Fictive execution time: 2015-10-02 12:00
        $now = 1443780000;
        return [
            'given timestamp' => [
                '02.10.2015',
                $now,
                ['date' => 'd.m.Y'],
                $now,
            ],
            'empty string' => [
                '02.10.2015',
                '',
                ['date' => 'd.m.Y'],
                $now,
            ],
            'testing null' => [
                '02.10.2015',
                null,
                ['date' => 'd.m.Y'],
                $now,
            ],
            'given timestamp return GMT' => [
                '02.10.2015 10:00:00',
                $now,
                [
                    'date' => 'd.m.Y H:i:s',
                    'date.' => ['GMT' => true],
                ],
                $now,
            ],
        ];
    }
 
    public function ‪stdWrap_date(string $expected, mixed $content, array $conf, int $now): void
    {
        ‪$GLOBALS['EXEC_TIME'] = $now;
        self::assertEquals(
            $expected,
            $this->subject->stdWrap_date($content, $conf)
        );
    }
 
    public function ‪stdWrap_debug(): void
    {
        $expect = '<pre>&lt;p class=&quot;class&quot;&gt;&lt;br/&gt;'
            . '&lt;/p&gt;</pre>';
        $content = '<p class="class"><br/></p>';
        self::assertSame($expect, $this->subject->stdWrap_debug($content));
    }
 
    public function ‪stdWrap_debugData(): void
    {
        ‪$GLOBALS['TYPO3_CONF_VARS']['SYS']['devIPmask'] = '*';
        $content = ‪StringUtility::getUniqueId('content');
        $key = ‪StringUtility::getUniqueId('key');
        $value = ‪StringUtility::getUniqueId('value');
        $altValue = ‪StringUtility::getUniqueId('value alt');
        $this->subject->data = [$key => $value];
        ob_start();
        $result = $this->subject->stdWrap_debugData($content);
        $out = ob_get_clean();
        self::assertSame($result, $content);
        self::assertStringContainsString('$cObj->data', $out);
        self::assertStringContainsString($value, $out);
        self::assertStringNotContainsString($altValue, $out);
    }
 
    public static function ‪stdWrap_debugFuncDataProvider(): array
    {
        return [
            'expect array by string' => [true, '2'],
            'expect array by integer' => [true, 2],
            'do not expect array' => [false, ''],
        ];
    }
 
    public function ‪stdWrap_debugFunc(bool $expectArray, mixed $confDebugFunc): void
    {
        ‪$GLOBALS['TYPO3_CONF_VARS']['SYS']['devIPmask'] = '*';
        $content = ‪StringUtility::getUniqueId('content');
        $conf = ['debugFunc' => $confDebugFunc];
        ob_start();
        $result = $this->subject->stdWrap_debugFunc($content, $conf);
        $out = ob_get_clean();
        self::assertSame($result, $content);
        self::assertStringContainsString($content, $out);
        if ($expectArray) {
            self::assertStringContainsString('=>', $out);
        } else {
            self::assertStringNotContainsString('=>', $out);
        }
    }
 
    public static function ‪stdWrapDoubleBrTagDataProvider(): array
    {
        return [
            'no config: void input' => [
                '',
                '',
                [],
            ],
            'no config: single break' => [
                'one' . LF . 'two',
                'one' . LF . 'two',
                [],
            ],
            'no config: double break' => [
                'onetwo',
                'one' . LF . LF . 'two',
                [],
            ],
            'no config: double break with whitespace' => [
                'onetwo',
                'one' . LF . "\t" . ' ' . "\t" . ' ' . LF . 'two',
                [],
            ],
            'no config: single break around' => [
                LF . 'one' . LF,
                LF . 'one' . LF,
                [],
            ],
            'no config: double break around' => [
                'one',
                LF . LF . 'one' . LF . LF,
                [],
            ],
            'empty string: double break around' => [
                'one',
                LF . LF . 'one' . LF . LF,
                ['doubleBrTag' => ''],
            ],
            'br tag: double break' => [
                'one<br/>two',
                'one' . LF . LF . 'two',
                ['doubleBrTag' => '<br/>'],
            ],
            'br tag: double break around' => [
                '<br/>one<br/>',
                LF . LF . 'one' . LF . LF,
                ['doubleBrTag' => '<br/>'],
            ],
            'double br tag: double break around' => [
                '<br/><br/>one<br/><br/>',
                LF . LF . 'one' . LF . LF,
                ['doubleBrTag' => '<br/><br/>'],
            ],
        ];
    }
 
    public function ‪stdWrap_doubleBrTag(string $expected, string $input, array $config): void
    {
        self::assertEquals($expected, $this->subject->stdWrap_doubleBrTag($input, $config));
    }
 
    public function ‪stdWrap_encapsLines(): void
    {
        $content = ‪StringUtility::getUniqueId('content');
        $conf = [
            'encapsLines' => [‪StringUtility::getUniqueId('not used')],
            'encapsLines.' => [‪StringUtility::getUniqueId('encapsLines.')],
        ];
        $return = ‪StringUtility::getUniqueId('return');
        ‪$subject = $this->getMockBuilder(ContentObjectRenderer::class)
            ->onlyMethods(['encaps_lineSplit'])->getMock();
        ‪$subject
            ->expects(self::once())
            ->method('encaps_lineSplit')
            ->with($content, $conf['encapsLines.'])
            ->willReturn($return);
        self::assertSame(
            $return,
            ‪$subject->stdWrap_encapsLines($content, $conf)
        );
    }
 
    public function ‪stdWrap_encapsLines_HTML5SelfClosingTags(string $input, string $expected): void
    {
        $rteParseFunc = $this->‪getLibParseFunc_RTE();
 
        $conf = [
            'encapsLines' => $rteParseFunc['parseFunc.']['nonTypoTagStdWrap.']['encapsLines'] ?? null,
            'encapsLines.' => $rteParseFunc['parseFunc.']['nonTypoTagStdWrap.']['encapsLines.'] ?? null,
        ];
        // don't add an &nbsp; to tag without content
        $conf['encapsLines.']['innerStdWrap_all.']['ifBlank'] = '';
        $additionalEncapsTags = ['a', 'b', 'span'];
 
        // We want to allow any tag to be an encapsulating tag
        // since this is possible and we don't want an additional tag to be wrapped around.
        $conf['encapsLines.']['encapsTagList'] .= ',' . implode(',', $additionalEncapsTags);
        $conf['encapsLines.']['encapsTagList'] .= ',' . implode(',', [$input]);
 
        // Check if we get a self-closing tag for
        // empty tags where this is allowed according to HTML5
        $content = '<' . $input . ' id="myId" class="bodytext" />';
        $result = $this->subject->stdWrap_encapsLines($content, $conf);
        self::assertSame($expected, $result);
    }
 
    public static function ‪html5SelfClosingTagsDataprovider(): array
    {
        return [
            'areaTag_selfclosing' => [
                'input' => 'area',
                'expected' => '<area id="myId" class="bodytext" />',
            ],
            'base_selfclosing' => [
                'input' => 'base',
                'expected' => '<base id="myId" class="bodytext" />',
            ],
            'br_selfclosing' => [
                'input' => 'br',
                'expected' => '<br id="myId" class="bodytext" />',
            ],
            'col_selfclosing' => [
                'input' => 'col',
                'expected' => '<col id="myId" class="bodytext" />',
            ],
            'embed_selfclosing' => [
                'input' => 'embed',
                'expected' => '<embed id="myId" class="bodytext" />',
            ],
            'hr_selfclosing' => [
                'input' => 'hr',
                'expected' => '<hr id="myId" class="bodytext" />',
            ],
            'img_selfclosing' => [
                'input' => 'img',
                'expected' => '<img id="myId" class="bodytext" />',
            ],
            'input_selfclosing' => [
                'input' => 'input',
                'expected' => '<input id="myId" class="bodytext" />',
            ],
            'keygen_selfclosing' => [
                'input' => 'keygen',
                'expected' => '<keygen id="myId" class="bodytext" />',
            ],
            'link_selfclosing' => [
                'input' => 'link',
                'expected' => '<link id="myId" class="bodytext" />',
            ],
            'meta_selfclosing' => [
                'input' => 'meta',
                'expected' => '<meta id="myId" class="bodytext" />',
            ],
            'param_selfclosing' => [
                'input' => 'param',
                'expected' => '<param id="myId" class="bodytext" />',
            ],
            'source_selfclosing' => [
                'input' => 'source',
                'expected' => '<source id="myId" class="bodytext" />',
            ],
            'track_selfclosing' => [
                'input' => 'track',
                'expected' => '<track id="myId" class="bodytext" />',
            ],
            'wbr_selfclosing' => [
                'input' => 'wbr',
                'expected' => '<wbr id="myId" class="bodytext" />',
            ],
            'p_notselfclosing' => [
                'input' => 'p',
                'expected' => '<p id="myId" class="bodytext"></p>',
            ],
            'a_notselfclosing' => [
                'input' => 'a',
                'expected' => '<a id="myId" class="bodytext"></a>',
            ],
            'strong_notselfclosing' => [
                'input' => 'strong',
                'expected' => '<strong id="myId" class="bodytext"></strong>',
            ],
            'span_notselfclosing' => [
                'input' => 'span',
                'expected' => '<span id="myId" class="bodytext"></span>',
            ],
        ];
    }
 
    public static function ‪stdWrap_encodeForJavaScriptValueDataProvider(): array
    {
        return [
            'double quote in string' => [
                '\'double\u0020quote\u0022\'',
                'double quote"',
            ],
            'backslash in string' => [
                '\'backslash\u0020\u005C\'',
                'backslash \\',
            ],
            'exclamation mark' => [
                '\'exclamation\u0021\'',
                'exclamation!',
            ],
            'whitespace tab, newline and carriage return' => [
                '\'white\u0009space\u000As\u000D\'',
                "white\tspace\ns\r",
            ],
            'single quote in string' => [
                '\'single\u0020quote\u0020\u0027\'',
                'single quote \'',
            ],
            'tag' => [
                '\'\u003Ctag\u003E\'',
                '<tag>',
            ],
            'ampersand in string' => [
                '\'amper\u0026sand\'',
                'amper&sand',
            ],
        ];
    }
 
    public function ‪stdWrap_encodeForJavaScriptValue(string $expect, string $content): void
    {
        self::assertSame(
            $expect,
            $this->subject->stdWrap_encodeForJavaScriptValue($content)
        );
    }
 
    public static function ‪stdWrap_expandListDataProvider(): array
    {
        return [
            'numbers' => ['1,2,3', '1,2,3'],
            'range' => ['3,4,5', '3-5'],
            'numbers and range' => ['1,3,4,5,7', '1,3-5,7'],
        ];
    }
 
    public function ‪stdWrap_expandList(string $expected, string $content): void
    {
        self::assertEquals(
            $expected,
            $this->subject->stdWrap_expandList($content)
        );
    }
 
    public function ‪stdWrap_field(): void
    {
        $expect = ‪StringUtility::getUniqueId('expect');
        $conf = ['field' => ‪StringUtility::getUniqueId('field')];
        ‪$subject = $this->getMockBuilder(ContentObjectRenderer::class)
            ->onlyMethods(['getFieldVal'])->getMock();
        ‪$subject
            ->expects(self::once())
            ->method('getFieldVal')
            ->with($conf['field'])
            ->willReturn($expect);
        self::assertSame(
            $expect,
            ‪$subject->stdWrap_field('discarded', $conf)
        );
    }
 
    public static function ‪stdWrap_fieldRequiredDataProvider(): array
    {
        $content = ‪StringUtility::getUniqueId('content');
        return [
            // resulting in boolean false
            'false is false' => [
                '',
                true,
                $content,
                ['fieldRequired' => 'false'],
            ],
            'null is false' => [
                '',
                true,
                $content,
                ['fieldRequired' => 'null'],
            ],
            'empty string is false' => [
                '',
                true,
                $content,
                ['fieldRequired' => 'empty'],
            ],
            'whitespace is false' => [
                '',
                true,
                $content,
                ['fieldRequired' => 'whitespace'],
            ],
            'string zero is false' => [
                '',
                true,
                $content,
                ['fieldRequired' => 'stringZero'],
            ],
            'string zero with whitespace is false' => [
                '',
                true,
                $content,
                ['fieldRequired' => 'stringZeroWithWhiteSpace'],
            ],
            'zero is false' => [
                '',
                true,
                $content,
                ['fieldRequired' => 'zero'],
            ],
            // resulting in boolean true
            'true is true' => [
                $content,
                false,
                $content,
                ['fieldRequired' => 'true'],
            ],
            'string is true' => [
                $content,
                false,
                $content,
                ['fieldRequired' => 'string'],
            ],
            'one is true' => [
                $content,
                false,
                $content,
                ['fieldRequired' => 'one'],
            ],
        ];
    }
 
    public function ‪stdWrap_fieldRequired(string $expect, bool $stop, string $content, array $conf): void
    {
        $data = [
            'null' => null,
            'false' => false,
            'empty' => '',
            'whitespace' => "\t" . ' ',
            'stringZero' => '0',
            'stringZeroWithWhiteSpace' => "\t" . ' 0 ' . "\t",
            'zero' => 0,
            'string' => 'string',
            'true' => true,
            'one' => 1,
        ];
        ‪$subject = ‪$this->subject;
        ‪$subject->_set('data', $data);
        ‪$subject->_set('stdWrapRecursionLevel', 1);
        ‪$subject->_set('stopRendering', [1 => false]);
        self::assertSame(
            $expect,
            ‪$subject->stdWrap_fieldRequired($content, $conf)
        );
        self::assertSame($stop, ‪$subject->_get('stopRendering')[1]);
    }
 
    public static function ‪hashDataProvider(): array
    {
        return [
            'md5' => [
                'bacb98acf97e0b6112b1d1b650b84971',
                'joh316',
                ['hash' => 'md5'],
            ],
            'sha1' => [
                '063b3d108bed9f88fa618c6046de0dccadcf3158',
                'joh316',
                ['hash' => 'sha1'],
            ],
            'stdWrap capability' => [
                'bacb98acf97e0b6112b1d1b650b84971',
                'joh316',
                [
                    'hash' => '5',
                    'hash.' => ['wrap' => 'md|'],
                ],
            ],
            'non-existing hashing algorithm' => [
                '',
                'joh316',
                ['hash' => 'non-existing'],
            ],
        ];
    }
 
    public function ‪stdWrap_hash(string $expect, string $content, array $conf): void
    {
        self::assertSame(
            $expect,
            $this->subject->stdWrap_hash($content, $conf)
        );
    }
 
    public static function ‪stdWrap_htmlSpecialCharsDataProvider(): array
    {
        return [
            'void conf' => [
                '&lt;span&gt;1 &amp;lt; 2&lt;/span&gt;',
                '<span>1 &lt; 2</span>',
                [],
            ],
            'void preserveEntities' => [
                '&lt;span&gt;1 &amp;lt; 2&lt;/span&gt;',
                '<span>1 &lt; 2</span>',
                ['htmlSpecialChars.' => []],
            ],
            'false preserveEntities' => [
                '&lt;span&gt;1 &amp;lt; 2&lt;/span&gt;',
                '<span>1 &lt; 2</span>',
                ['htmlSpecialChars.' => ['preserveEntities' => 0]],
            ],
            'true preserveEntities' => [
                '&lt;span&gt;1 &lt; 2&lt;/span&gt;',
                '<span>1 &lt; 2</span>',
                ['htmlSpecialChars.' => ['preserveEntities' => 1]],
            ],
        ];
    }
 
    public function ‪stdWrap_htmlSpecialChars(string $expected, string $input, array $conf): void
    {
        self::assertSame(
            $expected,
            $this->subject->stdWrap_htmlSpecialChars($input, $conf)
        );
    }
 
    public static function ‪stdWrap_ifDataProvider(): array
    {
        $content = ‪StringUtility::getUniqueId('content');
        $conf = ['if.' => [‪StringUtility::getUniqueId('if.')]];
        return [
            // evals to true
            'empty config' => [
                $content,
                false,
                $content,
                [],
                0,
                false,
            ],
            'if. is empty array' => [
                $content,
                false,
                $content,
                ['if.' => []],
                0,
                false,
            ],
            'if. is null' => [
                $content,
                false,
                $content,
                ['if.' => null],
                0,
                false,
            ],
            'if. is false' => [
                $content,
                false,
                $content,
                ['if.' => false],
                0,
                false,
            ],
            'if. is 0' => [
                $content,
                false,
                $content,
                ['if.' => false],
                0,
                false,
            ],
            'if. is "0"' => [
                $content,
                false,
                $content,
                ['if.' => '0'],
                0,
                false,
            ],
            'checkIf returning true' => [
                $content,
                false,
                $content,
                $conf,
                1,
                true,
            ],
            // evals to false
            'checkIf returning false' => [
                '',
                true,
                $content,
                $conf,
                1,
                false,
            ],
        ];
    }
 
    public function ‪stdWrap_if(string $expect, bool $stop, string $content, array $conf, int $times, bool $will): void
    {
        ‪$subject = $this->getAccessibleMock(
            ContentObjectRenderer::class,
            ['checkIf']
        );
        ‪$subject->_set('stdWrapRecursionLevel', 1);
        ‪$subject->_set('stopRendering', [1 => false]);
        ‪$subject
            ->expects(self::exactly($times))
            ->method('checkIf')
            ->with($conf['if.'] ?? null)
            ->willReturn($will);
        self::assertSame($expect, ‪$subject->stdWrap_if($content, $conf));
        self::assertSame($stop, ‪$subject->_get('stopRendering')[1]);
    }
 
    public static function ‪checkIfDataProvider(): array
    {
        return [
            'true bitAnd the same' => [true, ['bitAnd' => '4', 'value' => '4']],
            'true bitAnd included' => [true, ['bitAnd' => '6', 'value' => '4']],
            'false bitAnd' => [false, ['bitAnd' => '4', 'value' => '3']],
            'negate true bitAnd the same' => [false, ['bitAnd' => '4', 'value' => '4', 'negate' => '1']],
            'negate true bitAnd included' => [false, ['bitAnd' => '6', 'value' => '4', 'negate' => '1']],
            'negate false bitAnd' => [true, ['bitAnd' => '3', 'value' => '4', 'negate' => '1']],
            'contains matches' => [true, ['contains' => 'long text', 'value' => 'this is a long text']],
            'contains does not match' => [false, ['contains' => 'short text', 'value' => 'this is a long text']],
            'negate contains does not match' => [false, ['contains' => 'long text', 'value' => 'this is a long text', 'negate' => '1']],
            'negate contains does not match but matches' => [true, ['contains' => 'short text', 'value' => 'this is a long text', 'negate' => '1']],
            'startsWith matches' => [true, ['startsWith' => 'this is', 'value' => 'this is a long text']],
            'startsWith does not match' => [false, ['startsWith' => 'a long text', 'value' => 'this is a long text']],
            'negate startsWith does not match' => [false, ['startsWith' => 'this is', 'value' => 'this is a long text', 'negate' => '1']],
            'negate startsWith does not match but matches' => [true, ['startsWith' => 'a long text', 'value' => 'this is a long text', 'negate' => '1']],
            'endsWith matches' => [true, ['endsWith' => 'a long text', 'value' => 'this is a long text']],
            'endsWith does not match' => [false, ['endsWith' => 'this is', 'value' => 'this is a long text']],
            'negate endsWith does not match' => [false, ['endsWith' => 'a long text', 'value' => 'this is a long text', 'negate' => '1']],
            'negate endsWith does not match but matches' => [true, ['endsWith' => 'this is', 'value' => 'this is a long text', 'negate' => '1']],
        ];
    }
 
    public function ‪checkIf(bool $expect, array $conf): void
    {
        ‪$subject = $this->getAccessibleMock(
            ContentObjectRenderer::class,
            ['stdWrap']
        );
        self::assertSame($expect, ‪$subject->checkIf($conf));
    }
 
    public static function ‪stdWrap_ifBlankDataProvider(): array
    {
        $alt = ‪StringUtility::getUniqueId('alternative content');
        $conf = ['ifBlank' => $alt];
        return [
            // blank cases
            'null is blank' => [$alt, null, $conf],
            'false is blank' => [$alt, false, $conf],
            'empty string is blank' => [$alt, '', $conf],
            'whitespace is blank' => [$alt, "\t" . '', $conf],
            // non-blank cases
            'string is not blank' => ['string', 'string', $conf],
            'zero is not blank' => [0, 0, $conf],
            'zero string is not blank' => ['0', '0', $conf],
            'zero float is not blank' => [0.0, 0.0, $conf],
            'true is not blank' => [true, true, $conf],
        ];
    }
 
    public function ‪stdWrap_ifBlank(mixed $expect, mixed $content, array $conf): void
    {
        $result = $this->subject->stdWrap_ifBlank($content, $conf);
        self::assertSame($expect, $result);
    }
 
    public static function ‪stdWrap_ifEmptyDataProvider(): array
    {
        $alt = ‪StringUtility::getUniqueId('alternative content');
        $conf = ['ifEmpty' => $alt];
        return [
            // empty cases
            'null is empty' => [$alt, null, $conf],
            'false is empty' => [$alt, false, $conf],
            'zero is empty' => [$alt, 0, $conf],
            'float zero is empty' => [$alt, 0.0, $conf],
            'whitespace is empty' => [$alt, "\t" . ' ', $conf],
            'empty string is empty' => [$alt, '', $conf],
            'zero string is empty' => [$alt, '0', $conf],
            'zero string is empty with whitespace' => [
                $alt,
                "\t" . ' 0 ' . "\t",
                $conf,
            ],
            // non-empty cases
            'string is not empty' => ['string', 'string', $conf],
            '1 is not empty' => [1, 1, $conf],
            '-1 is not empty' => [-1, -1, $conf],
            '0.1 is not empty' => [0.1, 0.1, $conf],
            '-0.1 is not empty' => [-0.1, -0.1, $conf],
            'true is not empty' => [true, true, $conf],
        ];
    }
 
    public function ‪stdWrap_ifEmpty(mixed $expect, mixed $content, array $conf): void
    {
        $result = $this->subject->stdWrap_ifEmpty($content, $conf);
        self::assertSame($expect, $result);
    }
 
    public static function ‪stdWrap_ifNullDataProvider(): array
    {
        $alt = ‪StringUtility::getUniqueId('alternative content');
        $conf = ['ifNull' => $alt];
        return [
            'only null is null' => [$alt, null, $conf],
            'zero is not null' => [0, 0, $conf],
            'float zero is not null' => [0.0, 0.0, $conf],
            'false is not null' => [false, false, $conf],
            'zero string is not null' => ['0', '0', $conf],
            'empty string is not null' => ['', '', $conf],
            'whitespace is not null' => ["\t" . '', "\t" . '', $conf],
        ];
    }
 
    public function ‪stdWrap_ifNull(mixed $expect, mixed $content, array $conf): void
    {
        $result = $this->subject->stdWrap_ifNull($content, $conf);
        self::assertSame($expect, $result);
    }
 
    public static function ‪stdWrap_innerWrapDataProvider(): array
    {
        return [
            'no conf' => [
                'XXX',
                'XXX',
                [],
            ],
            'simple' => [
                '<wrap>XXX</wrap>',
                'XXX',
                ['innerWrap' => '<wrap>|</wrap>'],
            ],
            'missing pipe puts wrap before' => [
                '<pre>XXX',
                'XXX',
                ['innerWrap' => '<pre>'],
            ],
            'trims whitespace' => [
                '<wrap>XXX</wrap>',
                'XXX',
                ['innerWrap' => '<wrap>' . "\t" . ' | ' . "\t" . '</wrap>'],
            ],
            'split char change is not possible' => [
                '<wrap> # </wrap>XXX',
                'XXX',
                [
                    'innerWrap' => '<wrap> # </wrap>',
                    'innerWrap.' => ['splitChar' => '#'],
                ],
            ],
        ];
    }
 
    public function ‪stdWrap_innerWrap(string $expected, string $input, array $conf): void
    {
        self::assertSame(
            $expected,
            $this->subject->stdWrap_innerWrap($input, $conf)
        );
    }
 
    public static function ‪stdWrap_innerWrap2DataProvider(): array
    {
        return [
            'no conf' => [
                'XXX',
                'XXX',
                [],
            ],
            'simple' => [
                '<wrap>XXX</wrap>',
                'XXX',
                ['innerWrap2' => '<wrap>|</wrap>'],
            ],
            'missing pipe puts wrap before' => [
                '<pre>XXX',
                'XXX',
                ['innerWrap2' => '<pre>'],
            ],
            'trims whitespace' => [
                '<wrap>XXX</wrap>',
                'XXX',
                ['innerWrap2' => '<wrap>' . "\t" . ' | ' . "\t" . '</wrap>'],
            ],
            'split char change is not possible' => [
                '<wrap> # </wrap>XXX',
                'XXX',
                [
                    'innerWrap2' => '<wrap> # </wrap>',
                    'innerWrap2.' => ['splitChar' => '#'],
                ],
            ],
        ];
    }
 
    public function ‪stdWrap_innerWrap2(string $expected, string $input, array $conf): void
    {
        self::assertSame(
            $expected,
            $this->subject->stdWrap_innerWrap2($input, $conf)
        );
    }
 
    public function ‪stdWrap_insertData(): void
    {
        $content = ‪StringUtility::getUniqueId('content');
        $return = ‪StringUtility::getUniqueId('return');
        ‪$subject = $this->getMockBuilder(ContentObjectRenderer::class)
            ->onlyMethods(['insertData'])->getMock();
        ‪$subject->expects(self::once())->method('insertData')
            ->with($content)->willReturn($return);
        self::assertSame(
            $return,
            ‪$subject->stdWrap_insertData($content)
        );
    }
 
    public static function ‪stdWrap_insertDataProvider(): array
    {
        return [
            'empty' => ['', ''],
            'notFoundData' => ['any=1', 'any{$string}=1'],
            'queryParameter' => ['any{#string}=1', 'any{#string}=1'],
        ];
    }
 
    public function ‪stdWrap_insertDataAndInputExamples(mixed $expect, string $content): void
    {
        self::assertSame($expect, $this->subject->stdWrap_insertData($content));
    }
 
    public static function ‪stdWrap_intvalDataProvider(): array
    {
        return [
            // numbers
            'int' => [123, 123],
            'float' => [123, 123.45],
            'float does not round up' => [123, 123.55],
            // negative numbers
            'negative int' => [-123, -123],
            'negative float' => [-123, -123.45],
            'negative float does not round down' => [-123, -123.55],
            // strings
            'word string' => [0, 'string'],
            'empty string' => [0, ''],
            'zero string' => [0, '0'],
            'int string' => [123, '123'],
            'float string' => [123, '123.55'],
            'negative float string' => [-123, '-123.55'],
            // other types
            'null' => [0, null],
            'true' => [1, true],
            'false' => [0, false],
        ];
    }
 
    public function ‪stdWrap_intval(int $expect, mixed $content): void
    {
        self::assertSame($expect, $this->subject->stdWrap_intval($content));
    }
 
    public static function ‪stdWrapKeywordsDataProvider(): array
    {
        return [
            'empty string' => ['', ''],
            'blank' => ['', ' '],
            'tab' => ['', "\t"],
            'single semicolon' => [',', ' ; '],
            'single comma' => [',', ' , '],
            'single nl' => [',', ' ' . PHP_EOL . ' '],
            'double semicolon' => [',,', ' ; ; '],
            'double comma' => [',,', ' , , '],
            'double nl' => [',,', ' ' . PHP_EOL . ' ' . PHP_EOL . ' '],
            'simple word' => ['one', ' one '],
            'simple word trimmed' => ['one', 'one'],
            ', separated' => ['one,two', ' one , two '],
            '; separated' => ['one,two', ' one ; two '],
            'nl separated' => ['one,two', ' one ' . PHP_EOL . ' two '],
            ', typical' => ['one,two,three', 'one, two, three'],
            '; typical' => ['one,two,three', ' one; two; three'],
            'nl typical' => [
                'one,two,three',
                'one' . PHP_EOL . 'two' . PHP_EOL . 'three',
            ],
            ', sourounded' => [',one,two,', ' , one , two , '],
            '; sourounded' => [',one,two,', ' ; one ; two ; '],
            'nl sourounded' => [
                ',one,two,',
                ' ' . PHP_EOL . ' one ' . PHP_EOL . ' two ' . PHP_EOL . ' ',
            ],
            'mixed' => [
                'one,two,three,four',
                ' one, two; three' . PHP_EOL . 'four',
            ],
            'keywods with blanks in words' => [
                'one plus,two minus',
                ' one plus , two minus ',
            ],
        ];
    }
 
    public function ‪stdWrap_keywords(string $expected, string $input): void
    {
        self::assertSame($expected, $this->subject->stdWrap_keywords($input));
    }
 
    public static function ‪stdWrap_langDataProvider(): array
    {
        return [
            'empty conf' => [
                'original',
                'original',
                [],
                'de_DE',
            ],
            'translation de' => [
                'Übersetzung',
                'original',
                [
                    'lang.' => [
                        'de' => 'Übersetzung',
                        'it' => 'traduzione',
                    ],
                ],
                'de_DE',
            ],
            'translation it' => [
                'traduzione',
                'original',
                [
                    'lang.' => [
                        'de' => 'Übersetzung',
                        'it' => 'traduzione',
                    ],
                ],
                'it_IT',
            ],
            'no translation' => [
                'original',
                'original',
                [
                    'lang.' => [
                        'de' => 'Übersetzung',
                        'it' => 'traduzione',
                    ],
                ],
                'en',
            ],
            'missing label' => [
                'original',
                'original',
                [
                    'lang.' => [
                        'de' => 'Übersetzung',
                        'it' => 'traduzione',
                    ],
                ],
                'fr_FR',
            ],
        ];
    }
 
    public function ‪stdWrap_langViaSiteLanguage(string $expected, string $input, array $conf, string $language): void
    {
        $site = $this->‪createSiteWithLanguage([
            'base' => '/',
            'languageId' => 2,
            'locale' => $language,
        ]);
        $this->frontendControllerMock->_set('language', $site->getLanguageById(2));
        self::assertSame(
            $expected,
            $this->subject->stdWrap_lang($input, $conf)
        );
    }
 
    public function ‪stdWrap_listNum(): void
    {
        $content = ‪StringUtility::getUniqueId('content');
        $conf = [
            'listNum' => ‪StringUtility::getUniqueId('listNum'),
            'listNum.' => [
                'splitChar' => ‪StringUtility::getUniqueId('splitChar'),
            ],
        ];
        $return = ‪StringUtility::getUniqueId('return');
        ‪$subject = $this->getMockBuilder(ContentObjectRenderer::class)
            ->onlyMethods(['listNum'])->getMock();
        ‪$subject
            ->expects(self::once())
            ->method('listNum')
            ->with(
                $content,
                $conf['listNum'],
                $conf['listNum.']['splitChar']
            )
            ->willReturn($return);
        self::assertSame(
            $return,
            ‪$subject->stdWrap_listNum($content, $conf)
        );
    }
 
    public static function ‪stdWrap_noTrimWrapDataProvider(): array
    {
        return [
            'Standard case' => [
                ' left middle right ',
                'middle',
                [
                    'noTrimWrap' => '| left | right |',
                ],
            ],
            'Tabs as whitespace' => [
                "\t" . 'left' . "\t" . 'middle' . "\t" . 'right' . "\t",
                'middle',
                [
                    'noTrimWrap' =>
                        '|' . "\t" . 'left' . "\t" . '|' . "\t" . 'right' . "\t" . '|',
                ],
            ],
            'Split char is 0' => [
                ' left middle right ',
                'middle',
                [
                    'noTrimWrap' => '0 left 0 right 0',
                    'noTrimWrap.' => ['splitChar' => '0'],
                ],
            ],
            'Split char is pipe (default)' => [
                ' left middle right ',
                'middle',
                [
                    'noTrimWrap' => '| left | right |',
                    'noTrimWrap.' => ['splitChar' => '|'],
                ],
            ],
            'Split char is a' => [
                ' left middle right ',
                'middle',
                [
                    'noTrimWrap' => 'a left a right a',
                    'noTrimWrap.' => ['splitChar' => 'a'],
                ],
            ],
            'Split char is a word (ab)' => [
                ' left middle right ',
                'middle',
                [
                    'noTrimWrap' => 'ab left ab right ab',
                    'noTrimWrap.' => ['splitChar' => 'ab'],
                ],
            ],
            'Split char accepts stdWrap' => [
                ' left middle right ',
                'middle',
                [
                    'noTrimWrap' => 'abc left abc right abc',
                    'noTrimWrap.' => [
                        'splitChar' => 'b',
                        'splitChar.' => ['wrap' => 'a|c'],
                    ],
                ],
            ],
        ];
    }
 
    public function ‪stdWrap_noTrimWrap(string $expect, string $content, array $conf): void
    {
        self::assertSame(
            $expect,
            $this->subject->stdWrap_noTrimWrap($content, $conf)
        );
    }
 
    public function ‪stdWrap_numRows(): void
    {
        $conf = [
            'numRows' => ‪StringUtility::getUniqueId('numRows'),
            'numRows.' => [‪StringUtility::getUniqueId('numRows')],
        ];
        ‪$subject = $this->getMockBuilder(ContentObjectRenderer::class)
            ->onlyMethods(['numRows'])->getMock();
        ‪$subject->expects(self::once())->method('numRows')
            ->with($conf['numRows.'])->willReturn('return');
        self::assertSame(
            'return',
            ‪$subject->stdWrap_numRows('discard', $conf)
        );
    }
 
    public function ‪stdWrap_numberFormat(): void
    {
        $content = ‪StringUtility::getUniqueId('content');
        $conf = [
            'numberFormat' => ‪StringUtility::getUniqueId('not used'),
            'numberFormat.' => [‪StringUtility::getUniqueId('numberFormat.')],
        ];
        $return = ‪StringUtility::getUniqueId('return');
        ‪$subject = $this->getMockBuilder(ContentObjectRenderer::class)
            ->onlyMethods(['numberFormat'])->getMock();
        ‪$subject
            ->expects(self::once())
            ->method('numberFormat')
            ->with((float)$content, $conf['numberFormat.'])
            ->willReturn($return);
        self::assertSame(
            $return,
            ‪$subject->stdWrap_numberFormat($content, $conf)
        );
    }
 
    public static function ‪stdWrap_outerWrapDataProvider(): array
    {
        return [
            'no conf' => [
                'XXX',
                'XXX',
                [],
            ],
            'simple' => [
                '<wrap>XXX</wrap>',
                'XXX',
                ['outerWrap' => '<wrap>|</wrap>'],
            ],
            'missing pipe puts wrap before' => [
                '<pre>XXX',
                'XXX',
                ['outerWrap' => '<pre>'],
            ],
            'trims whitespace' => [
                '<wrap>XXX</wrap>',
                'XXX',
                ['outerWrap' => '<wrap>' . "\t" . ' | ' . "\t" . '</wrap>'],
            ],
            'split char change is not possible' => [
                '<wrap> # </wrap>XXX',
                'XXX',
                [
                    'outerWrap' => '<wrap> # </wrap>',
                    'outerWrap.' => ['splitChar' => '#'],
                ],
            ],
        ];
    }
 
    public function ‪stdWrap_outerWrap(string $expected, string $input, array $conf): void
    {
        self::assertSame(
            $expected,
            $this->subject->stdWrap_outerWrap($input, $conf)
        );
    }
 
    public static function ‪stdWrap_overrideDataProvider(): array
    {
        return [
            'standard case' => [
                'override',
                'content',
                ['override' => 'override'],
            ],
            'empty conf does not override' => [
                'content',
                'content',
                [],
            ],
            'empty string does not override' => [
                'content',
                'content',
                ['override' => ''],
            ],
            'whitespace does not override' => [
                'content',
                'content',
                ['override' => ' ' . "\t"],
            ],
            'zero does not override' => [
                'content',
                'content',
                ['override' => 0],
            ],
            'false does not override' => [
                'content',
                'content',
                ['override' => false],
            ],
            'null does not override' => [
                'content',
                'content',
                ['override' => null],
            ],
            'one does override' => [
                1,
                'content',
                ['override' => 1],
            ],
            'minus one does override' => [
                -1,
                'content',
                ['override' => -1],
            ],
            'float does override' => [
                -0.1,
                'content',
                ['override' => -0.1],
            ],
            'true does override' => [
                true,
                'content',
                ['override' => true],
            ],
            'the value is not trimmed' => [
                "\t" . 'override',
                'content',
                ['override' => "\t" . 'override'],
            ],
        ];
    }
 
    public function ‪stdWrap_override(mixed $expect, string $content, array $conf): void
    {
        self::assertSame(
            $expect,
            $this->subject->stdWrap_override($content, $conf)
        );
    }
 
    public function ‪stdWrap_parseFunc(): void
    {
        $content = ‪StringUtility::getUniqueId('content');
        $conf = [
            'parseFunc' => ‪StringUtility::getUniqueId('parseFunc'),
            'parseFunc.' => [‪StringUtility::getUniqueId('parseFunc.')],
        ];
        $return = ‪StringUtility::getUniqueId('return');
        ‪$subject = $this->getMockBuilder(ContentObjectRenderer::class)
            ->onlyMethods(['parseFunc'])->getMock();
        ‪$subject
            ->expects(self::once())
            ->method('parseFunc')
            ->with($content, $conf['parseFunc.'], $conf['parseFunc'])
            ->willReturn($return);
        self::assertSame(
            $return,
            ‪$subject->stdWrap_parseFunc($content, $conf)
        );
    }
 
    public function ‪stdWrap_postCObject(): void
    {
        $debugKey = '/stdWrap/.postCObject';
        $content = ‪StringUtility::getUniqueId('content');
        $conf = [
            'postCObject' => ‪StringUtility::getUniqueId('postCObject'),
            'postCObject.' => [‪StringUtility::getUniqueId('postCObject.')],
        ];
        $return = ‪StringUtility::getUniqueId('return');
        ‪$subject = $this->getMockBuilder(ContentObjectRenderer::class)
            ->onlyMethods(['cObjGetSingle'])->getMock();
        ‪$subject
            ->expects(self::once())
            ->method('cObjGetSingle')
            ->with($conf['postCObject'], $conf['postCObject.'], $debugKey)
            ->willReturn($return);
        self::assertSame(
            $content . $return,
            ‪$subject->stdWrap_postCObject($content, $conf)
        );
    }
 
    public function ‪stdWrap_postUserFunc(): void
    {
        $content = ‪StringUtility::getUniqueId('content');
        $conf = [
            'postUserFunc' => ‪StringUtility::getUniqueId('postUserFunc'),
            'postUserFunc.' => [‪StringUtility::getUniqueId('postUserFunc.')],
        ];
        $return = ‪StringUtility::getUniqueId('return');
        ‪$subject = $this->getMockBuilder(ContentObjectRenderer::class)
            ->onlyMethods(['callUserFunction'])->getMock();
        ‪$subject
            ->expects(self::once())
            ->method('callUserFunction')
            ->with($conf['postUserFunc'], $conf['postUserFunc.'])
            ->willReturn($return);
        self::assertSame(
            $return,
            ‪$subject->stdWrap_postUserFunc($content, $conf)
        );
    }
 
    public function ‪stdWrap_postUserFuncInt(): void
    {
        $uniqueHash = ‪StringUtility::getUniqueId('uniqueHash');
        $substKey = 'INT_SCRIPT.' . $uniqueHash;
        $content = ‪StringUtility::getUniqueId('content');
        $conf = [
            'postUserFuncInt' => ‪StringUtility::getUniqueId('function'),
            'postUserFuncInt.' => [‪StringUtility::getUniqueId('function array')],
        ];
        $expect = '<!--' . $substKey . '-->';
        $frontend = $this->getMockBuilder(TypoScriptFrontendController::class)
            ->disableOriginalConstructor()->onlyMethods(['uniqueHash'])
            ->getMock();
        $frontend->expects(self::once())->method('uniqueHash')
            ->with()->willReturn($uniqueHash);
        $frontend->config = ['INTincScript' => []];
        ‪$subject = $this->getAccessibleMock(
            ContentObjectRenderer::class,
            null,
            [$frontend]
        );
        self::assertSame(
            $expect,
            ‪$subject->stdWrap_postUserFuncInt($content, $conf)
        );
        $array = [
            'content' => $content,
            'postUserFunc' => $conf['postUserFuncInt'],
            'conf' => $conf['postUserFuncInt.'],
            'type' => 'POSTUSERFUNC',
            'cObj' => serialize(‪$subject),
        ];
        self::assertSame(
            $array,
            $frontend->config['INTincScript'][$substKey]
        );
    }
 
    public function ‪stdWrap_preCObject(): void
    {
        $debugKey = '/stdWrap/.preCObject';
        $content = ‪StringUtility::getUniqueId('content');
        $conf = [
            'preCObject' => ‪StringUtility::getUniqueId('preCObject'),
            'preCObject.' => [‪StringUtility::getUniqueId('preCObject.')],
        ];
        $return = ‪StringUtility::getUniqueId('return');
        ‪$subject = $this->getMockBuilder(ContentObjectRenderer::class)
            ->onlyMethods(['cObjGetSingle'])->getMock();
        ‪$subject
            ->expects(self::once())
            ->method('cObjGetSingle')
            ->with($conf['preCObject'], $conf['preCObject.'], $debugKey)
            ->willReturn($return);
        self::assertSame(
            $return . $content,
            ‪$subject->stdWrap_preCObject($content, $conf)
        );
    }
 
    public function ‪stdWrap_preIfEmptyListNum(): void
    {
        $content = ‪StringUtility::getUniqueId('content');
        $conf = [
            'preIfEmptyListNum' => ‪StringUtility::getUniqueId('preIfEmptyListNum'),
            'preIfEmptyListNum.' => [
                'splitChar' => ‪StringUtility::getUniqueId('splitChar'),
            ],
        ];
        $return = ‪StringUtility::getUniqueId('return');
        ‪$subject = $this->getMockBuilder(ContentObjectRenderer::class)
            ->onlyMethods(['listNum'])->getMock();
        ‪$subject
            ->expects(self::once())
            ->method('listNum')
            ->with(
                $content,
                $conf['preIfEmptyListNum'],
                $conf['preIfEmptyListNum.']['splitChar']
            )
            ->willReturn($return);
        self::assertSame(
            $return,
            ‪$subject->stdWrap_preIfEmptyListNum($content, $conf)
        );
    }
 
    public static function ‪stdWrap_prefixCommentDataProvider(): array
    {
        $content = ‪StringUtility::getUniqueId('content');
        $will = ‪StringUtility::getUniqueId('will');
        $conf = [];
        $conf['prefixComment'] = ‪StringUtility::getUniqueId('prefixComment');
        $emptyConf1 = [];
        $emptyConf2 = [];
        $emptyConf2['prefixComment'] = '';
        return [
            'standard case' => [$will, $content, $conf, false, 1, $will],
            'emptyConf1' => [$content, $content, $emptyConf1, false, 0, $will],
            'emptyConf2' => [$content, $content, $emptyConf2, false, 0, $will],
            'disabled by bool' => [$content, $content, $conf, true, 0, $will],
            'disabled by int' => [$content, $content, $conf, 1, 0, $will],
        ];
    }
 
    public function ‪stdWrap_prefixComment(
        string $expect,
        string $content,
        array $conf,
        int|bool $disable,
        int $times,
        string $will
    ): void {
        $this->frontendControllerMock
            ->config['config']['disablePrefixComment'] = $disable;
        ‪$subject = $this->getMockBuilder(ContentObjectRenderer::class)
            ->onlyMethods(['prefixComment'])->getMock();
        ‪$subject
            ->expects(self::exactly($times))
            ->method('prefixComment')
            ->with($conf['prefixComment'] ?? null, [], $content)
            ->willReturn($will);
        self::assertSame(
            $expect,
            ‪$subject->stdWrap_prefixComment($content, $conf)
        );
    }
 
    public function ‪stdWrap_prepend(): void
    {
        $debugKey = '/stdWrap/.prepend';
        $content = ‪StringUtility::getUniqueId('content');
        $conf = [
            'prepend' => ‪StringUtility::getUniqueId('prepend'),
            'prepend.' => [‪StringUtility::getUniqueId('prepend.')],
        ];
        $return = ‪StringUtility::getUniqueId('return');
        ‪$subject = $this->getMockBuilder(ContentObjectRenderer::class)
            ->onlyMethods(['cObjGetSingle'])->getMock();
        ‪$subject
            ->expects(self::once())
            ->method('cObjGetSingle')
            ->with($conf['prepend'], $conf['prepend.'], $debugKey)
            ->willReturn($return);
        self::assertSame(
            $return . $content,
            ‪$subject->stdWrap_prepend($content, $conf)
        );
    }
 
    public static function ‪stdWrap_prioriCalcDataProvider(): array
    {
        return [
            'priority of *' => ['7', '1 + 2 * 3', []],
            'priority of parentheses' => ['9', '(1 + 2) * 3', []],
            'float' => ['1.5', '3/2', []],
            'intval casts to int' => [1, '3/2', ['prioriCalc' => 'intval']],
            'intval does not round' => [2, '2.7', ['prioriCalc' => 'intval']],
        ];
    }
 
    public function ‪stdWrap_prioriCalc(mixed $expect, string $content, array $conf): void
    {
        $result = $this->subject->stdWrap_prioriCalc($content, $conf);
        self::assertSame($expect, $result);
    }
 
    public function ‪stdWrap_preUserFunc(): void
    {
        $content = ‪StringUtility::getUniqueId('content');
        $conf = [
            'preUserFunc' => ‪StringUtility::getUniqueId('preUserFunc'),
            'preUserFunc.' => [‪StringUtility::getUniqueId('preUserFunc.')],
        ];
        ‪$subject = $this->getMockBuilder(ContentObjectRenderer::class)
            ->onlyMethods(['callUserFunction'])->getMock();
        ‪$subject->expects(self::once())->method('callUserFunction')
            ->with($conf['preUserFunc'], $conf['preUserFunc.'], $content)
            ->willReturn('return');
        self::assertSame(
            'return',
            ‪$subject->stdWrap_preUserFunc($content, $conf)
        );
    }
 
    public static function ‪stdWrap_rawUrlEncodeDataProvider(): array
    {
        return [
            'https://typo3.org?id=10' => [
                'https%3A%2F%2Ftypo3.org%3Fid%3D10',
                'https://typo3.org?id=10',
            ],
            'https://typo3.org?id=10&foo=bar' => [
                'https%3A%2F%2Ftypo3.org%3Fid%3D10%26foo%3Dbar',
                'https://typo3.org?id=10&foo=bar',
            ],
        ];
    }
 
    public function ‪stdWrap_rawUrlEncode(string $expect, string $content): void
    {
        self::assertSame(
            $expect,
            $this->subject->stdWrap_rawUrlEncode($content)
        );
    }
 
    public function ‪stdWrap_replacement(): void
    {
        $content = ‪StringUtility::getUniqueId('content');
        $conf = [
            'replacement' => ‪StringUtility::getUniqueId('not used'),
            'replacement.' => [‪StringUtility::getUniqueId('replacement.')],
        ];
        $return = ‪StringUtility::getUniqueId('return');
        ‪$subject = $this->getMockBuilder(ContentObjectRenderer::class)
            ->onlyMethods(['replacement'])->getMock();
        ‪$subject
            ->expects(self::once())
            ->method('replacement')
            ->with($content, $conf['replacement.'])
            ->willReturn($return);
        self::assertSame(
            $return,
            ‪$subject->stdWrap_replacement($content, $conf)
        );
    }
 
    public static function ‪stdWrap_requiredDataProvider(): array
    {
        return [
            // empty content
            'empty string is empty' => ['', true, ''],
            'null is empty' => ['', true, null],
            'false is empty' => ['', true, false],
 
            // non-empty content
            'blank is not empty' => [' ', false, ' '],
            'tab is not empty' => ["\t", false, "\t"],
            'linebreak is not empty' => [PHP_EOL, false, PHP_EOL],
            '"0" is not empty' => ['0', false, '0'],
            '0 is not empty' => [0, false, 0],
            '1 is not empty' => [1, false, 1],
            'true is not empty' => [true, false, true],
        ];
    }
 
    public function ‪stdWrap_required(mixed $expect, bool $stop, mixed $content): void
    {
        ‪$subject = ‪$this->subject;
        ‪$subject->_set('stdWrapRecursionLevel', 1);
        ‪$subject->_set('stopRendering', [1 => false]);
        self::assertSame($expect, ‪$subject->stdWrap_required($content));
        self::assertSame($stop, ‪$subject->_get('stopRendering')[1]);
    }
 
    public function ‪stdWrap_round(): void
    {
        $content = ‪StringUtility::getUniqueId('content');
        $conf = [
            'round' => ‪StringUtility::getUniqueId('not used'),
            'round.' => [‪StringUtility::getUniqueId('round.')],
        ];
        $return = ‪StringUtility::getUniqueId('return');
        ‪$subject = $this->getMockBuilder(ContentObjectRenderer::class)
            ->onlyMethods(['round'])->getMock();
        ‪$subject
            ->expects(self::once())
            ->method('round')
            ->with($content, $conf['round.'])
            ->willReturn($return);
        self::assertSame($return, ‪$subject->stdWrap_round($content, $conf));
    }
 
    public function ‪stdWrap_setContentToCurrent(): void
    {
        $content = ‪StringUtility::getUniqueId('content');
        self::assertNotSame($content, $this->subject->getData('current'));
        self::assertSame(
            $content,
            $this->subject->stdWrap_setContentToCurrent($content)
        );
        self::assertSame($content, $this->subject->getData('current'));
    }
 
    public static function ‪stdWrap_setCurrentDataProvider(): array
    {
        return [
            'no conf' => [
                'content',
                [],
            ],
            'empty string' => [
                'content',
                ['setCurrent' => ''],
            ],
            'non-empty string' => [
                'content',
                ['setCurrent' => 'xxx'],
            ],
            'integer null' => [
                'content',
                ['setCurrent' => 0],
            ],
            'integer not null' => [
                'content',
                ['setCurrent' => 1],
            ],
            'boolean true' => [
                'content',
                ['setCurrent' => true],
            ],
            'boolean false' => [
                'content',
                ['setCurrent' => false],
            ],
        ];
    }
 
    public function ‪stdWrap_setCurrent(string $input, array $conf): void
    {
        if (isset($conf['setCurrent'])) {
            self::assertNotSame($conf['setCurrent'], $this->subject->getData('current'));
        }
        self::assertSame($input, $this->subject->stdWrap_setCurrent($input, $conf));
        if (isset($conf['setCurrent'])) {
            self::assertSame($conf['setCurrent'], $this->subject->getData('current'));
        }
    }
 
    public function ‪stdWrap_split(): void
    {
        $content = ‪StringUtility::getUniqueId('content');
        $conf = [
            'split' => ‪StringUtility::getUniqueId('not used'),
            'split.' => [‪StringUtility::getUniqueId('split.')],
        ];
        $return = ‪StringUtility::getUniqueId('return');
        ‪$subject = $this->getMockBuilder(ContentObjectRenderer::class)
            ->onlyMethods(['splitObj'])->getMock();
        ‪$subject
            ->expects(self::once())
            ->method('splitObj')
            ->with($content, $conf['split.'])
            ->willReturn($return);
        self::assertSame(
            $return,
            ‪$subject->stdWrap_split($content, $conf)
        );
    }
 
    public function ‪stdWrap_stdWrap(): void
    {
        $content = ‪StringUtility::getUniqueId('content');
        $conf = [
            'stdWrap' => ‪StringUtility::getUniqueId('not used'),
            'stdWrap.' => [‪StringUtility::getUniqueId('stdWrap.')],
        ];
        $return = ‪StringUtility::getUniqueId('return');
        ‪$subject = $this->getMockBuilder(ContentObjectRenderer::class)
            ->onlyMethods(['stdWrap'])->getMock();
        ‪$subject
            ->expects(self::once())
            ->method('stdWrap')
            ->with($content, $conf['stdWrap.'])
            ->willReturn($return);
        self::assertSame($return, ‪$subject->stdWrap_stdWrap($content, $conf));
    }
 
    public static function ‪stdWrap_stdWrapValueDataProvider(): array
    {
        return [
            'only key returns value' => [
                'ifNull',
                [
                    'ifNull' => '1',
                ],
                '',
                '1',
            ],
            'array without key returns empty string' => [
                'ifNull',
                [
                    'ifNull.' => '1',
                ],
                '',
                '',
            ],
            'array without key returns default' => [
                'ifNull',
                [
                    'ifNull.' => '1',
                ],
                'default',
                'default',
            ],
            'non existing key returns default' => [
                'ifNull',
                [
                    'noTrimWrap' => 'test',
                    'noTrimWrap.' => '1',
                ],
                'default',
                'default',
            ],
            'default value null is returned' => [
                'ifNull',
                [],
                null,
                null,
            ],
            'existing key and array returns stdWrap' => [
                'test',
                [
                    'test' => 'value',
                    'test.' => ['case' => 'upper'],
                ],
                'default',
                'VALUE',
            ],
            'the string "0" from stdWrap will be returned' => [
                'test',
                [
                    'test' => '',
                    'test.' => [
                        'wrap' => '|0',
                    ],
                ],
                '100',
                '0',
            ],
        ];
    }
 
    public function ‪stdWrap_stdWrapValue(
        string $key,
        array $configuration,
        ?string $defaultValue,
        ?string $expected
    ): void {
        $result = $this->subject->stdWrapValue($key, $configuration, $defaultValue);
        self::assertSame($expected, $result);
    }
 
    public static function ‪stdWrap_strPadDataProvider(): array
    {
        return [
            'pad string with default settings and length 10' => [
                'Alien     ',
                'Alien',
                [
                    'length' => '10',
                ],
            ],
            'pad string with default settings and length 10 and multibyte character' => [
                'Älien     ',
                'Älien',
                [
                    'length' => '10',
                ],
            ],
            'pad string with padWith -= and type left and length 10' => [
                '-=-=-Alien',
                'Alien',
                [
                    'length' => '10',
                    'padWith' => '-=',