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 Prophecy\Argument;
use Prophecy\PhpUnit\ProphecyTrait;
use Prophecy\Prophecy\ObjectProphecy;
use Psr\Container\ContainerInterface;
use Psr\Http\Message\ServerRequestInterface;
use Psr\Log\NullLogger;
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\SiteConfiguration;
use ‪TYPO3\CMS\Core\Context\Context;
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\ExpressionLanguage\ProviderConfigurationLoader;
use ‪TYPO3\CMS\Core\LinkHandling\LinkService;
use ‪TYPO3\CMS\Core\Log\Logger;
use TYPO3\CMS\Core\Package\PackageManager;
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\TimeTracker\TimeTracker;
use ‪TYPO3\CMS\Core\TypoScript\TemplateService;
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\ContentObjectGetImageResourceHookInterface;
use TYPO3\CMS\Frontend\ContentObject\ContentObjectRenderer;
use ‪TYPO3\CMS\Frontend\ContentObject\ContentObjectStdWrapHookInterface;
use ‪TYPO3\CMS\Frontend\ContentObject\Exception\ContentRenderingException;
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\Typolink\LinkResultInterface;
use TYPO3\TestingFramework\Core\AccessibleObjectInterface;
use TYPO3\TestingFramework\Core\Unit\UnitTestCase;
 
class ‪ContentObjectRendererTest extends UnitTestCase
{
    use ProphecyTrait;
    use ‪ContentObjectRendererTestTrait;
 
    protected ‪$resetSingletonInstances = true;
 
    protected MockObject ‪$subject;
 
    protected MockObject ‪$frontendControllerMock;
 
    protected ‪$templateServiceMock;
 
    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 ObjectProphecy ‪$cacheManager;
 
    protected ‪$backupEnvironment = true;
 
    protected function ‪setUp(): void
    {
        parent::setUp();
 
        $site = $this->createSiteWithLanguage([
            'base' => '/',
            'languageId' => 2,
            'locale' => 'en_UK',
            'typo3Language' => 'default',
        ]);
 
        ‪$GLOBALS['SIM_ACCESS_TIME'] = 1534278180;
        $packageManagerMock = $this->getMockBuilder(PackageManager::class)
            ->disableOriginalConstructor()
            ->getMock();
        $this->templateServiceMock =
            $this->getMockBuilder(TemplateService::class)
                ->setConstructorArgs([null, $packageManagerMock])
                ->addMethods(['linkData'])
                ->getMock();
        $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->tmpl = ‪$this->templateServiceMock;
        $this->frontendControllerMock->config = [];
        $this->frontendControllerMock->page = [];
        $this->frontendControllerMock->sys_page = $pageRepositoryMock;
        $this->frontendControllerMock->_set('language', $site->getLanguageById(2));
        ‪$GLOBALS['TSFE'] = ‪$this->frontendControllerMock;
 
        $this->cacheManager = $this->prophesize(CacheManager::class);
        GeneralUtility::setSingletonInstance(CacheManager::class, $this->cacheManager->reveal());
 
        $this->subject = $this->getAccessibleMock(
            ContentObjectRenderer::class,
            ['getResourceFactory', 'getEnvironmentVariable'],
            [$this->frontendControllerMock]
        );
 
        $logger = $this->prophesize(Logger::class);
        $this->subject->setLogger($logger->reveal());
        $request = $this->prophesize(ServerRequestInterface::class);
        $this->subject->setRequest($request->reveal());
        $this->subject->setContentObjectClassMap($this->contentObjectMap);
        $this->subject->start([], 'tt_content');
    }
 
    // Utility functions
 
    protected function ‪getFrontendController(): ‪TypoScriptFrontendController
    {
        return ‪$GLOBALS['TSFE'];
    }
 
    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
    {
        $cacheManagerProphecy = $this->prophesize(CacheManager::class);
        $cacheProphecy = $this->prophesize(CacheFrontendInterface::class);
        $cacheManagerProphecy->getCache('imagesizes')->willReturn($cacheProphecy->reveal());
        $cacheProphecy->get(Argument::cetera())->willReturn(false);
        $cacheProphecy->set(Argument::cetera(), null)->willReturn(false);
        GeneralUtility::setSingletonInstance(CacheManager::class, $cacheManagerProphecy->reveal());
 
        $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 ‪canRegisterAContentObjectClassForATypoScriptName(): void
    {
        $className = TextContentObject::class;
        $contentObjectName = 'TEST_TEXT';
        $this->subject->registerContentObjectClass(
            $className,
            $contentObjectName
        );
        $object = $this->subject->getContentObject($contentObjectName);
        self::assertInstanceOf($className, $object);
    }
 
    public function ‪canSetTheContentObjectClassMapAndGetARegisteredContentObject(): void
    {
        $className = TextContentObject::class;
        $contentObjectName = 'TEST_TEXT';
        $classMap = [$contentObjectName => $className];
        $this->subject->setContentObjectClassMap($classMap);
        $object = $this->subject->getContentObject($contentObjectName);
        self::assertInstanceOf($className, $object);
    }
 
    public function ‪canNotAccessInternalContentObjectMapByReference(): void
    {
        $className = TextContentObject::class;
        $contentObjectName = 'TEST_TEXT';
        $classMap = [];
        $this->subject->setContentObjectClassMap($classMap);
        $classMap[$contentObjectName] = $className;
        $object = $this->subject->getContentObject($contentObjectName);
        self::assertNull($object);
    }
 
    public function ‪willReturnNullForUnregisteredObject(): void
    {
        $object = $this->subject->getContentObject('FOO');
        self::assertNull($object);
    }
 
    public function ‪willThrowAnExceptionForARegisteredNonContentObject(): void
    {
        $this->expectException(ContentRenderingException::class);
        $this->subject->registerContentObjectClass(
            \stdClass::class,
            'STDCLASS'
        );
        $this->subject->getContentObject('STDCLASS');
    }
 
    public function ‪registersAllDefaultContentObjectsDataProvider(): array
    {
        $dataProvider = [];
        foreach ($this->contentObjectMap as $name => $className) {
            $dataProvider[] = [$name, $className];
        }
        return $dataProvider;
    }
 
    public function ‪registersAllDefaultContentObjects(
        string $objectName,
        string $className
    ): void {
        self::assertTrue(
            is_subclass_of($className, AbstractContentObject::class)
        );
        if ($objectName === 'FLUIDTEMPLATE') {
            GeneralUtility::addInstance(ContentDataProcessor::class, new ContentDataProcessor($this->prophesize(ContainerInterface::class)->reveal()));
        }
        $object = $this->subject->getContentObject($objectName);
        self::assertInstanceOf($className, $object);
    }
 
    // Tests concerning getQueryArguments()
 
    public function ‪getQueryArgumentsExcludesParameters(): void
    {
        $_GET = [
            'key1' => 'value1',
            'key2' => 'value2',
            'key3' => [
                'key31' => 'value31',
                'key32' => [
                    'key321' => 'value321',
                    'key322' => 'value322',
                ],
            ],
        ];
        $getQueryArgumentsConfiguration = [];
        $getQueryArgumentsConfiguration['exclude'] = [];
        $getQueryArgumentsConfiguration['exclude'][] = 'key1';
        $getQueryArgumentsConfiguration['exclude'][] = 'key3[key31]';
        $getQueryArgumentsConfiguration['exclude'][] = 'key3[key32][key321]';
        $getQueryArgumentsConfiguration['exclude'] = implode(',', $getQueryArgumentsConfiguration['exclude']);
        $expectedResult = $this->‪rawUrlEncodeSquareBracketsInUrl('&key2=value2&key3[key32][key322]=value322');
        $actualResult = $this->subject->getQueryArguments($getQueryArgumentsConfiguration);
        self::assertEquals($expectedResult, $actualResult);
    }
 
    private function ‪rawUrlEncodeSquareBracketsInUrl(string $string): string
    {
        return str_replace(['[', ']'], ['%5B', '%5D'], $string);
    }
 
    // Tests concerning crop
 
    public function ‪cropIsMultibyteSafe(): void
    {
        self::assertEquals('бла', $this->subject->crop('бла', '3|...'));
    }
 
 
    // Tests concerning cropHTML
 
    public 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>foobaz',
                '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 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, $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 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, $content, array $conf): void
    {
        self::assertSame(
            $expects,
            $this->subject->numberFormat($content, $conf)
        );
    }
 
    public 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 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 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 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']);
        ‪$subject->expects(self::exactly(($ifEmptyShouldBeCalled ? 1 : 0)))
            ->method('stdWrap_ifEmpty');
 
        ‪$subject->stdWrap($content, $conf);
    }
 
    public 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));
    }
 
    // Tests concerning getData()
 
    public 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
    {
        $_GET = [
            'onlyInGet' => 'GetValue',
            'inGetAndPost' => 'ValueInGet',
        ];
        $_POST = [
            'onlyInPost' => 'PostValue',
            'inGetAndPost' => 'ValueInPost',
        ];
        self::assertEquals($expectedValue, $this->subject->getData('gp:' . $key));
    }
 
    public function ‪getDataWithTypeTsfe(): void
    {
        self::assertEquals(‪$GLOBALS['TSFE']->metaCharset, $this->subject->getData('tsfe:metaCharset'));
    }
 
    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 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']->tmpl->rootLine = $rootline;
        self::assertEquals(2, $this->subject->getData('level'));
    }
 
    public function ‪getDataWithTypeGlobal(): void
    {
        self::assertEquals(‪$GLOBALS['TSFE']->metaCharset, $this->subject->getData('global:TSFE|metaCharset'));
    }
 
    public function ‪getDataWithTypeLeveltitle(): void
    {
        $rootline = [
            0 => ['uid' => 1, 'title' => 'title1'],
            1 => ['uid' => 2, 'title' => 'title2'],
            2 => ['uid' => 3, 'title' => ''],
        ];
 
        ‪$GLOBALS['TSFE']->tmpl->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']->tmpl->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']->tmpl->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']->tmpl->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']->tmpl->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 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');
        ‪$GLOBALS['TSFE']->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'
        ));
        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'));
    }
 
    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']->tmpl->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 ‪aTagParamsHasLeadingSpaceIfNotEmpty(): void
    {
        $aTagParams = $this->subject->getATagParams(['ATagParams' => 'data-test="testdata"']);
        self::assertEquals(' data-test="testdata"', $aTagParams);
    }
 
    public function ‪aTagParamsHaveSpaceBetweenLocalAndGlobalParams(): void
    {
        ‪$GLOBALS['TSFE']->config['config']['ATagParams'] = 'data-global="dataglobal"';
        $aTagParams = $this->subject->getATagParams(['ATagParams' => 'data-test="testdata"']);
        self::assertEquals(' data-global="dataglobal" data-test="testdata"', $aTagParams);
    }
 
    public function ‪aTagParamsHasNoLeadingSpaceIfEmpty(): void
    {
        // make sure global ATagParams are empty
        ‪$GLOBALS['TSFE']->config['config']['ATagParams'] = '';
        $aTagParams = $this->subject->getATagParams(['ATagParams' => '']);
        self::assertEquals('', $aTagParams);
    }
 
    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::getBackendPath() . '/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)
    {
        $contentObjectFixture = $this->getMockBuilder(AbstractContentObject::class)
            ->setConstructorArgs([$this->subject])
            ->getMock();
        $contentObjectFixture->expects(self::once())
            ->method('render')
            ->willReturnCallback(static function () {
                throw new \LogicException('Exception during rendering', 1414513947);
            });
        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 ‪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>',
            ],
            '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>',
            ],
            '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>',
            ],
            '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>?',
            ],
            '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>.',
            ],
            '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>',
            ],
            '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>',
            ],
            '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>',
            ],
            '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>',
            ],
            '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>',
            ],
            '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>',
            ],
            '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>',
            ],
            '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>',
            ],
            '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>',
            ],
            'https link' => [
                'Some text with a link https://example.com',
                [
                ],
                'Some text with a link <a href="https://example.com">example.com</a>',
            ],
            '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>',
            ],
            '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>',
            ],
        ];
    }
 
    public function ‪httpMakelinksReturnsLink(string $data, array $configuration, string $expectedResult): void
    {
        self::assertSame($expectedResult, $this->subject->http_makelinks($data, $configuration));
    }
 
    public 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->http_makelinks($data, $configuration));
    }
 
    public 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>',
            ],
            '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>',
            ],
            '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>',
            ],
            '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>?',
            ],
            '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>.',
            ],
            '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>.',
            ],
            '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>.',
            ],
            '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>.',
            ],
        ];
    }
 
    public function ‪mailtoMakelinksReturnsMailToLink(string $data, array $configuration, string $expectedResult): void
    {
        self::assertSame($expectedResult, $this->subject->mailto_makelinks($data, $configuration));
    }
 
    public function ‪mailtoMakelinksReturnsNoMailToLink(): void
    {
        self::assertSame('mailto:', $this->subject->mailto_makelinks('mailto:', []));
    }
 
    public 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" title="Open new window" target="_blank" class="url-class" rel="noreferrer">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" title="Open new window" target="someTarget" class="url-class" rel="noreferrer">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" title="Open new window" target="_blank" class="url-class" rel="noreferrer">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" title="Open new window" target="someTarget" class="url-class" rel="noreferrer">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 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" title="Write an email" class="email-class">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" class="different-url-class" rel="noreferrer">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
    {
        $packageManagerMock = $this->getMockBuilder(PackageManager::class)
            ->disableOriginalConstructor()
            ->getMock();
        $templateServiceObjectMock = $this->getMockBuilder(TemplateService::class)
            ->setConstructorArgs([null, $packageManagerMock])
            ->addMethods(['dummy'])
            ->getMock();
        $templateServiceObjectMock->setup = [
            'lib.' => [
                'parseFunc.' => $this->‪getLibParseFunc(),
            ],
        ];
        $typoScriptFrontendControllerMockObject = $this->createMock(TypoScriptFrontendController::class);
        $typoScriptFrontendControllerMockObject->config = [
            'config' => [],
        ];
        $typoScriptFrontendControllerMockObject->tmpl = $templateServiceObjectMock;
        ‪$GLOBALS['TSFE'] = $typoScriptFrontendControllerMockObject;
 
        $this->cacheManager->getCache('runtime')->willReturn(new NullFrontend('dummy'));
        $this->cacheManager->getCache('core')->willReturn(new NullFrontend('runtime'));
 
        GeneralUtility::setSingletonInstance(
            SiteConfiguration::class,
            new SiteConfiguration(‪Environment::getConfigPath() . '/sites', new NullFrontend('dummy'))
        );
 
        $this->subject->_set('typoScriptFrontendController', $typoScriptFrontendControllerMockObject);
 
        self::assertEquals($expectedResult, $this->subject->typoLink($linkText, $configuration));
    }
 
    public function ‪typoLinkEncodesMailAddressForSpamProtection(
        array $settings,
        string $linkText,
        string $mailAddress,
        string $expected
    ): void {
        $this->‪getFrontendController()->spamProtectEmailAddresses = $settings['spamProtectEmailAddresses'];
        $this->‪getFrontendController()->config['config'] = $settings;
        $typoScript = ['parameter' => $mailAddress];
 
        self::assertEquals($expected, $this->subject->typoLink($linkText, $typoScript));
    }
 
    public function ‪typoLinkEncodesMailAddressForSpamProtectionDataProvider(): array
    {
        return [
            'plain mail without mailto scheme' => [
                [
                    'spamProtectEmailAddresses' => '',
                    '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' => '',
                    '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',
                // @todo no substitution, due to `?subject=` extension (which cannot be found in the link-text)
                '<a href="#" data-mailto-token="ocknvq,uqog0dqfaBvguv0varq50qti?uwdlgev=hqq%42dct" data-mailto-vector="2">some.body@test.typo3.org</a>',
            ],
            'entity substitution with at and dot substitution' => [
                [
                    'spamProtectEmailAddresses' => 'ascii',
                    'spamProtectEmailAddresses_atSubst' => '',
                    'spamProtectEmailAddresses_lastDotSubst' => '',
                ],
                'some.body@test.typo3.org',
                'mailto:some.body@test.typo3.org',
                '<a href="&#109;&#97;&#105;&#108;&#116;&#111;&#58;&#115;&#111;&#109;&#101;&#46;&#98;&#111;&#100;&#121;&#64;&#116;&#101;&#115;&#116;&#46;&#116;&#121;&#112;&#111;&#51;&#46;&#111;&#114;&#103;">some.body(at)test.typo3.org</a>',
            ],
            'entity substitution with at and dot substitution with at and dot substitution' => [
                [
                    'spamProtectEmailAddresses' => 'ascii',
                    'spamProtectEmailAddresses_atSubst' => '(at)',
                    'spamProtectEmailAddresses_lastDotSubst' => '(dot)',
                ],
                'some.body@test.typo3.org',
                'mailto:some.body@test.typo3.org',
                '<a href="&#109;&#97;&#105;&#108;&#116;&#111;&#58;&#115;&#111;&#109;&#101;&#46;&#98;&#111;&#100;&#121;&#64;&#116;&#101;&#115;&#116;&#46;&#116;&#121;&#112;&#111;&#51;&#46;&#111;&#114;&#103;">some.body(at)test.typo3(dot)org</a>',
            ],
        ];
    }
 
    public 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" title="Title of the file" target="_blank" class="file-class">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" title="Title of the file" target="_blank">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" title="Title of the file" target="_blank" class="file-class">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" title="Title of the file" target="_blank" class="file-class">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" title="foo-bar" target="_blank" class="file-class">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" title="Title of the file" target="_blank">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" title="Title of the file" target="_blank" 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
    {
        $packageManagerMock = $this->getMockBuilder(PackageManager::class)
            ->disableOriginalConstructor()
            ->getMock();
        $templateServiceObjectMock = $this->getMockBuilder(TemplateService::class)
            ->setConstructorArgs([null, $packageManagerMock])
            ->addMethods(['dummy'])
            ->getMock();
        $templateServiceObjectMock->setup = [
            'lib.' => [
                'parseFunc.' => $this->‪getLibParseFunc(),
            ],
        ];
        $typoScriptFrontendControllerMockObject = $this->createMock(TypoScriptFrontendController::class);
        $typoScriptFrontendControllerMockObject->config = [
            'config' => [],
        ];
        $typoScriptFrontendControllerMockObject->tmpl = $templateServiceObjectMock;
        ‪$GLOBALS['TSFE'] = $typoScriptFrontendControllerMockObject;
 
        $resourceFactory = $this->prophesize(ResourceFactory::class);
        GeneralUtility::setSingletonInstance(ResourceFactory::class, $resourceFactory->reveal());
 
        $this->subject->_set('typoScriptFrontendController', $typoScriptFrontendControllerMockObject);
 
        self::assertEquals($expectedResult, $this->subject->typoLink($linkText, $configuration));
    }
 
    public 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" title="Title of the file" target="_blank" class="file-class">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" title="Title of the file" target="_blank" class="file-class">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" title="Title of the file" target="_blank" class="file-class">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" title="Title of the file" target="_blank" class="file-class">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" title="Title of the file" target="_blank" class="file-class">My file</a>',
            ],
        ];
    }
 
    public function ‪typolinkReturnsCorrectLinksForFilesWithAbsRefPrefix(
        string $linkText,
        array $configuration,
        string $absRefPrefix,
        string $expectedResult
    ): void {
        $packageManagerMock = $this->getMockBuilder(PackageManager::class)
            ->disableOriginalConstructor()
            ->getMock();
        $templateServiceObjectMock = $this->getMockBuilder(TemplateService::class)
            ->setConstructorArgs([null, $packageManagerMock])
            ->addMethods(['dummy'])
            ->getMock();
        $templateServiceObjectMock->setup = [
            'lib.' => [
                'parseFunc.' => $this->‪getLibParseFunc(),
            ],
        ];
        $resourceFactory = $this->prophesize(ResourceFactory::class);
        GeneralUtility::setSingletonInstance(ResourceFactory::class, $resourceFactory->reveal());
 
        $typoScriptFrontendControllerMockObject = $this->createMock(TypoScriptFrontendController::class);
        $typoScriptFrontendControllerMockObject->config = [
            'config' => [],
        ];
        $typoScriptFrontendControllerMockObject->tmpl = $templateServiceObjectMock;
        ‪$GLOBALS['TSFE'] = $typoScriptFrontendControllerMockObject;
        ‪$GLOBALS['TSFE']->absRefPrefix = $absRefPrefix;
        $this->subject->_set('typoScriptFrontendController', $typoScriptFrontendControllerMockObject);
 
        self::assertEquals($expectedResult, $this->subject->typoLink($linkText, $configuration));
    }
 
    public function ‪typolinkOpensInNewWindow(): void
    {
        $this->cacheManager->getCache('runtime')->willReturn(new NullFrontend('runtime'));
        $this->cacheManager->getCache('core')->willReturn(new NullFrontend('runtime'));
        GeneralUtility::setSingletonInstance(
            SiteConfiguration::class,
            new SiteConfiguration(‪Environment::getConfigPath() . '/sites', new NullFrontend('dummy'))
        );
        $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));
        $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));
 
        $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));
 
        ‪$GLOBALS['TSFE']->xhtmlDoctype = 'xhtml_strict';
        $linkText = 'Nice Text with default window name';
        $configuration = [
            'parameter' => 'https://example.com 13x84',
        ];
        $expectedResult = '<a href="https://example.com" 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));
    }
 
    public function ‪typoLinkReturnsOnlyLinkTextIfNoLinkResolvingIsPossible(): void
    {
        $linkService = $this->prophesize(LinkService::class);
        GeneralUtility::setSingletonInstance(LinkService::class, $linkService->reveal());
        $linkService->resolve('foo')->willThrow(InvalidPathException::class);
 
        self::assertSame('foo', $this->subject->typoLink('foo', ['parameter' => 'foo']));
    }
 
    public function ‪typoLinkLogsErrorIfNoLinkResolvingIsPossible(): void
    {
        $linkService = $this->prophesize(LinkService::class);
        GeneralUtility::setSingletonInstance(LinkService::class, $linkService->reveal());
        $linkService->resolve('foo')->willThrow(InvalidPathException::class);
 
        $logger = $this->prophesize(Logger::class);
        $logger->warning('The link could not be generated', Argument::any())->shouldBeCalled();
        $this->subject->setLogger($logger->reveal());
        $this->subject->typoLink('foo', ['parameter' => 'foo']);
    }
 
    public function ‪typolinkLinkResult(): void
    {
        $packageManagerMock = $this->getMockBuilder(PackageManager::class)
            ->disableOriginalConstructor()
            ->getMock();
        $templateServiceObjectMock = $this->getMockBuilder(TemplateService::class)
            ->setConstructorArgs([null, $packageManagerMock])
            ->addMethods(['dummy'])
            ->getMock();
        $templateServiceObjectMock->setup = [
            'lib.' => [
                'parseFunc.' => $this->‪getLibParseFunc(),
            ],
        ];
        $typoScriptFrontendControllerMockObject = $this->createMock(TypoScriptFrontendController::class);
        $typoScriptFrontendControllerMockObject->config = [
            'config' => [],
        ];
        $typoScriptFrontendControllerMockObject->tmpl = $templateServiceObjectMock;
        ‪$GLOBALS['TSFE'] = $typoScriptFrontendControllerMockObject;
 
        $resourceFactory = $this->prophesize(ResourceFactory::class);
        GeneralUtility::setSingletonInstance(ResourceFactory::class, $resourceFactory->reveal());
 
        $this->cacheManager->getCache('runtime')->willReturn(new NullFrontend('dummy'));
        $this->cacheManager->getCache('core')->willReturn(new NullFrontend('runtime'));
 
        GeneralUtility::setSingletonInstance(
            SiteConfiguration::class,
            new SiteConfiguration(‪Environment::getConfigPath() . '/sites', new NullFrontend('dummy'))
        );
 
        $this->subject->_set('typoScriptFrontendController', $typoScriptFrontendControllerMockObject);
 
        $linkResult = $this->subject->typoLink('', [
            'parameter' => 'https://example.tld',
            'returnLast' => 'result', ]);
 
        self::assertTrue(is_a($linkResult, LinkResultInterface::class, true));
        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);
    }
 
    public function ‪typoLinkProperlyEncodesLinkResult(string $linkText, array $configuration, string $expectedResult): void
    {
        $packageManagerMock = $this->getMockBuilder(PackageManager::class)
            ->disableOriginalConstructor()
            ->getMock();
        $templateServiceObjectMock = $this->getMockBuilder(TemplateService::class)
            ->setConstructorArgs([null, $packageManagerMock])
            ->addMethods(['dummy'])
            ->getMock();
        $templateServiceObjectMock->setup = [
            'lib.' => [
                'parseFunc.' => $this->‪getLibParseFunc(),
            ],
        ];
        $typoScriptFrontendControllerMockObject = $this->createMock(TypoScriptFrontendController::class);
        $typoScriptFrontendControllerMockObject->config = [
            'config' => [],
        ];
        $typoScriptFrontendControllerMockObject->tmpl = $templateServiceObjectMock;
        ‪$GLOBALS['TSFE'] = $typoScriptFrontendControllerMockObject;
 
        $resourceFactory = $this->prophesize(ResourceFactory::class);
        GeneralUtility::setSingletonInstance(ResourceFactory::class, $resourceFactory->reveal());
 
        $this->cacheManager->getCache('runtime')->willReturn(new NullFrontend('dummy'));
        $this->cacheManager->getCache('core')->willReturn(new NullFrontend('runtime'));
 
        GeneralUtility::setSingletonInstance(
            SiteConfiguration::class,
            new SiteConfiguration(‪Environment::getConfigPath() . '/sites', new NullFrontend('dummy'))
        );
 
        $this->subject->_set('typoScriptFrontendController', $typoScriptFrontendControllerMockObject);
 
        self::assertEquals($expectedResult, (string)$this->subject->typoLink($linkText, $configuration));
    }
 
    public 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 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 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($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 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($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 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 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(83, $callable);
    }
 
    public function ‪notAllStdWrapProcessorsAreCallableWithEmptyConfiguration(): void
    {
        $timeTrackerProphecy = $this->prophesize(TimeTracker::class);
        GeneralUtility::setSingletonInstance(TimeTracker::class, $timeTrackerProphecy->reveal());
 
        // `parseFunc` issues deprecation in case `htmlSanitize` is not given
        $expectExceptions = ['numRows', 'parseFunc'];
        $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(83, $count);
    }
 
    /***************************************************************************
     * End general tests for stdWrap_
     ***************************************************************************/
 
    /***************************************************************************
     * Tests for stdWrap_ in alphabetical order (all uppercase before lowercase)
     ***************************************************************************/
 
    public 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 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 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 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
    {
        ‪$GLOBALS['TSFE']->xhtmlDoctype = $xhtmlDoctype;
        self::assertSame($expected, $this->subject->stdWrap_br($input));
    }
 
    public 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 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 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 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,
        $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 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,
        $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)
        );
    }
 
    public 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 function ‪stdWrap_dataDataProvider(): array
    {
        $data = [‪StringUtility::getUniqueId('data')];
        $alt = [‪StringUtility::getUniqueId('alternativeData')];
        return [
            'default' => [$data, $data, ''],
            'alt is array' => [$alt, $data, $alt],
            'alt is empty array' => [[], $data, []],
            'alt null' => [$data, $data, null],
            'alt string' => [$data, $data, 'xxx'],
            'alt int' => [$data, $data, 1],
            'alt bool' => [$data, $data, true],
        ];
    }
 
    public function ‪stdWrap_data(array $expect, array $data, $alt): void
    {
        $conf = ['data' => ‪StringUtility::getUniqueId('conf.data')];
        $return = ‪StringUtility::getUniqueId('return');
        ‪$subject = $this->getAccessibleMock(
            ContentObjectRenderer::class,
            ['getData']
        );
        ‪$subject->_set('data', $data);
        ‪$subject->_set('alternativeData', $alt);
        ‪$subject
            ->expects(self::once())
            ->method('getData')
            ->with($conf['data'], $expect)
            ->willReturn($return);
        self::assertSame($return, ‪$subject->stdWrap_data('discard', $conf));
        self::assertSame('', ‪$subject->_get('alternativeData'));
    }
 
    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 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, $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];
        // Without alternative data only data is returned.
        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);
        // By adding alternative data both are returned together.
        $this->subject->alternativeData = [$key => $altValue];
        ob_start();
        $this->subject->stdWrap_debugData($content);
        $out = ob_get_clean();
        self::assertStringNotContainsString('$cObj->alternativeData', $out);
        self::assertStringContainsString($value, $out);
        self::assertStringContainsString($altValue, $out);
    }
 
    public 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, $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 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 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 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 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 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 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 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 function ‪stdWrap_ifDataProvider(): array
    {
        $content = ‪StringUtility::getUniqueId('content');
        $conf = ['if.' => [‪StringUtility::getUniqueId('if.')]];
        return [
            // evals to true
            'empty config' => [
                $content,
                false,
                $content,
                [],
                0,
                null,
            ],
            'if. is empty array' => [
                $content,
                false,
                $content,
                ['if.' => []],
                0,
                null,
            ],
            'if. is null' => [
                $content,
                false,
                $content,
                ['if.' => null],
                0,
                null,
            ],
            'if. is false' => [
                $content,
                false,
                $content,
                ['if.' => false],
                0,
                null,
            ],
            'if. is 0' => [
                $content,
                false,
                $content,
                ['if.' => false],
                0,
                null,
            ],
            'if. is "0"' => [
                $content,
                false,
                $content,
                ['if.' => '0'],
                0,
                null,
            ],
            '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 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']],
        ];
    }
 
    public function ‪checkIf(bool $expect, array $conf): void
    {
        ‪$subject = $this->getAccessibleMock(
            ContentObjectRenderer::class,
            ['stdWrap']
        );
        self::assertSame($expect, ‪$subject->checkIf($conf));
    }
 
    public 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($expect, $content, array $conf): void
    {
        $result = $this->subject->stdWrap_ifBlank($content, $conf);
        self::assertSame($expect, $result);
    }
 
    public 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($expect, $content, array $conf): void
    {
        $result = $this->subject->stdWrap_ifEmpty($content, $conf);
        self::assertSame($expect, $result);
    }
 
    public 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($expect, $content, array $conf): void
    {
        $result = $this->subject->stdWrap_ifNull($content, $conf);
        self::assertSame($expect, $result);
    }
 
    public 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 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 function ‪stdWrap_insertDataProvider(): array
    {
        return [
            'empty' => ['', ''],
            'notFoundData' => ['any=1', 'any{$string}=1'],
            'queryParameter' => ['any{#string}=1', 'any{#string}=1'],
        ];
    }
 
    public function ‪stdWrap_insertDataAndInputExamples($expect, string $content): void
    {
        self::assertSame($expect, $this->subject->stdWrap_insertData($content));
    }
 
    public 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, $content): void
    {
        self::assertSame($expect, $this->subject->stdWrap_intval($content));
    }
 
    public 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 function ‪stdWrap_langDataProvider(): array
    {
        return [
            'empty conf' => [
                'original',
                'original',
                [],
                'de',
            ],
            'translation de' => [
                'Übersetzung',
                'original',
                [
                    'lang.' => [
                        'de' => 'Übersetzung',
                        'it' => 'traduzione',
                    ],
                ],
                'de',
            ],
            'translation it' => [
                'traduzione',
                'original',
                [
                    'lang.' => [
                        'de' => 'Übersetzung',
                        'it' => 'traduzione',
                    ],
                ],
                'it',
            ],
            'no translation' => [
                'original',
                'original',
                [
                    'lang.' => [
                        'de' => 'Übersetzung',
                        'it' => 'traduzione',
                    ],
                ],
                '',
            ],
            'missing label' => [
                'original',
                'original',
                [
                    'lang.' => [
                        'de' => 'Übersetzung',
                        'it' => 'traduzione',
                    ],
                ],
                'fr',
            ],
        ];
    }
 
    public function ‪stdWrap_langViaSiteLanguage(string $expected, string $input, array $conf, string $language): void
    {
        $site = $this->createSiteWithLanguage([
            'base' => '/',
            'languageId' => 2,
            'locale' => 'en_UK',
            'typo3Language' => $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 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 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 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($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 = [];
        ‪$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 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,
        $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 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($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 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 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($expect, bool $stop, $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 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 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 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' => '-=',
                    'type' => 'left',
                ],
            ],
            'pad string with padWith äö and type left and length 10 and multibyte characters' => [
                'äöäöäÄlien',
                'Älien',
                [
                    'length' => '10',
                    'padWith' => 'äö',
                    'type' => 'left',
                ],
            ],
            'pad string with padWith _ and type both and length 10' => [
                '__Alien___',
                'Alien',
                [
                    'length' => '10',
                    'padWith' => '_',
                    'type' => 'both',
                ],
            ],
            'pad string with padWith 0 and type both and length 10' => [
                '00Alien000',
                'Alien',
                [
                    'length' => '10',
                    'padWith' => '0',
                    'type' => 'both',
                ],
            ],
            'pad string with padWith ___ and type both and length 6' => [
                'Alien_',
                'Alien',
                [
                    'length' => '6',
                    'padWith' => '___',
                    'type' => 'both',
                ],
            ],
            'pad string with padWith _ and type both and length 12, using stdWrap for length' => [
                '___Alien____',
                'Alien',
                [
                    'length' => '1',
                    'length.' => [
                        'wrap' => '|2',
                    ],
                    'padWith' => '_',
                    'type' => 'both',
                ],
            ],
            'pad string with padWith _ and type both and length 12, using stdWrap for padWidth' => [
                '-_=Alien-_=-',
                'Alien',
                [
                    'length' => '12',
                    'padWith' => '_',
                    'padWith.' => [
                        'wrap' => '-|=',
                    ],
                    'type' => 'both',
                ],
            ],
            'pad string with padWith _ and type both and length 12, using stdWrap for type' => [
                '_______Alien',
                'Alien',
                [
                    'length' => '12',
                    'padWith' => '_',
                    'type' => 'both',
                    // make type become "left"
                    'type.' => [
                        'substring' => '2,1',
                        'wrap' => 'lef|',
                    ],
                ],
            ],
        ];
    }
 
    public function ‪stdWrap_strPad(string $expect, string $content, array $conf): void
    {
        $conf = ['strPad.' => $conf];
        $result = $this->subject->stdWrap_strPad($content, $conf);
        self::assertSame($expect, $result);
    }
 
    public function ‪stdWrap_strftimeDataProvider(): array
    {
        // Fictive execution time is 2012-09-01 12:00 in UTC/GMT.
        $now = 1346500800;
        return [
            'given timestamp' => [
                '01-09-2012',
                $now,
                ['strftime' => '%d-%m-%Y'],
                $now,
            ],
            'empty string' => [
                '01-09-2012',
                '',
                ['strftime' => '%d-%m-%Y'],
                $now,
            ],
            'testing null' => [
                '01-09-2012',
                null,
                ['strftime' => '%d-%m-%Y'],
                $now,
            ],
        ];
    }
 
    public function ‪stdWrap_strftime(string $expect, $content, array $conf, int $now): void
    {
        // Save current timezone and set to UTC to make the system under test
        // behave the same in all server timezone settings
        $timezoneBackup = date_default_timezone_get();
        date_default_timezone_set('UTC');
 
        ‪$GLOBALS['EXEC_TIME'] = $now;
        $result = $this->subject->stdWrap_strftime($content, $conf);
 
        // Reset timezone
        date_default_timezone_set($timezoneBackup);
 
        self::assertSame($expect, $result);
    }
 
    public function ‪stdWrap_stripHtml(): void
    {
        $content = '<html><p>Hello <span class="inline">inline tag<span>!</p><p>Hello!</p></html>';
        $expected = 'Hello inline tag!Hello!';
        self::assertSame($expected, $this->subject->stdWrap_stripHtml($content));
    }
 
    public function ‪stdWrap_strtotimeDataProvider(): array
    {
        return [
            'date from content' => [
                1417651200,
                '2014-12-04',
                ['strtotime' => '1'],
            ],
            'manipulation of date from content' => [
                1417996800,
                '2014-12-04',
                ['strtotime' => '+ 2 weekdays'],
            ],
            'date from configuration' => [
                1417651200,
                '',
                ['strtotime' => '2014-12-04'],
            ],
            'manipulation of date from configuration' => [
                1417996800,
                '',
                ['strtotime' => '2014-12-04 + 2 weekdays'],
            ],
            'empty input' => [
                false,
                '',
                ['strtotime' => '1'],
            ],
            'date from content and configuration' => [
                false,
                '2014-12-04',
                ['strtotime' => '2014-12-05'],
            ],
        ];
    }
 
    public function ‪stdWrap_strtotime($expect, string $content, array $conf): void
    {
        // Set exec_time to a hard timestamp
        ‪$GLOBALS['EXEC_TIME'] = 1417392000;
        // Save current timezone and set to UTC to make the system under test
        // behave the same in all server timezone settings
        $timezoneBackup = date_default_timezone_get();
        date_default_timezone_set('UTC');
 
        $result = $this->subject->stdWrap_strtotime($content, $conf);
 
        // Reset timezone
        date_default_timezone_set($timezoneBackup);
 
        self::assertEquals($expect, $result);
    }
 
    public function ‪stdWrap_substring(): void
    {
        $content = ‪StringUtility::getUniqueId('content');
        $conf = [
            'substring' => ‪StringUtility::getUniqueId('substring'),
            'substring.' => ‪StringUtility::getUniqueId('not used'),
        ];
        $return = ‪StringUtility::getUniqueId('return');
        ‪$subject = $this->getMockBuilder(ContentObjectRenderer::class)
            ->onlyMethods(['substring'])->getMock();
        ‪$subject
            ->expects(self::once())
            ->method('substring')
            ->with($content, $conf['substring'])
            ->willReturn($return);
        self::assertSame(
            $return,
            ‪$subject->stdWrap_substring($content, $conf)
        );
    }
 
    public function ‪stdWrap_trimDataProvider(): array
    {
        return [
            // string not trimmed
            'empty string' => ['', ''],
            'string without whitespace' => ['xxx', 'xxx'],
            'string with whitespace inside' => [
                'xx ' . "\t" . ' xx',
                'xx ' . "\t" . ' xx',
            ],
            'string with newlines inside' => [
                'xx ' . PHP_EOL . ' xx',
                'xx ' . PHP_EOL . ' xx',
            ],
            // string trimmed
            'blanks around' => ['xxx', '  xxx  '],
            'tabs around' => ['xxx', "\t" . 'xxx' . "\t"],
            'newlines around' => ['xxx', PHP_EOL . 'xxx' . PHP_EOL],
            'mixed case' => ['xxx', "\t" . ' xxx ' . PHP_EOL],
            // non strings
            'null' => ['', null],
            'false' => ['', false],
            'true' => ['1', true],
            'zero' => ['0', 0],
            'one' => ['1', 1],
            '-1' => ['-1', -1],
            '0.0' => ['0', 0.0],
            '1.0' => ['1', 1.0],
            '-1.0' => ['-1', -1.0],
            '1.1' => ['1.1', 1.1],
        ];
    }
 
    public function ‪stdWrap_trim(string $expect, $content): void
    {
        $result = $this->subject->stdWrap_trim($content);
        self::assertSame($expect, $result);
    }
 
    public function ‪stdWrap_typolink(): void
    {
        $content = ‪StringUtility::getUniqueId('content');
        $conf = [
            'typolink' => ‪StringUtility::getUniqueId('not used'),
            'typolink.' => [‪StringUtility::getUniqueId('typolink.')],
        ];
        $return = ‪StringUtility::getUniqueId('return');
        ‪$subject = $this->getMockBuilder(ContentObjectRenderer::class)
            ->onlyMethods(['typolink'])->getMock();
        ‪$subject
            ->expects(self::once())
            ->method('typolink')
            ->with($content, $conf['typolink.'])
            ->willReturn($return);
        self::assertSame($return, ‪$subject->stdWrap_typolink($content, $conf));
    }
 
    public function ‪stdWrap_wrapDataProvider(): array
    {
        return [
            'no conf' => [
                'XXX',
                'XXX',
                [],
            ],
            'simple' => [
                '<wrapper>XXX</wrapper>',
                'XXX',
                ['wrap' => '<wrapper>|</wrapper>'],
            ],
            'trims whitespace' => [
                '<wrapper>XXX</wrapper>',
                'XXX',
                ['wrap' => '<wrapper>' . "\t" . ' | ' . "\t" . '</wrapper>'],
            ],
            'missing pipe puts wrap before' => [
                '<pre>XXX',
                'XXX',
                [
                    'wrap' => '<pre>',
                ],
            ],
            'split char change' => [
                '<wrapper>XXX</wrapper>',
                'XXX',
                [
                    'wrap' => '<wrapper> # </wrapper>',
                    'wrap.' => ['splitChar' => '#'],
                ],
            ],
            'split by pattern' => [
                '<wrapper>XXX</wrapper>',
                'XXX',
                [
                    'wrap' => '<wrapper> ###splitter### </wrapper>',
                    'wrap.' => ['splitChar' => '###splitter###'],
                ],
            ],
        ];
    }
 
    public function ‪stdWrap_wrap(string $expected, string $input, array $conf): void
    {
        self::assertSame(
            $expected,
            $this->subject->stdWrap_wrap($input, $conf)
        );
    }
 
    public function ‪stdWrap_wrap2DataProvider(): array
    {
        return [
            'no conf' => [
                'XXX',
                'XXX',
                [],
            ],
            'simple' => [
                '<wrapper>XXX</wrapper>',
                'XXX',
                ['wrap2' => '<wrapper>|</wrapper>'],
            ],
            'trims whitespace' => [
                '<wrapper>XXX</wrapper>',
                'XXX',
                ['wrap2' => '<wrapper>' . "\t" . ' | ' . "\t" . '</wrapper>'],
            ],
            'missing pipe puts wrap2 before' => [
                '<pre>XXX',
                'XXX',
                [
                    'wrap2' => '<pre>',
                ],
            ],
            'split char change' => [
                '<wrapper>XXX</wrapper>',
                'XXX',
                [
                    'wrap2' => '<wrapper> # </wrapper>',
                    'wrap2.' => ['splitChar' => '#'],
                ],
            ],
            'split by pattern' => [
                '<wrapper>XXX</wrapper>',
                'XXX',
                [
                    'wrap2' => '<wrapper> ###splitter### </wrapper>',
                    'wrap2.' => ['splitChar' => '###splitter###'],
                ],
            ],
        ];
    }
 
    public function ‪stdWrap_wrap2(string $expected, string $input, array $conf): void
    {
        self::assertSame($expected, $this->subject->stdWrap_wrap2($input, $conf));
    }
 
    public function ‪stdWrap_wrap3DataProvider(): array
    {
        return [
            'no conf' => [
                'XXX',
                'XXX',
                [],
            ],
            'simple' => [
                '<wrapper>XXX</wrapper>',
                'XXX',
                ['wrap3' => '<wrapper>|</wrapper>'],
            ],
            'trims whitespace' => [
                '<wrapper>XXX</wrapper>',
                'XXX',
                ['wrap3' => '<wrapper>' . "\t" . ' | ' . "\t" . '</wrapper>'],
            ],
            'missing pipe puts wrap3 before' => [
                '<pre>XXX',
                'XXX',
                [
                    'wrap3' => '<pre>',
                ],
            ],
            'split char change' => [
                '<wrapper>XXX</wrapper>',
                'XXX',
                [
                    'wrap3' => '<wrapper> # </wrapper>',
                    'wrap3.' => ['splitChar' => '#'],
                ],
            ],
            'split by pattern' => [
                '<wrapper>XXX</wrapper>',
                'XXX',
                [
                    'wrap3' => '<wrapper> ###splitter### </wrapper>',
                    'wrap3.' => ['splitChar' => '###splitter###'],
                ],
            ],
        ];
    }
 
    public function ‪stdWrap_wrap3(string $expected, string $input, array $conf): void
    {
        self::assertSame($expected, $this->subject->stdWrap_wrap3($input, $conf));
    }
 
    public function ‪stdWrap_wrapAlignDataProvider(): array
    {
        $format = '<div style="text-align:%s;">%s</div>';
        $content = ‪StringUtility::getUniqueId('content');
        $wrapAlign = ‪StringUtility::getUniqueId('wrapAlign');
        $expect = sprintf($format, $wrapAlign, $content);
        return [
            'standard case' => [$expect, $content, $wrapAlign],
            'empty conf' => [$content, $content, null],
            'empty string' => [$content, $content, ''],
            'whitespaced zero string' => [$content, $content, ' 0 '],
        ];
    }
 
    public function ‪stdWrap_wrapAlign(string $expect, string $content, $wrapAlignConf): void
    {
        $conf = [];
        if ($wrapAlignConf !== null) {
            $conf['wrapAlign'] = $wrapAlignConf;
        }
        self::assertSame(
            $expect,
            $this->subject->stdWrap_wrapAlign($content, $conf)
        );
    }
 
    /***************************************************************************
     * End of tests of stdWrap in alphabetical order
     ***************************************************************************/
 
    /***************************************************************************
     * Begin: Mixed tests
     *
     * - Add new tests here that still don't have a better place in this class.
     * - Place tests in alphabetical order.
     * - Place data provider above test method.
     ***************************************************************************/
 
    public function ‪getCurrentTable(): void
    {
        self::assertEquals('tt_content', $this->subject->getCurrentTable());
    }
 
    public function ‪prefixCommentDataProvider(): array
    {
        $comment = ‪StringUtility::getUniqueId();
        $content = ‪StringUtility::getUniqueId();
        $format = '%s';
        $format .= '%%s<!-- %%s [begin] -->%s';
        $format .= '%%s%s%%s%s';
        $format .= '%%s<!-- %%s [end] -->%s';
        $format .= '%%s%s';
        $format = sprintf($format, LF, LF, "\t", LF, LF, "\t");
        $indent1 = "\t";
        $indent2 = "\t" . "\t";
        return [
            'indent one tab' => [
                sprintf(
                    $format,
                    $indent1,
                    $comment,
                    $indent1,
                    $content,
                    $indent1,
                    $comment,
                    $indent1
                ),
                '1|' . $comment,
                $content,
            ],
            'indent two tabs' => [
                sprintf(
                    $format,
                    $indent2,
                    $comment,
                    $indent2,
                    $content,
                    $indent2,
                    $comment,
                    $indent2
                ),
                '2|' . $comment,
                $content,
            ],
            'htmlspecialchars applies for comment only' => [
                sprintf(
                    $format,
                    $indent1,
                    '&lt;' . $comment . '&gt;',
                    $indent1,
                    '<' . $content . '>',
                    $indent1,
                    '&lt;' . $comment . '&gt;',
                    $indent1
                ),
                '1|<' . $comment . '>',
                '<' . $content . '>',
            ],
        ];
    }
 
    public function ‪prefixComment(string $expect, string $comment, string $content): void
    {
        // The parameter $conf is never used. Just provide null.
        // Consider to improve the signature and deprecate the old one.
        $result = $this->subject->prefixComment($comment, null, $content);
        self::assertEquals($expect, $result);
    }
 
    public function ‪setCurrentFile_getCurrentFile(): void
    {
        $storageMock = $this->createMock(ResourceStorage::class);
        $file = new File(['testfile'], $storageMock);
        $this->subject->setCurrentFile($file);
        self::assertSame($file, $this->subject->getCurrentFile());
    }
 
    public function ‪setCurrentVal_getCurrentVal(): void
    {
        $key = ‪StringUtility::getUniqueId();
        $value = ‪StringUtility::getUniqueId();
        $this->subject->currentValKey = $key;
        $this->subject->setCurrentVal($value);
        self::assertEquals($value, $this->subject->getCurrentVal());
        self::assertEquals($value, $this->subject->data[$key]);
    }
 
    public function ‪setUserObjectType_getUserObjectType(): void
    {
        $value = ‪StringUtility::getUniqueId();
        $this->subject->setUserObjectType($value);
        self::assertEquals($value, $this->subject->getUserObjectType());
    }
 
    public function ‪emailSpamProtectionWithTypeAsciiDataProvider(): array
    {
        return [
            'Simple email address' => [
                'test@email.tld',
                '&#116;&#101;&#115;&#116;&#64;&#101;&#109;&#97;&#105;&#108;&#46;&#116;&#108;&#100;',
            ],
            'Simple email address with unicode characters' => [
                'matthäus@email.tld',
                '&#109;&#97;&#116;&#116;&#104;&#228;&#117;&#115;&#64;&#101;&#109;&#97;&#105;&#108;&#46;&#116;&#108;&#100;',
            ],
            'Susceptible email address' => [
                '"><script>alert(\'emailSpamProtection\')</script>',
                '&#34;&#62;&#60;&#115;&#99;&#114;&#105;&#112;&#116;&#62;&#97;&#108;&#101;&#114;&#116;&#40;&#39;&#101;&#109;&#97;&#105;&#108;&#83;&#112;&#97;&#109;&#80;&#114;&#111;&#116;&#101;&#99;&#116;&#105;&#111;&#110;&#39;&#41;&#60;&#47;&#115;&#99;&#114;&#105;&#112;&#116;&#62;',
 
            ],
            'Susceptible email address with unicode characters' => [
                '"><script>alert(\'ȅmǡilSpamProtȅction\')</script>',
                '&#34;&#62;&#60;&#115;&#99;&#114;&#105;&#112;&#116;&#62;&#97;&#108;&#101;&#114;&#116;&#40;&#39;&#517;&#109;&#481;&#105;&#108;&#83;&#112;&#97;&#109;&#80;&#114;&#111;&#116;&#517;&#99;&#116;&#105;&#111;&#110;&#39;&#41;&#60;&#47;&#115;&#99;&#114;&#105;&#112;&#116;&#62;',
            ],
        ];
    }
 
    public function ‪mailSpamProtectionWithTypeAscii(string $content, string $expected): void
    {
        self::assertSame(
            $expected,
            $this->subject->_call('encryptEmail', $content, 'ascii')
        );
    }
 
    public function ‪getGlobalDataProvider(): array
    {
        return [
            'simple' => [
                'foo',
                'HTTP_SERVER_VARS | something',
                [
                    'HTTP_SERVER_VARS' => [
                        'something' => 'foo',
                    ],
                ],
                null,
            ],
            'simple source fallback' => [
                'foo',
                'HTTP_SERVER_VARS | something',
                null,
                [
                    'HTTP_SERVER_VARS' => [
                        'something' => 'foo',
                    ],
                ],
            ],
            'globals ignored if source given' => [
                '',
                'HTTP_SERVER_VARS | something',
                [
                    'HTTP_SERVER_VARS' => [
                        'something' => 'foo',
                    ],
                ],
                [
                    'HTTP_SERVER_VARS' => [
                        'something-else' => 'foo',
                    ],
                ],
            ],
            'sub array is returned as empty string' => [
                '',
                'HTTP_SERVER_VARS | something',
                [
                    'HTTP_SERVER_VARS' => [
                        'something' => ['foo'],
                    ],
                ],
                null,
            ],
            'does not exist' => [
                '',
                'HTTP_SERVER_VARS | something',
                [
                    'HTTP_SERVER_VARS' => [
                        'something-else' => 'foo',
                    ],
                ],
                null,
            ],
            'does not exist in source' => [
                '',
                'HTTP_SERVER_VARS | something',
                null,
                [
                    'HTTP_SERVER_VARS' => [
                        'something-else' => 'foo',
                    ],
                ],
            ],
        ];
    }
 
    public function ‪getGlobalReturnsExpectedResult($expected, string $key, ?array $globals, ?array $source): void
    {
        if (isset($globals['HTTP_SERVER_VARS'])) {
            // Note we can't simply $GLOBALS = $globals, since phpunit backupGlobals works on existing array keys.
            ‪$GLOBALS['HTTP_SERVER_VARS'] = $globals['HTTP_SERVER_VARS'];
        }
        self::assertSame(
            $expected,
            (new ContentObjectRenderer())->getGlobal($key, $source)
        );
    }
 
    /***************************************************************************
     * End: Mixed tests
     ***************************************************************************/
}