ContentObjectRendererTest.php

Go to the documentation of this file.

<?php
declare(strict_types = 1);
namespace ‪TYPO3\CMS\Frontend\Tests\Unit\ContentObject;
 
/*
 * 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!
 */
 
use PHPUnit\Framework\Exception;
use Prophecy\Argument;
use Psr\Http\Message\ServerRequestInterface;
use ‪TYPO3\CMS\Core\Authentication\BackendUserAuthentication;
use ‪TYPO3\CMS\Core\Cache\CacheManager;
use ‪TYPO3\CMS\Core\Cache\Frontend\FrontendInterface as CacheFrontendInterface;
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\Http\ServerRequest;
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\Site\Entity\Site;
use ‪TYPO3\CMS\Core\Site\Entity\SiteLanguage;
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\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\ContentObjectArrayContentObject;
use ‪TYPO3\CMS\Frontend\ContentObject\ContentObjectArrayInternalContentObject;
use ‪TYPO3\CMS\Frontend\ContentObject\ContentObjectGetImageResourceHookInterface;
use ‪TYPO3\CMS\Frontend\ContentObject\ContentObjectOneSourceCollectionHookInterface;
use ‪TYPO3\CMS\Frontend\ContentObject\ContentObjectRenderer;
use ‪TYPO3\CMS\Frontend\ContentObject\ContentObjectStdWrapHookInterface;
use ‪TYPO3\CMS\Frontend\ContentObject\EditPanelContentObject;
use ‪TYPO3\CMS\Frontend\ContentObject\Exception\ContentRenderingException;
use ‪TYPO3\CMS\Frontend\ContentObject\FileContentObject;
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\TemplateContentObject;
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\Page\PageRepository;
use TYPO3\TestingFramework\Core\AccessibleObjectInterface;
use TYPO3\TestingFramework\Core\Unit\UnitTestCase;
 
class ‪ContentObjectRendererTest extends UnitTestCase
{
    use ‪ContentObjectRendererTestTrait;
 
    protected ‪$resetSingletonInstances = true;
 
    protected ‪$subject;
 
    protected ‪$frontendControllerMock;
 
    protected ‪$templateServiceMock;
 
    protected ‪$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,
        'FILE' => FileContentObject::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,
        'TEMPLATE' => TemplateContentObject::class,
        'FLUIDTEMPLATE' => FluidTemplateContentObject::class,
        'SVG' => ScalableVectorGraphicsContentObject::class,
        'EDITPANEL' => EditPanelContentObject::class
    ];
 
    protected function ‪setUp(): void
    {
        ‪$GLOBALS['SIM_ACCESS_TIME'] = 1534278180;
        $packageManagerMock = $this->getMockBuilder(PackageManager::class)
            ->disableOriginalConstructor()
            ->getMock();
        $this->templateServiceMock =
            $this->getMockBuilder(TemplateService::class)
                ->setConstructorArgs([null, $packageManagerMock])
                ->setMethods(['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;
        ‪$GLOBALS['TSFE'] = ‪$this->frontendControllerMock;
 
        $this->subject = $this->getAccessibleMock(
            ContentObjectRenderer::class,
            ['getResourceFactory', 'getEnvironmentVariable'],
            [$this->frontendControllerMock]
        );
 
        $logger = $this->prophesize(Logger::class);
        $this->subject->setLogger($logger->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('cache_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->expects($this->any())->method('getResourceFactory')->will($this->returnValue($resourceFactory));
 
        $className = $this->getUniqueId('tx_coretest');
        $getImgResourceHookMock = $this->getMockBuilder(ContentObjectGetImageResourceHookInterface::class)
            ->setMethods(['getImgResourcePostProcess'])
            ->setMockClassName($className)
            ->getMock();
        $getImgResourceHookMock
            ->expects($this->once())
            ->method('getImgResourcePostProcess')
            ->will($this->returnCallback([$this, 'isGetImgResourceHookCalledCallback']));
        $getImgResourceHookObjects = [$getImgResourceHookMock];
        $this->subject->_setRef('getImgResourceHookObjects', $getImgResourceHookObjects);
        $this->subject->getImgResource('typo3/sysext/core/Tests/Unit/Utility/Fixtures/clear.gif', []);
    }
 
    public function ‪isGetImgResourceHookCalledCallback(
        string $file,
        array $fileArray,
        $imageResource,
        ContentObjectRenderer $parent
    ): array {
        $this->assertEquals('typo3/sysext/core/Tests/Unit/Utility/Fixtures/clear.gif', $file);
        $this->assertEquals('typo3/sysext/core/Tests/Unit/Utility/Fixtures/clear.gif', $imageResource['origFile']);
        $this->assertTrue(is_array($fileArray));
        $this->assertTrue($parent instanceof ContentObjectRenderer);
        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);
        $this->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);
        $this->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);
        $this->assertNull($object);
    }
 
    public function ‪willReturnNullForUnregisteredObject(): void
    {
        $object = $this->subject->getContentObject('FOO');
        $this->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 {
        $this->assertTrue(
            is_subclass_of($className, AbstractContentObject::class)
        );
        $object = $this->subject->getContentObject($objectName);
        $this->assertInstanceOf($className, $object);
    }
 
    // Tests concerning getQueryArguments()
 
    public function ‪getQueryArgumentsExcludesParameters(): void
    {
        $this->subject->expects($this->any())->method('getEnvironmentVariable')->with($this->equalTo('QUERY_STRING'))->will(
            $this->returnValue('key1=value1&key2=value2&key3[key31]=value31&key3[key32][key321]=value321&key3[key32][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);
        $this->assertEquals($expectedResult, $actualResult);
    }
 
    public function ‪getQueryArgumentsExcludesGetParameters(): void
    {
        $_GET = [
            'key1' => 'value1',
            'key2' => 'value2',
            'key3' => [
                'key31' => 'value31',
                'key32' => [
                    'key321' => 'value321',
                    'key322' => 'value322'
                ]
            ]
        ];
        $getQueryArgumentsConfiguration = [];
        $getQueryArgumentsConfiguration['method'] = 'GET';
        $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);
        $this->assertEquals($expectedResult, $actualResult);
    }
 
    public function ‪getQueryArgumentsOverrulesSingleParameter(): void
    {
        $this->subject->expects($this->any())->method('getEnvironmentVariable')->with($this->equalTo('QUERY_STRING'))->will(
            $this->returnValue('key1=value1')
        );
        $getQueryArgumentsConfiguration = [];
        $overruleArguments = [
            // Should be overridden
            'key1' => 'value1Overruled',
            // Shouldn't be set: Parameter doesn't exist in source array and is not forced
            'key2' => 'value2Overruled'
        ];
        $expectedResult = '&key1=value1Overruled';
        $actualResult = $this->subject->getQueryArguments($getQueryArgumentsConfiguration, $overruleArguments);
        $this->assertEquals($expectedResult, $actualResult);
    }
 
    public function ‪getQueryArgumentsOverrulesMultiDimensionalParameters(): void
    {
        $_POST = [
            'key1' => 'value1',
            'key2' => 'value2',
            'key3' => [
                'key31' => 'value31',
                'key32' => [
                    'key321' => 'value321',
                    'key322' => 'value322'
                ]
            ]
        ];
        $getQueryArgumentsConfiguration = [];
        $getQueryArgumentsConfiguration['method'] = 'POST';
        $getQueryArgumentsConfiguration['exclude'] = [];
        $getQueryArgumentsConfiguration['exclude'][] = 'key1';
        $getQueryArgumentsConfiguration['exclude'][] = 'key3[key31]';
        $getQueryArgumentsConfiguration['exclude'][] = 'key3[key32][key321]';
        $getQueryArgumentsConfiguration['exclude'] = implode(',', $getQueryArgumentsConfiguration['exclude']);
        $overruleArguments = [
            // Should be overridden
            'key2' => 'value2Overruled',
            'key3' => [
                'key32' => [
                    // Shouldn't be set: Parameter is excluded and not forced
                    'key321' => 'value321Overruled',
                    // Should be overridden: Parameter is not excluded
                    'key322' => 'value322Overruled',
                    // Shouldn't be set: Parameter doesn't exist in source array and is not forced
                    'key323' => 'value323Overruled'
                ]
            ]
        ];
        $expectedResult = $this->‪rawUrlEncodeSquareBracketsInUrl('&key2=value2Overruled&key3[key32][key322]=value322Overruled');
        $actualResult = $this->subject->getQueryArguments($getQueryArgumentsConfiguration, $overruleArguments);
        $this->assertEquals($expectedResult, $actualResult);
    }
 
    public function ‪getQueryArgumentsOverrulesMultiDimensionalForcedParameters(): void
    {
        $this->subject->expects($this->any())->method('getEnvironmentVariable')->with($this->equalTo('QUERY_STRING'))->will(
            $this->returnValue('key1=value1&key2=value2&key3[key31]=value31&key3[key32][key321]=value321&key3[key32][key322]=value322')
        );
        $_POST = [
            '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'][] = 'key3[key32][key322]';
        $getQueryArgumentsConfiguration['exclude'] = implode(',', $getQueryArgumentsConfiguration['exclude']);
        $overruleArguments = [
            // Should be overridden
            'key2' => 'value2Overruled',
            'key3' => [
                'key32' => [
                    // Should be set: Parameter is excluded but forced
                    'key321' => 'value321Overruled',
                    // Should be set: Parameter doesn't exist in source array but is forced
                    'key323' => 'value323Overruled'
                ]
            ]
        ];
        $expectedResult = $this->‪rawUrlEncodeSquareBracketsInUrl('&key2=value2Overruled&key3[key32][key321]=value321Overruled&key3[key32][key323]=value323Overruled');
        $actualResult = $this->subject->getQueryArguments($getQueryArgumentsConfiguration, $overruleArguments, true);
        $this->assertEquals($expectedResult, $actualResult);
        $getQueryArgumentsConfiguration['method'] = 'POST';
        $actualResult = $this->subject->getQueryArguments($getQueryArgumentsConfiguration, $overruleArguments, true);
        $this->assertEquals($expectedResult, $actualResult);
    }
 
    public function ‪getQueryArgumentsWithMethodPostGetMergesParameters(): void
    {
        $_POST = [
            'key1' => 'POST1',
            'key2' => 'POST2',
            'key3' => [
                'key31' => 'POST31',
                'key32' => 'POST32',
                'key33' => [
                    'key331' => 'POST331',
                    'key332' => 'POST332',
                ]
            ]
        ];
        $_GET = [
            'key2' => 'GET2',
            'key3' => [
                'key32' => 'GET32',
                'key33' => [
                    'key331' => 'GET331',
                ]
            ]
        ];
        $getQueryArgumentsConfiguration = [];
        $getQueryArgumentsConfiguration['method'] = 'POST,GET';
        $expectedResult = $this->‪rawUrlEncodeSquareBracketsInUrl('&key1=POST1&key2=GET2&key3[key31]=POST31&key3[key32]=GET32&key3[key33][key331]=GET331&key3[key33][key332]=POST332');
        $actualResult = $this->subject->getQueryArguments($getQueryArgumentsConfiguration);
        $this->assertEquals($expectedResult, $actualResult);
    }
 
    public function ‪getQueryArgumentsWithMethodGetPostMergesParameters(): void
    {
        $_GET = [
            'key1' => 'GET1',
            'key2' => 'GET2',
            'key3' => [
                'key31' => 'GET31',
                'key32' => 'GET32',
                'key33' => [
                    'key331' => 'GET331',
                    'key332' => 'GET332',
                ]
            ]
        ];
        $_POST = [
            'key2' => 'POST2',
            'key3' => [
                'key32' => 'POST32',
                'key33' => [
                    'key331' => 'POST331',
                ]
            ]
        ];
        $getQueryArgumentsConfiguration = [];
        $getQueryArgumentsConfiguration['method'] = 'GET,POST';
        $expectedResult = $this->‪rawUrlEncodeSquareBracketsInUrl('&key1=GET1&key2=POST2&key3[key31]=GET31&key3[key32]=POST32&key3[key33][key331]=POST331&key3[key33][key332]=GET332');
        $actualResult = $this->subject->getQueryArguments($getQueryArgumentsConfiguration);
        $this->assertEquals($expectedResult, $actualResult);
    }
 
    private function ‪rawUrlEncodeSquareBracketsInUrl(string $string): string
    {
        return str_replace(['[', ']'], ['%5B', '%5D'], $string);
    }
 
    // Tests concerning crop
 
    public function ‪cropIsMultibyteSafe(): void
    {
        $this->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';
 
        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',
            ],
        ];
    }
 
    public function ‪cropHTML(string $expect, string $content, string $conf): void
    {
        $this->‪handleCharset($content, $expect);
        $this->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
    {
        $this->assertSame(
            $expect,
            $this->subject->_call('round', $content, $conf)
        );
    }
 
    public function ‪recursiveStdWrapProperlyRendersBasicString(): void
    {
        $stdWrapConfiguration = [
            'noTrimWrap' => '|| 123|',
            'stdWrap.' => [
                'wrap' => '<b>|</b>'
            ]
        ];
        $this->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',
                        ]
                    ]
                ]
            ]
        ];
        $this->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
    {
        $this->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
    {
        $this->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
    {
        $this->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
    {
        $this->assertSame($expectation, $this->subject->stdWrap($content, $configuration));
    }
 
    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
    {
        $this->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',
        ];
        $this->assertEquals($expectedValue, $this->subject->getData('gp:' . $key));
    }
 
    public function ‪getDataWithTypeTsfe(): void
    {
        $this->assertEquals(‪$GLOBALS['TSFE']->metaCharset, $this->subject->getData('tsfe:metaCharset'));
    }
 
    public function ‪getDataWithTypeGetenv(): void
    {
        $envName = $this->getUniqueId('frontendtest');
        $value = $this->getUniqueId('someValue');
        putenv($envName . '=' . $value);
        $this->assertEquals($value, $this->subject->getData('getenv:' . $envName));
    }
 
    public function ‪getDataWithTypeGetindpenv(): void
    {
        $this->subject->expects($this->once())->method('getEnvironmentVariable')
            ->with($this->equalTo('SCRIPT_FILENAME'))->will($this->returnValue('dummyPath'));
        $this->assertEquals('dummyPath', $this->subject->getData('getindpenv:SCRIPT_FILENAME'));
    }
 
    public function ‪getDataWithTypeField(): void
    {
        $key = 'someKey';
        $value = 'someValue';
        $field = [$key => $value];
 
        $this->assertEquals($value, $this->subject->getData('field:' . $key, $field));
    }
 
    public function ‪getDataWithTypeFieldAndFieldIsMultiDimensional(): void
    {
        $key = 'somekey|level1|level2';
        $value = 'somevalue';
        $field = ['somekey' => ['level1' => ['level2' => 'somevalue']]];
 
        $this->assertEquals($value, $this->subject->getData('field:' . $key, $field));
    }
 
    public function ‪getDataWithTypeFileReturnsUidOfFileObject(): void
    {
        $uid = $this->getUniqueId();
        $file = $this->createMock(File::class);
        $file->expects($this->once())->method('getUid')->will($this->returnValue($uid));
        $this->subject->setCurrentFile($file);
        $this->assertEquals($uid, $this->subject->getData('file:current:uid'));
    }
 
    public function ‪getDataWithTypeParameters(): void
    {
        $key = $this->getUniqueId('someKey');
        $value = $this->getUniqueId('someValue');
        $this->subject->parameters[$key] = $value;
 
        $this->assertEquals($value, $this->subject->getData('parameters:' . $key));
    }
 
    public function ‪getDataWithTypeRegister(): void
    {
        $key = $this->getUniqueId('someKey');
        $value = $this->getUniqueId('someValue');
        ‪$GLOBALS['TSFE']->register[$key] = $value;
 
        $this->assertEquals($value, $this->subject->getData('register:' . $key));
    }
 
    public function ‪getDataWithTypeSession(): void
    {
        $frontendUser = $this->getMockBuilder(FrontendUserAuthentication::class)
            ->setMethods(['getSessionData'])
            ->getMock();
        $frontendUser->expects($this->once())->method('getSessionData')->with('myext')->willReturn([
            'mydata' => [
                'someValue' => 42,
            ],
        ]);
        ‪$GLOBALS['TSFE']->fe_user = $frontendUser;
 
        $this->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;
        $this->assertEquals(2, $this->subject->getData('level'));
    }
 
    public function ‪getDataWithTypeGlobal(): void
    {
        $this->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;
        $this->assertEquals('', $this->subject->getData('leveltitle:-1'));
        // since "title3" is not set, it will slide to "title2"
        $this->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;
        $this->assertEquals('', $this->subject->getData('levelmedia:-1'));
        // since "title3" is not set, it will slide to "title2"
        $this->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;
        $this->assertEquals(3, $this->subject->getData('leveluid:-1'));
        // every element will have a uid - so adding slide doesn't really make sense, just for completeness
        $this->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;
        $this->assertEquals('', $this->subject->getData('levelfield:-1,testfield'));
        $this->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;
        $this->assertEquals('field2', $this->subject->getData('fullrootline:-1,testfield'));
    }
 
    public function ‪getDataWithTypeDate(): void
    {
        $format = 'Y-M-D';
        $defaultFormat = 'd/m Y';
 
        $this->assertEquals(date($format, ‪$GLOBALS['EXEC_TIME']), $this->subject->getData('date:' . $format));
        $this->assertEquals(date($defaultFormat, ‪$GLOBALS['EXEC_TIME']), $this->subject->getData('date'));
    }
 
    public function ‪getDataWithTypePage(): void
    {
        $uid = mt_rand();
        ‪$GLOBALS['TSFE']->page['uid'] = $uid;
        $this->assertEquals($uid, $this->subject->getData('page:uid'));
    }
 
    public function ‪getDataWithTypeCurrent(): void
    {
        $key = $this->getUniqueId('someKey');
        $value = $this->getUniqueId('someValue');
        $this->subject->data[$key] = $value;
        $this->subject->currentValKey = $key;
        $this->assertEquals($value, $this->subject->getData('current'));
    }
 
    public function ‪getDataWithTypeDb(): void
    {
        $dummyRecord = ['uid' => 5, 'title' => 'someTitle'];
 
        ‪$GLOBALS['TSFE']->sys_page->expects($this->atLeastOnce())->method('getRawRecord')->with(
            'tt_content',
            '106'
        )->will($this->returnValue($dummyRecord));
        $this->assertEquals($dummyRecord['title'], $this->subject->getData('db:tt_content:106:title'));
    }
 
    public function ‪getDataWithTypeLll(): void
    {
        $key = $this->getUniqueId('someKey');
        $value = $this->getUniqueId('someValue');
        ‪$GLOBALS['TSFE']->expects($this->once())->method('sL')->with('LLL:' . $key)->will($this->returnValue($value));
        $this->assertEquals($value, $this->subject->getData('lll:' . $key));
    }
 
    public function ‪getDataWithTypePath(): void
    {
        $filenameIn = 'typo3/sysext/frontend/Public/Icons/Extension.svg';
        $this->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);
        $this->assertEquals(3, $this->subject->getData('context:workspace:id'));
        $this->assertEquals('0,-1', $this->subject->getData('context:frontend.user:groupIds'));
        $this->assertEquals(false, $this->subject->getData('context:frontend.user:isLoggedIn'));
        $this->assertEquals(false, $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'
               ]
           ]
        ]);
        $serverRequest = $this->prophesize(ServerRequestInterface::class);
        $serverRequest->getAttribute('site')->willReturn($site);
        ‪$GLOBALS['TYPO3_REQUEST'] = $serverRequest->reveal();
        $this->assertEquals('http://example.com', $this->subject->getData('site:base'));
        $this->assertEquals('yeah', $this->subject->getData('site:custom.config.nested'));
    }
 
    public function ‪getDataWithTypeSiteWithBaseVariants(): void
    {
        $cacheManagerProphecy = $this->prophesize(CacheManager::class);
        $cacheProphecy = $this->prophesize(CacheFrontendInterface::class);
        $cacheManagerProphecy->getCache('cache_core')->willReturn($cacheProphecy->reveal());
        GeneralUtility::setSingletonInstance(CacheManager::class, $cacheManagerProphecy->reveal());
        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'
                ],
            ]
        ]);
 
        $serverRequest = $this->prophesize(ServerRequestInterface::class);
        $serverRequest->getAttribute('site')->willReturn($site);
        ‪$GLOBALS['TYPO3_REQUEST'] = $serverRequest->reveal();
        $this->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);
        $serverRequest = $this->prophesize(ServerRequestInterface::class);
        $serverRequest->getAttribute('language')->willReturn($language);
        ‪$GLOBALS['TYPO3_REQUEST'] = $serverRequest->reveal();
        $this->assertEquals('German', $this->subject->getData('siteLanguage:navigationTitle'));
    }
 
    public function ‪getDataWithTypeParentRecordNumber(): void
    {
        $recordNumber = mt_rand();
        $this->subject->parentRecordNumber = $recordNumber;
        $this->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);
 
        $this->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);
 
        $this->assertEquals($expectedResult, $cleanedResult);
    }
 
    public function ‪getDataWithTypeDebugData(): void
    {
        $key = $this->getUniqueId('someKey');
        $value = $this->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);
 
        $this->assertEquals($expectedResult, $cleanedResult);
    }
 
    public function ‪getDataWithTypeDebugRegister(): void
    {
        $key = $this->getUniqueId('someKey');
        $value = $this->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);
 
        $this->assertEquals($expectedResult, $cleanedResult);
    }
 
    public function ‪getDataWithTypeDebugPage(): void
    {
        $uid = mt_rand();
        ‪$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);
 
        $this->assertEquals($expectedResult, $cleanedResult);
    }
 
    public function ‪aTagParamsHasLeadingSpaceIfNotEmpty(): void
    {
        $aTagParams = $this->subject->getATagParams(['ATagParams' => 'data-test="testdata"']);
        $this->assertEquals(' data-test="testdata"', $aTagParams);
    }
 
    public function ‪aTagParamsHaveSpaceBetweenLocalAndGlobalParams(): void
    {
        ‪$GLOBALS['TSFE']->ATagParams = 'data-global="dataglobal"';
        $aTagParams = $this->subject->getATagParams(['ATagParams' => 'data-test="testdata"']);
        $this->assertEquals(' data-global="dataglobal" data-test="testdata"', $aTagParams);
    }
 
    public function ‪aTagParamsHasNoLeadingSpaceIfEmpty(): void
    {
        // make sure global ATagParams are empty
        ‪$GLOBALS['TSFE']->ATagParams = '';
        $aTagParams = $this->subject->getATagParams(['ATagParams' => '']);
        $this->assertEquals('', $aTagParams);
    }
 
    public function ‪getImageTagTemplateFallsBackToDefaultTemplateIfNoTemplateIsFoundDataProvider(): array
    {
        return [
            [null, null],
            ['', null],
            ['', []],
            ['fooo', ['foo' => 'bar']]
        ];
    }
 
    public function ‪getImageTagTemplateFallsBackToDefaultTemplateIfNoTemplateIsFound($key, $configuration): void
    {
        $defaultImgTagTemplate = '<img src="###SRC###" width="###WIDTH###" height="###HEIGHT###" ###PARAMS### ###ALTPARAMS### ###BORDER######SELFCLOSINGTAGSLASH###>';
        $result = $this->subject->getImageTagTemplate($key, $configuration);
        $this->assertEquals($result, $defaultImgTagTemplate);
    }
 
    public function ‪getImageTagTemplateReturnTemplateElementIdentifiedByKeyDataProvider(): array
    {
        return [
            [
                'foo',
                [
                    'layout.' => [
                        'foo.' => [
                            'element' => '<img src="###SRC###" srcset="###SOURCES###" ###PARAMS### ###ALTPARAMS### ###FOOBAR######SELFCLOSINGTAGSLASH###>'
                        ]
                    ]
                ],
                '<img src="###SRC###" srcset="###SOURCES###" ###PARAMS### ###ALTPARAMS### ###FOOBAR######SELFCLOSINGTAGSLASH###>'
            ]
 
        ];
    }
 
    public function ‪getImageTagTemplateReturnTemplateElementIdentifiedByKey($key, $configuration, $expectation): void
    {
        $result = $this->subject->getImageTagTemplate($key, $configuration);
        $this->assertEquals($result, $expectation);
    }
 
    public function ‪getImageSourceCollectionReturnsEmptyStringIfNoSourcesAreDefinedDataProvider(): array
    {
        return [
            [null, null, null],
            ['foo', null, null],
            ['foo', ['sourceCollection.' => 1], 'bar']
        ];
    }
 
    public function ‪getImageSourceCollectionReturnsEmptyStringIfNoSourcesAreDefined(
        $layoutKey,
        $configuration,
        $file
    ): void {
        $result = $this->subject->getImageSourceCollection($layoutKey, $configuration, $file);
        $this->assertSame($result, '');
    }
 
    public function ‪getImageSourceCollectionRendersDefinedSources(): void
    {
        $cObj = $this->getMockBuilder(ContentObjectRenderer::class)
            ->setMethods(['stdWrap', 'getImgResource'])
            ->getMock();
 
        $cObj->start([], 'tt_content');
 
        $layoutKey = 'test';
 
        $configuration = [
            'layoutKey' => 'test',
            'layout.' => [
                'test.' => [
                    'element' => '<img ###SRC### ###SRCCOLLECTION### ###SELFCLOSINGTAGSLASH###>',
                    'source' => '---###SRC###---'
                ]
            ],
            'sourceCollection.' => [
                '1.' => [
                    'width' => '200'
                ]
            ]
        ];
 
        $file = 'testImageName';
 
        // Avoid calling of stdWrap
        $cObj
            ->expects($this->any())
            ->method('stdWrap')
            ->will($this->returnArgument(0));
 
        // Avoid calling of imgResource
        $cObj
            ->expects($this->exactly(1))
            ->method('getImgResource')
            ->with($this->equalTo('testImageName'))
            ->will($this->returnValue([100, 100, null, 'bar']));
 
        $result = $cObj->getImageSourceCollection($layoutKey, $configuration, $file);
 
        $this->assertEquals('---bar---', $result);
    }
 
    public function ‪getImageSourceCollectionRendersDefinedLayoutKeyDataDefaultProvider(): array
    {
        $sourceCollectionArray = [
            'small.' => [
                'width' => 200,
                'srcsetCandidate' => '600w',
                'mediaQuery' => '(max-device-width: 600px)',
                'dataKey' => 'small',
            ],
            'smallRetina.' => [
                'if.directReturn' => 0,
                'width' => 200,
                'pixelDensity' => '2',
                'srcsetCandidate' => '600w 2x',
                'mediaQuery' => '(max-device-width: 600px) AND (min-resolution: 192dpi)',
                'dataKey' => 'smallRetina',
            ]
        ];
        return [
            [
                'default',
                [
                    'layoutKey' => 'default',
                    'layout.' => [
                        'default.' => [
                            'element' => '<img src="###SRC###" width="###WIDTH###" height="###HEIGHT###" ###PARAMS### ###ALTPARAMS### ###BORDER######SELFCLOSINGTAGSLASH###>',
                            'source' => ''
                        ]
                    ],
                    'sourceCollection.' => $sourceCollectionArray
                ]
            ],
        ];
    }
 
    public function ‪getImageSourceCollectionRendersDefinedLayoutKeyDefault($layoutKey, $configuration): void
    {
        $cObj = $this->getMockBuilder(ContentObjectRenderer::class)
            ->setMethods(['stdWrap', 'getImgResource'])
            ->getMock();
 
        $cObj->start([], 'tt_content');
 
        $file = 'testImageName';
 
        // Avoid calling of stdWrap
        $cObj
            ->expects($this->any())
            ->method('stdWrap')
            ->will($this->returnArgument(0));
 
        $result = $cObj->getImageSourceCollection($layoutKey, $configuration, $file);
 
        $this->assertEmpty($result);
    }
 
    public function ‪getImageSourceCollectionRendersDefinedLayoutKeyDataDataProvider(): array
    {
        $sourceCollectionArray = [
            'small.' => [
                'width' => 200,
                'srcsetCandidate' => '600w',
                'mediaQuery' => '(max-device-width: 600px)',
                'dataKey' => 'small',
            ],
            'smallRetina.' => [
                'if.directReturn' => 1,
                'width' => 200,
                'pixelDensity' => '2',
                'srcsetCandidate' => '600w 2x',
                'mediaQuery' => '(max-device-width: 600px) AND (min-resolution: 192dpi)',
                'dataKey' => 'smallRetina',
            ]
        ];
        return [
            [
                'srcset',
                [
                    'layoutKey' => 'srcset',
                    'layout.' => [
                        'srcset.' => [
                            'element' => '<img src="###SRC###" srcset="###SOURCECOLLECTION###" ###PARAMS### ###ALTPARAMS######SELFCLOSINGTAGSLASH###>',
                            'source' => '|*|###SRC### ###SRCSETCANDIDATE###,|*|###SRC### ###SRCSETCANDIDATE###'
                        ]
                    ],
                    'sourceCollection.' => $sourceCollectionArray
                ],
                'xhtml_strict',
                'bar-file.jpg 600w,bar-file.jpg 600w 2x',
            ],
            [
                'picture',
                [
                    'layoutKey' => 'picture',
                    'layout.' => [
                        'picture.' => [
                            'element' => '<picture>###SOURCECOLLECTION###<img src="###SRC###" ###PARAMS### ###ALTPARAMS######SELFCLOSINGTAGSLASH###></picture>',
                            'source' => '<source src="###SRC###" media="###MEDIAQUERY###"###SELFCLOSINGTAGSLASH###>'
                        ]
                    ],
                    'sourceCollection.' => $sourceCollectionArray,
                ],
                'xhtml_strict',
                '<source src="bar-file.jpg" media="(max-device-width: 600px)" /><source src="bar-file.jpg" media="(max-device-width: 600px) AND (min-resolution: 192dpi)" />',
            ],
            [
                'picture',
                [
                    'layoutKey' => 'picture',
                    'layout.' => [
                        'picture.' => [
                            'element' => '<picture>###SOURCECOLLECTION###<img src="###SRC###" ###PARAMS### ###ALTPARAMS######SELFCLOSINGTAGSLASH###></picture>',
                            'source' => '<source src="###SRC###" media="###MEDIAQUERY###"###SELFCLOSINGTAGSLASH###>'
                        ]
                    ],
                    'sourceCollection.' => $sourceCollectionArray,
                ],
                '',
                '<source src="bar-file.jpg" media="(max-device-width: 600px)"><source src="bar-file.jpg" media="(max-device-width: 600px) AND (min-resolution: 192dpi)">',
            ],
            [
                'data',
                [
                    'layoutKey' => 'data',
                    'layout.' => [
                        'data.' => [
                            'element' => '<img src="###SRC###" ###SOURCECOLLECTION### ###PARAMS### ###ALTPARAMS######SELFCLOSINGTAGSLASH###>',
                            'source' => 'data-###DATAKEY###="###SRC###"'
                        ]
                    ],
                    'sourceCollection.' => $sourceCollectionArray
                ],
                'xhtml_strict',
                'data-small="bar-file.jpg"data-smallRetina="bar-file.jpg"',
            ],
        ];
    }
 
    public function ‪getImageSourceCollectionRendersDefinedLayoutKeyData(
        $layoutKey,
        $configuration,
        $xhtmlDoctype,
        $expectedHtml
    ): void {
        $cObj = $this->getMockBuilder(ContentObjectRenderer::class)
            ->setMethods(['stdWrap', 'getImgResource'])
            ->getMock();
 
        $cObj->start([], 'tt_content');
 
        $file = 'testImageName';
 
        ‪$GLOBALS['TSFE']->xhtmlDoctype = $xhtmlDoctype;
 
        // Avoid calling of stdWrap
        $cObj
            ->expects($this->any())
            ->method('stdWrap')
            ->will($this->returnArgument(0));
 
        // Avoid calling of imgResource
        $cObj
            ->expects($this->exactly(2))
            ->method('getImgResource')
            ->with($this->equalTo('testImageName'))
            ->will($this->returnValue([100, 100, null, 'bar-file.jpg']));
 
        $result = $cObj->getImageSourceCollection($layoutKey, $configuration, $file);
 
        $this->assertEquals($expectedHtml, $result);
    }
 
    public function ‪getImageSourceCollectionHookCalled(): void
    {
        $this->subject = $this->getAccessibleMock(
            ContentObjectRenderer::class,
            ['getResourceFactory', 'stdWrap', 'getImgResource']
        );
        $this->subject->start([], 'tt_content');
 
        // Avoid calling stdwrap and getImgResource
        $this->subject->expects($this->any())
            ->method('stdWrap')
            ->will($this->returnArgument(0));
 
        $this->subject->expects($this->any())
            ->method('getImgResource')
            ->will($this->returnValue([100, 100, null, 'bar-file.jpg']));
 
        $resourceFactory = $this->createMock(ResourceFactory::class);
        $this->subject->expects($this->any())->method('getResourceFactory')->will($this->returnValue($resourceFactory));
 
        $className = $this->getUniqueId('tx_coretest_getImageSourceCollectionHookCalled');
        $getImageSourceCollectionHookMock = $this->getMockBuilder(
            ContentObjectOneSourceCollectionHookInterface::class
        )
            ->setMethods(['getOneSourceCollection'])
            ->setMockClassName($className)
            ->getMock();
        GeneralUtility::addInstance($className, $getImageSourceCollectionHookMock);
        ‪$GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['tslib/class.tslib_content.php']['getImageSourceCollection'][] = $className;
 
        $getImageSourceCollectionHookMock
            ->expects($this->exactly(1))
            ->method('getOneSourceCollection')
            ->will($this->returnCallback([$this, 'isGetOneSourceCollectionCalledCallback']));
 
        $configuration = [
            'layoutKey' => 'data',
            'layout.' => [
                'data.' => [
                    'element' => '<img src="###SRC###" ###SOURCECOLLECTION### ###PARAMS### ###ALTPARAMS######SELFCLOSINGTAGSLASH###>',
                    'source' => 'data-###DATAKEY###="###SRC###"'
                ]
            ],
            'sourceCollection.' => [
                'small.' => [
                    'width' => 200,
                    'srcsetCandidate' => '600w',
                    'mediaQuery' => '(max-device-width: 600px)',
                    'dataKey' => 'small',
                ],
            ],
        ];
 
        $result = $this->subject->getImageSourceCollection('data', $configuration, $this->getUniqueId('testImage-'));
 
        $this->assertSame($result, 'isGetOneSourceCollectionCalledCallback');
    }
 
    public function ‪isGetOneSourceCollectionCalledCallback(
        array $sourceRenderConfiguration,
        array $sourceConfiguration,
        $oneSourceCollection,
        $parent
    ): string {
        $this->assertTrue(is_array($sourceRenderConfiguration));
        $this->assertTrue(is_array($sourceConfiguration));
        return 'isGetOneSourceCollectionCalledCallback';
    }
 
    public function ‪renderingContentObjectThrowsException(): void
    {
        $this->expectException(\LogicException::class);
        $this->expectExceptionCode(1414513947);
        $contentObjectFixture = $this->‪createContentObjectThrowingExceptionFixture();
        $this->subject->render($contentObjectFixture, []);
    }
 
    public function ‪exceptionHandlerIsEnabledByDefaultInProductionContext(): void
    {
        $backupApplicationContext = GeneralUtility::getApplicationContext();
        ‪Fixtures\GeneralUtilityFixture::setApplicationContext(new ‪ApplicationContext('Production'));
 
        $contentObjectFixture = $this->‪createContentObjectThrowingExceptionFixture();
        $this->subject->render($contentObjectFixture, []);
 
        ‪Fixtures\GeneralUtilityFixture::setApplicationContext($backupApplicationContext);
    }
 
    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();
        $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',
            ]
        ];
 
        $this->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',
            ]
        ];
 
        $this->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()
    {
        $contentObjectFixture = $this->getMockBuilder(AbstractContentObject::class)
            ->setConstructorArgs([$this->subject])
            ->getMock();
        $contentObjectFixture->expects($this->once())
            ->method('render')
            ->willReturnCallback(function () {
                throw new \LogicException('Exception during rendering', 1414513947);
            });
        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 ‪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">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">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>',
            ],
        ];
    }
 
    public function ‪typolinkReturnsCorrectLinksForEmailsAndUrls($linkText, $configuration, $expectedResult): void
    {
        $packageManagerMock = $this->getMockBuilder(PackageManager::class)
            ->disableOriginalConstructor()
            ->getMock();
        $templateServiceObjectMock = $this->getMockBuilder(TemplateService::class)
            ->setConstructorArgs([null, $packageManagerMock])
            ->setMethods(['dummy'])
            ->getMock();
        $templateServiceObjectMock->setup = [
            'lib.' => [
                'parseFunc.' => $this->‪getLibParseFunc(),
            ],
        ];
        $typoScriptFrontendControllerMockObject = $this->createMock(TypoScriptFrontendController::class);
        $typoScriptFrontendControllerMockObject->config = [
            'config' => [],
        ];
        $typoScriptFrontendControllerMockObject->tmpl = $templateServiceObjectMock;
        ‪$GLOBALS['TSFE'] = $typoScriptFrontendControllerMockObject;
        $this->subject->_set('typoScriptFrontendController', $typoScriptFrontendControllerMockObject);
 
        $this->assertEquals($expectedResult, $this->subject->typoLink($linkText, $configuration));
    }
 
    public function ‪typoLinkEncodesMailAddressForSpamProtection(
        array $settings,
        $linkText,
        $mailAddress,
        $expected
    ): void {
        $this->‪getFrontendController()->spamProtectEmailAddresses = $settings['spamProtectEmailAddresses'];
        $this->‪getFrontendController()->config['config'] = $settings;
        $typoScript = ['parameter' => $mailAddress];
 
        $this->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="javascript:linkTo_UnCryptMailto(%27nbjmup%2Btpnf%5C%2FcpezAuftu%5C%2Fuzqp4%5C%2Fpsh%27);">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="javascript:linkTo_UnCryptMailto(%27nbjmup%2Btpnf%5C%2FcpezAuftu%5C%2Fuzqp4%5C%2Fpsh%27);">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="javascript:linkTo_UnCryptMailto(%27nbjmup%2Btpnf%5C%2FcpezAuftu%5C%2Fuzqp4%5C%2Fpsh%27);">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="javascript:linkTo_UnCryptMailto(%27lzhksn9rnld-ancxZsdrs-sxon2-nqf%27);">some.body(at)test.typo3(dot)org</a>',
            ],
            'mono-alphabetic substitution offset 2 with at and dot substitution and encoded subject' => [
                [
                    'spamProtectEmailAddresses' => '2',
                    'spamProtectEmailAddresses_atSubst' => '(at)',
                    'spamProtectEmailAddresses_lastDotSubst' => '(dot)',
                ],
                'some.body@test.typo3.org',
                'mailto:some.body@test.typo3.org?subject=foo%20bar',
                '<a href="javascript:linkTo_UnCryptMailto(%27ocknvq%2Cuqog0dqfaBvguv0varq50qti%3Fuwdlgev%3Dhqq%2542dct%27);">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($linkText, $configuration, $expectedResult): void
    {
        $packageManagerMock = $this->getMockBuilder(PackageManager::class)
            ->disableOriginalConstructor()
            ->getMock();
        $templateServiceObjectMock = $this->getMockBuilder(TemplateService::class)
            ->setConstructorArgs([null, $packageManagerMock])
            ->setMethods(['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);
 
        $this->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(
        $linkText,
        $configuration,
        $absRefPrefix,
        $expectedResult
    ): void {
        $packageManagerMock = $this->getMockBuilder(PackageManager::class)
            ->disableOriginalConstructor()
            ->getMock();
        $templateServiceObjectMock = $this->getMockBuilder(TemplateService::class)
            ->setConstructorArgs([null, $packageManagerMock])
            ->setMethods(['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);
 
        $this->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);
 
        $this->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 ‪stdWrap_splitObjReturnsCount(): void
    {
        $conf = [
            'token' => ',',
            'returnCount' => 1
        ];
        $expectedResult = 5;
        $amountOfEntries = $this->subject->splitObj('1, 2, 3, 4, 5', $conf);
        $this->assertSame(
            $expectedResult,
            $amountOfEntries
        );
    }
 
    public function ‪calculateCacheKeyDataProvider(): array
    {
        $value = $this->getUniqueId('value');
        $wrap = [$this->getUniqueId('wrap')];
        $valueConf = ['key' => $value];
        $wrapConf = ['key.' => $wrap];
        $conf = array_merge($valueConf, $wrapConf);
        $will = $this->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, $with, $withWrap, $will): void
    {
        ‪$subject = $this->getAccessibleMock(ContentObjectRenderer::class, ['stdWrap']);
        ‪$subject->expects($this->exactly($times))
            ->method('stdWrap')
            ->with($with, $withWrap)
            ->willReturn($will);
 
        $result = ‪$subject->_call('calculateCacheKey', $conf);
        $this->assertSame($expect, $result);
    }
 
    public function ‪getFromCacheDtataProvider(): array
    {
        $conf = [$this->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, $conf, $cacheKey, $times, $cached): void
    {
        ‪$subject = $this->getAccessibleMock(
            ContentObjectRenderer::class,
            ['calculateCacheKey']
        );
        ‪$subject
            ->expects($this->exactly(1))
            ->method('calculateCacheKey')
            ->with($conf)
            ->willReturn($cacheKey);
        $cacheFrontend = $this->createMock(CacheFrontendInterface::class);
        $cacheFrontend
            ->expects($this->exactly($times))
            ->method('get')
            ->with($cacheKey)
            ->willReturn($cached);
        $cacheManager = $this->createMock(CacheManager::class);
        $cacheManager
            ->method('getCache')
            ->willReturn($cacheFrontend);
        GeneralUtility::setSingletonInstance(
            CacheManager::class,
            $cacheManager
        );
        $this->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);
        $this->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
    {
        $this->assertSame(
            $expect,
            $this->subject->caseshift($content, $case)
        );
    }
 
    public function ‪HTMLcaseshiftDataProvider(): array
    {
        $case = $this->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)
            ->setMethods(['caseshift'])->getMock();
        ‪$subject
            ->expects($this->exactly(count($with)))
            ->method('caseshift')
            ->withConsecutive(...$with)
            ->will($this->onConsecutiveCalls(...$will));
        $this->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 += 1;
            } else {
                $notCallable += 1;
            }
        }
        $this->assertSame(1, $notCallable);
        $this->assertSame(86, $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', 'split', 'bytes'];
        $count = 0;
        $processors = [];
        $exceptions = [];
        foreach (array_keys($this->subject->_get('stdWrapOrder')) as $key) {
            $processors[] = strtr($key, ['.' => '']);
        }
        foreach (array_unique($processors) as $processor) {
            $count += 1;
            try {
                $conf = [$processor => '', $processor . '.' => ['table' => 'tt_content']];
                $method = 'stdWrap_' . $processor;
                $this->subject->$method('', $conf);
            } catch (\Exception $e) {
                $exceptions[] = $processor;
            }
        }
        $this->assertSame($expectExceptions, $exceptions);
        $this->assertSame(86, $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 = [$this->getUniqueId('conf')];
        $content = $this->getUniqueId('content');
        $processed1 = $this->getUniqueId('processed1');
        $processed2 = $this->getUniqueId('processed2');
        $hookObject1 = $this->createMock(
            ContentObjectStdWrapHookInterface::class
        );
        $hookObject1->expects($this->once())
            ->method($hookObjectCall)
            ->with($content, $conf)
            ->willReturn($processed1);
        $hookObject2 = $this->createMock(
            ContentObjectStdWrapHookInterface::class
        );
        $hookObject2->expects($this->once())
            ->method($hookObjectCall)
            ->with($processed1, $conf)
            ->willReturn($processed2);
        $this->subject->_set(
            'stdWrapHookObjects',
            [$hookObject1, $hookObject2]
        );
        $result = $this->subject->$stdWrapMethod($content, $conf);
        $this->assertSame($processed2, $result);
    }
 
    public function ‪stdWrap_HTMLparserDataProvider(): array
    {
        $content = $this->getUniqueId('content');
        $parsed = $this->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)
            ->setMethods(['HTMLparser_TSbridge'])->getMock();
        ‪$subject
            ->expects($this->exactly($times))
            ->method('HTMLparser_TSbridge')
            ->with($content, $conf['HTMLparser.'] ?? [])
            ->willReturn($will);
        $this->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);
        $this->assertEquals($expectedTags, $this->frontendControllerMock->_get('pageCacheTags'));
    }
 
    public function ‪stdWrap_age(): void
    {
        $now = 10;
        $content = '9';
        $conf = ['age' => $this->getUniqueId('age')];
        $return = $this->getUniqueId('return');
        $difference = $now - (int)$content;
        ‪$GLOBALS['EXEC_TIME'] = $now;
        ‪$subject = $this->getMockBuilder(ContentObjectRenderer::class)
            ->setMethods(['calcAge'])->getMock();
        ‪$subject
            ->expects($this->once())
            ->method('calcAge')
            ->with($difference, $conf['age'])
            ->willReturn($return);
        $this->assertSame($return, ‪$subject->‪stdWrap_age($content, $conf));
    }
 
    public function ‪stdWrap_append(): void
    {
        $debugKey = '/stdWrap/.append';
        $content = $this->getUniqueId('content');
        $conf = [
            'append' => $this->getUniqueId('append'),
            'append.' => [$this->getUniqueId('append.')],
        ];
        $return = $this->getUniqueId('return');
        ‪$subject = $this->getMockBuilder(ContentObjectRenderer::class)
            ->setMethods(['cObjGetSingle'])->getMock();
        ‪$subject
            ->expects($this->once())
            ->method('cObjGetSingle')
            ->with($conf['append'], $conf['append.'], $debugKey)
            ->willReturn($return);
        $this->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($expected, $input, $xhtmlDoctype): void
    {
        ‪$GLOBALS['TSFE']->xhtmlDoctype = $xhtmlDoctype;
        $this->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
    {
        $this->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],
            ]
        ];
    }
 
    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) {
            $this->markTestSkipped('Locale ' . $locale . ' is not available.');
        }
        $conf = ['bytes.' => $conf];
        $this->assertSame(
            $expect,
            $this->subject->stdWrap_bytes($content, $conf)
        );
    }
 
    public function ‪stdWrap_cObject(): void
    {
        $debugKey = '/stdWrap/.cObject';
        $content = $this->getUniqueId('content');
        $conf = [
            'cObject' => $this->getUniqueId('cObject'),
            'cObject.' => [$this->getUniqueId('cObject.')],
        ];
        $return = $this->getUniqueId('return');
        ‪$subject = $this->getMockBuilder(ContentObjectRenderer::class)
            ->setMethods(['cObjGetSingle'])->getMock();
        ‪$subject
            ->expects($this->once())
            ->method('cObjGetSingle')
            ->with($conf['cObject'], $conf['cObject.'], $debugKey)
            ->willReturn($return);
        $this->assertSame(
            $return,
            ‪$subject->‪stdWrap_cObject($content, $conf)
        );
    }
 
    public function ‪stdWrap_orderedStdWrapDataProvider(): array
    {
        $confA = [$this->getUniqueId('conf A')];
        $confB = [$this->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($firstConf, array $secondConf, array $conf): void
    {
        $content = $this->getUniqueId('content');
        $between = $this->getUniqueId('between');
        $expect = $this->getUniqueId('expect');
        $conf['orderedStdWrap.'] = $conf;
        ‪$subject = $this->getMockBuilder(ContentObjectRenderer::class)
            ->setMethods(['stdWrap'])->getMock();
        ‪$subject
            ->expects($this->exactly(2))
            ->method('stdWrap')
            ->withConsecutive([$content, $firstConf], [$between, $secondConf])
            ->will($this->onConsecutiveCalls($between, $expect));
        $this->assertSame(
            $expect,
            ‪$subject->‪stdWrap_orderedStdWrap($content, $conf)
        );
    }
 
    public function ‪stdWrap_cacheReadDataProvider(): array
    {
        $cacheConf = [$this->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,
        $with,
        $will
    ): void {
        ‪$subject = $this->getAccessibleMock(
            ContentObjectRenderer::class,
            ['getFromCache']
        );
        ‪$subject
            ->expects($this->exactly($times))
            ->method('getFromCache')
            ->with($with)
            ->willReturn($will);
        $this->assertSame(
            $expect,
            ‪$subject->‪stdWrap_cacheRead($input, $conf)
        );
    }
 
    public function ‪stdWrap_cacheStoreDataProvider(): array
    {
        $confCache = [$this->getUniqueId('cache.')];
        $key = [$this->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(
        $confCache,
        int $timesCCK,
        $key,
        int $times
    ): void {
        $content = $this->getUniqueId('content');
        $conf['cache.'] = $confCache;
        $tags = [$this->getUniqueId('tags')];
        $lifetime = $this->getUniqueId('lifetime');
        $params = [
            'key' => $key,
            'content' => $content,
            'lifetime' => $lifetime,
            'tags' => $tags
        ];
        ‪$subject = $this->getAccessibleMock(
            ContentObjectRenderer::class,
            [
                'calculateCacheKey',
                'calculateCacheTags',
                'calculateCacheLifetime'
            ]
        );
        ‪$subject
            ->expects($this->exactly($timesCCK))
            ->method('calculateCacheKey')
            ->with($confCache)
            ->willReturn($key);
        ‪$subject
            ->expects($this->exactly($times))
            ->method('calculateCacheTags')
            ->with($confCache)
            ->willReturn($tags);
        ‪$subject
            ->expects($this->exactly($times))
            ->method('calculateCacheLifetime')
            ->with($confCache)
            ->willReturn($lifetime);
        $cacheFrontend = $this->createMock(CacheFrontendInterface::class);
        $cacheFrontend
            ->expects($this->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
        );
        list($countCalls, $test) = [0, $this];
        $closure = 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
        ];
        $this->assertSame(
            $content,
            ‪$subject->‪stdWrap_cacheStore($content, $conf)
        );
        $this->assertSame($times * 3, $countCalls);
    }
 
    public function ‪stdWrap_case(): void
    {
        $content = $this->getUniqueId();
        $conf = [
            'case' => $this->getUniqueId('used'),
            'case.' => [$this->getUniqueId('discarded')],
        ];
        $return = $this->getUniqueId();
        ‪$subject = $this->getMockBuilder(ContentObjectRenderer::class)
            ->setMethods(['HTMLcaseshift'])->getMock();
        ‪$subject
            ->expects($this->once())
            ->method('HTMLcaseshift')
            ->with($content, $conf['case'])
            ->willReturn($return);
        $this->assertSame(
            $return,
            ‪$subject->‪stdWrap_case($content, $conf)
        );
    }
 
    public function ‪stdWrap_char(): void
    {
        $input = 'discarded';
        $expected = 'C';
        $this->assertEquals($expected, $this->subject->stdWrap_char($input, ['char' => '67']));
    }
 
    public function ‪stdWrap_crop(): void
    {
        $content = $this->getUniqueId('content');
        $conf = [
            'crop' => $this->getUniqueId('crop'),
            'crop.' => $this->getUniqueId('not used'),
        ];
        $return = $this->getUniqueId('return');
        ‪$subject = $this->getMockBuilder(ContentObjectRenderer::class)
            ->setMethods(['crop'])->getMock();
        ‪$subject
            ->expects($this->once())
            ->method('crop')
            ->with($content, $conf['crop'])
            ->willReturn($return);
        $this->assertSame(
            $return,
            ‪$subject->‪stdWrap_crop($content, $conf)
        );
    }
 
    public function ‪stdWrap_cropHTML(): void
    {
        $content = $this->getUniqueId('content');
        $conf = [
            'cropHTML' => $this->getUniqueId('cropHTML'),
            'cropHTML.' => $this->getUniqueId('not used'),
        ];
        $return = $this->getUniqueId('return');
        ‪$subject = $this->getMockBuilder(ContentObjectRenderer::class)
            ->setMethods(['cropHTML'])->getMock();
        ‪$subject
            ->expects($this->once())
            ->method('cropHTML')
            ->with($content, $conf['cropHTML'])
            ->willReturn($return);
        $this->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
    {
        $this->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);
        $this->assertSame(
            'currentValue_kidjls9dksoje',
            $this->subject->_get('currentValKey')
        );
        $this->assertSame(
            'default',
            $this->subject->stdWrap_current('discarded', ['discarded'])
        );
        $this->subject->_set('currentValKey', 'currentValue_new');
        $this->assertSame(
            'new',
            $this->subject->stdWrap_current('discarded', ['discarded'])
        );
    }
 
    public function ‪stdWrap_dataDataProvider(): array
    {
        $data = [$this->getUniqueId('data')];
        $alt = [$this->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' => $this->getUniqueId('conf.data')];
        $return = $this->getUniqueId('return');
        ‪$subject = $this->getAccessibleMock(
            ContentObjectRenderer::class,
            ['getData']
        );
        ‪$subject->_set('data', $data);
        ‪$subject->_set('alternativeData', $alt);
        ‪$subject
            ->expects($this->once())
            ->method('getData')
            ->with($conf['data'], $expect)
            ->willReturn($return);
        $this->assertSame($return, ‪$subject->‪stdWrap_data('discard', $conf));
        $this->assertSame('', ‪$subject->_get('alternativeData'));
    }
 
    public function ‪stdWrap_dataWrap(): void
    {
        $content = $this->getUniqueId('content');
        $conf = [
            'dataWrap' => $this->getUniqueId('dataWrap'),
            'dataWrap.' => [$this->getUniqueId('not used')],
        ];
        $return = $this->getUniqueId('return');
        ‪$subject = $this->getMockBuilder(ContentObjectRenderer::class)
            ->setMethods(['dataWrap'])->getMock();
        ‪$subject
            ->expects($this->once())
            ->method('dataWrap')
            ->with($content, $conf['dataWrap'])
            ->willReturn($return);
        $this->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;
        $this->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>';
        $this->assertSame($expect, $this->subject->stdWrap_debug($content));
    }
 
    public function ‪stdWrap_debugData(): void
    {
        ‪$GLOBALS['TYPO3_CONF_VARS']['SYS']['devIPmask'] = '*';
        $content = $this->getUniqueId('content');
        $key = $this->getUniqueId('key');
        $value = $this->getUniqueId('value');
        $altValue = $this->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();
        $this->assertSame($result, $content);
        $this->assertContains('$cObj->data', $out);
        $this->assertContains($value, $out);
        $this->assertNotContains($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();
        $this->assertNotContains('$cObj->alternativeData', $out);
        $this->assertContains($value, $out);
        $this->assertContains($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 = $this->getUniqueId('content');
        $conf = ['debugFunc' => $confDebugFunc];
        ob_start();
        $result = $this->subject->stdWrap_debugFunc($content, $conf);
        $out = ob_get_clean();
        $this->assertSame($result, $content);
        $this->assertContains($content, $out);
        if ($expectArray) {
            $this->assertContains('=>', $out);
        } else {
            $this->assertNotContains('=>', $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
    {
        $this->assertEquals($expected, $this->subject->stdWrap_doubleBrTag($input, $config));
    }
 
    public function ‪stdWrap_editIconsDataProvider(): array
    {
        $content = $this->getUniqueId('content');
        $editIcons = $this->getUniqueId('editIcons');
        $editIconsArray = [$this->getUniqueId('editIcons.')];
        $will = $this->getUniqueId('will');
        return [
            'standard case calls edit icons' => [
                $will,
                $content,
                ['editIcons' => $editIcons, 'editIcons.' => $editIconsArray],
                true,
                1,
                $editIconsArray,
                $will
            ],
            'null in editIcons. repalaced by []' => [
                $will,
                $content,
                ['editIcons' => $editIcons, 'editIcons.' => null],
                true,
                1,
                [],
                $will
            ],
            'missing editIcons. replaced by []' => [
                $will,
                $content,
                ['editIcons' => $editIcons],
                true,
                1,
                [],
                $will
            ],
            'no user login disables call' => [
                $content,
                $content,
                ['editIcons' => $editIcons, 'editIcons.' => $editIconsArray],
                false,
                0,
                $editIconsArray,
                $will
            ],
            'empty string in editIcons disables call' => [
                $content,
                $content,
                ['editIcons' => '', 'editIcons.' => $editIconsArray],
                true,
                0,
                $editIconsArray,
                $will
            ],
            'zero string in editIcons disables call' => [
                $content,
                $content,
                ['editIcons' => '0', 'editIcons.' => $editIconsArray],
                true,
                0,
                $editIconsArray,
                $will
            ],
        ];
    }
 
    public function ‪stdWrap_editIcons(
        string $expect,
        string $content,
        array $conf,
        bool $login,
        int $times,
        array $param3,
        string $will
    ): void {
        if ($login) {
            $backendUser = new ‪BackendUserAuthentication();
            $backendUser->user['uid'] = 13;
            GeneralUtility::makeInstance(Context::class)->setAspect('backend.user', new ‪UserAspect($backendUser));
        } else {
            GeneralUtility::makeInstance(Context::class)->setAspect('backend.user', new UserAspect());
        }
        ‪$subject = $this->getMockBuilder(ContentObjectRenderer::class)
            ->setMethods(['editIcons'])->getMock();
        ‪$subject
            ->expects($this->exactly($times))
            ->method('editIcons')
            ->with($content, $conf['editIcons'], $param3)
            ->willReturn($will);
        $this->assertSame(
            $expect,
            ‪$subject->‪stdWrap_editIcons($content, $conf)
        );
    }
 
    public function ‪stdWrap_encapsLines(): void
    {
        $content = $this->getUniqueId('content');
        $conf = [
            'encapsLines' => [$this->getUniqueId('not used')],
            'encapsLines.' => [$this->getUniqueId('encapsLines.')],
        ];
        $return = $this->getUniqueId('return');
        ‪$subject = $this->getMockBuilder(ContentObjectRenderer::class)
            ->setMethods(['encaps_lineSplit'])->getMock();
        ‪$subject
            ->expects($this->once())
            ->method('encaps_lineSplit')
            ->with($content, $conf['encapsLines.'])
            ->willReturn($return);
        $this->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);
        $this->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_editPanelDataProvider(): array
    {
        $content = $this->getUniqueId('content');
        $will = $this->getUniqueId('will');
        return [
            'standard case calls edit icons' => [
                $will,
                $content,
                true,
                1,
                $will
            ],
            'no user login disables call' => [
                $content,
                $content,
                false,
                0,
                $will
            ],
        ];
    }
 
    public function ‪stdWrap_editPanel(
        string $expect,
        string $content,
        bool $login,
        int $times,
        string $will
    ): void {
        if ($login) {
            $backendUser = new ‪BackendUserAuthentication();
            $backendUser->user['uid'] = 13;
            GeneralUtility::makeInstance(Context::class)->setAspect('backend.user', new ‪UserAspect($backendUser));
        } else {
            GeneralUtility::makeInstance(Context::class)->setAspect('backend.user', new UserAspect());
        }
        $conf = ['editPanel.' => [$this->getUniqueId('editPanel.')]];
        ‪$subject = $this->getMockBuilder(ContentObjectRenderer::class)
            ->setMethods(['editPanel'])->getMock();
        ‪$subject
            ->expects($this->exactly($times))
            ->method('editPanel')
            ->with($content, $conf['editPanel.'])
            ->willReturn($will);
        $this->assertSame(
            $expect,
            ‪$subject->‪stdWrap_editPanel($content, $conf)
        );
    }
 
    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
    {
        $this->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
    {
        $this->assertEquals(
            $expected,
            $this->subject->stdWrap_expandList($content)
        );
    }
 
    public function ‪stdWrap_field(): void
    {
        $expect = $this->getUniqueId('expect');
        $conf = ['field' => $this->getUniqueId('field')];
        ‪$subject = $this->getMockBuilder(ContentObjectRenderer::class)
            ->setMethods(['getFieldVal'])->getMock();
        ‪$subject
            ->expects($this->once())
            ->method('getFieldVal')
            ->with($conf['field'])
            ->willReturn($expect);
        $this->assertSame(
            $expect,
            ‪$subject->‪stdWrap_field('discarded', $conf)
        );
    }
 
    public function ‪stdWrap_fieldRequiredDataProvider(): array
    {
        $content = $this->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]);
        $this->assertSame(
            $expect,
            ‪$subject->‪stdWrap_fieldRequired($content, $conf)
        );
        $this->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
    {
        $this->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
    {
        $this->assertSame(
            $expected,
            $this->subject->stdWrap_htmlSpecialChars($input, $conf)
        );
    }
 
    public function ‪stdWrap_ifDataProvider(): array
    {
        $content = $this->getUniqueId('content');
        $conf = ['if.' => [$this->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, $will): void
    {
        ‪$subject = $this->getAccessibleMock(
            ContentObjectRenderer::class,
            ['checkIf']
        );
        ‪$subject->_set('stdWrapRecursionLevel', 1);
        ‪$subject->_set('stopRendering', [1 => false]);
        ‪$subject
            ->expects($this->exactly($times))
            ->method('checkIf')
            ->with($conf['if.'] ?? null)
            ->willReturn($will);
        $this->assertSame($expect, ‪$subject->‪stdWrap_if($content, $conf));
        $this->assertSame($stop, ‪$subject->_get('stopRendering')[1]);
    }
 
    public function ‪stdWrap_ifBlankDataProvider(): array
    {
        $alt = $this->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);
        $this->assertSame($expect, $result);
    }
 
    public function ‪stdWrap_ifEmptyDataProvider(): array
    {
        $alt = $this->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);
        $this->assertSame($expect, $result);
    }
 
    public function ‪stdWrap_ifNullDataProvider(): array
    {
        $alt = $this->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 is not null' => [0, 0, $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);
        $this->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
    {
        $this->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
    {
        $this->assertSame(
            $expected,
            $this->subject->stdWrap_innerWrap2($input, $conf)
        );
    }
 
    public function ‪stdWrap_insertData(): void
    {
        $content = $this->getUniqueId('content');
        $conf = [$this->getUniqueId('conf not used')];
        $return = $this->getUniqueId('return');
        ‪$subject = $this->getMockBuilder(ContentObjectRenderer::class)
            ->setMethods(['insertData'])->getMock();
        ‪$subject->expects($this->once())->method('insertData')
            ->with($content)->willReturn($return);
        $this->assertSame(
            $return,
            ‪$subject->‪stdWrap_insertData($content, $conf)
        );
    }
 
    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
    {
        $this->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
    {
        $this->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
    {
        $this->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_langViaTSFE(string $expected, string $input, array $conf, string $language): void
    {
        if ($language) {
            $this->frontendControllerMock
                ->config['config']['language'] = $language;
        }
        $this->assertSame(
            $expected,
            $this->subject->stdWrap_lang($input, $conf)
        );
    }
 
    public function ‪stdWrap_langViaSiteLanguage(string $expected, string $input, array $conf, string $language): void
    {
        if ($language) {
            $site = $this->‪createSiteWithLanguage([
                'base' => '/',
                'languageId' => 2,
                'locale' => 'en_UK',
                'typo3Language' => $language,
            ]);
            $request = new ServerRequest();
            ‪$GLOBALS['TYPO3_REQUEST'] = $request->withAttribute(
                'language',
                $site->getLanguageById(2)
            );
        }
        $this->assertSame(
            $expected,
            $this->subject->stdWrap_lang($input, $conf)
        );
    }
 
    public function ‪stdWrap_listNum(): void
    {
        $content = $this->getUniqueId('content');
        $conf = [
            'listNum' => $this->getUniqueId('listNum'),
            'listNum.' => [
                'splitChar' => $this->getUniqueId('splitChar')
            ],
        ];
        $return = $this->getUniqueId('return');
        ‪$subject = $this->getMockBuilder(ContentObjectRenderer::class)
            ->setMethods(['listNum'])->getMock();
        ‪$subject
            ->expects($this->once())
            ->method('listNum')
            ->with(
                $content,
                $conf['listNum'],
                $conf['listNum.']['splitChar']
            )
            ->willReturn($return);
        $this->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
    {
        $this->assertSame(
            $expect,
            $this->subject->stdWrap_noTrimWrap($content, $conf)
        );
    }
 
    public function ‪stdWrap_numRows(): void
    {
        $conf = [
            'numRows' => $this->getUniqueId('numRows'),
            'numRows.' => [$this->getUniqueId('numRows')],
        ];
        ‪$subject = $this->getMockBuilder(ContentObjectRenderer::class)
            ->setMethods(['numRows'])->getMock();
        ‪$subject->expects($this->once())->method('numRows')
            ->with($conf['numRows.'])->willReturn('return');
        $this->assertSame(
            'return',
            ‪$subject->‪stdWrap_numRows('discard', $conf)
        );
    }
 
    public function ‪stdWrap_numberFormat(): void
    {
        $content = $this->getUniqueId('content');
        $conf = [
            'numberFormat' => $this->getUniqueId('not used'),
            'numberFormat.' => [$this->getUniqueId('numberFormat.')],
        ];
        $return = $this->getUniqueId('return');
        ‪$subject = $this->getMockBuilder(ContentObjectRenderer::class)
            ->setMethods(['numberFormat'])->getMock();
        ‪$subject
            ->expects($this->once())
            ->method('numberFormat')
            ->with($content, $conf['numberFormat.'])
            ->willReturn($return);
        $this->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
    {
        $this->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
    {
        $this->assertSame(
            $expect,
            $this->subject->stdWrap_override($content, $conf)
        );
    }
 
    public function ‪stdWrap_parseFunc(): void
    {
        $content = $this->getUniqueId('content');
        $conf = [
            'parseFunc' => $this->getUniqueId('parseFunc'),
            'parseFunc.' => [$this->getUniqueId('parseFunc.')],
        ];
        $return = $this->getUniqueId('return');
        ‪$subject = $this->getMockBuilder(ContentObjectRenderer::class)
            ->setMethods(['parseFunc'])->getMock();
        ‪$subject
            ->expects($this->once())
            ->method('parseFunc')
            ->with($content, $conf['parseFunc.'], $conf['parseFunc'])
            ->willReturn($return);
        $this->assertSame(
            $return,
            ‪$subject->‪stdWrap_parseFunc($content, $conf)
        );
    }
 
    public function ‪stdWrap_postCObject(): void
    {
        $debugKey = '/stdWrap/.postCObject';
        $content = $this->getUniqueId('content');
        $conf = [
            'postCObject' => $this->getUniqueId('postCObject'),
            'postCObject.' => [$this->getUniqueId('postCObject.')],
        ];
        $return = $this->getUniqueId('return');
        ‪$subject = $this->getMockBuilder(ContentObjectRenderer::class)
            ->setMethods(['cObjGetSingle'])->getMock();
        ‪$subject
            ->expects($this->once())
            ->method('cObjGetSingle')
            ->with($conf['postCObject'], $conf['postCObject.'], $debugKey)
            ->willReturn($return);
        $this->assertSame(
            $content . $return,
            ‪$subject->‪stdWrap_postCObject($content, $conf)
        );
    }
 
    public function ‪stdWrap_postUserFunc(): void
    {
        $content = $this->getUniqueId('content');
        $conf = [
            'postUserFunc' => $this->getUniqueId('postUserFunc'),
            'postUserFunc.' => [$this->getUniqueId('postUserFunc.')],
        ];
        $return = $this->getUniqueId('return');
        ‪$subject = $this->getMockBuilder(ContentObjectRenderer::class)
            ->setMethods(['callUserFunction'])->getMock();
        ‪$subject
            ->expects($this->once())
            ->method('callUserFunction')
            ->with($conf['postUserFunc'], $conf['postUserFunc.'])
            ->willReturn($return);
        $this->assertSame(
            $return,
            ‪$subject->‪stdWrap_postUserFunc($content, $conf)
        );
    }
 
    public function ‪stdWrap_postUserFuncInt(): void
    {
        $uniqueHash = $this->getUniqueId('uniqueHash');
        $substKey = 'INT_SCRIPT.' . $uniqueHash;
        $content = $this->getUniqueId('content');
        $conf = [
            'postUserFuncInt' => $this->getUniqueId('function'),
            'postUserFuncInt.' => [$this->getUniqueId('function array')],
        ];
        $expect = '<!--' . $substKey . '-->';
        $frontend = $this->getMockBuilder(TypoScriptFrontendController::class)
            ->disableOriginalConstructor()->setMethods(['uniqueHash'])
            ->getMock();
        $frontend->expects($this->once())->method('uniqueHash')
            ->with()->willReturn($uniqueHash);
        $frontend->config = [];
        ‪$subject = $this->getAccessibleMock(
            ContentObjectRenderer::class,
            null,
            [$frontend]
        );
        $this->assertSame(
            $expect,
            ‪$subject->‪stdWrap_postUserFuncInt($content, $conf)
        );
        $array = [
            'content' => $content,
            'postUserFunc' => $conf['postUserFuncInt'],
            'conf' => $conf['postUserFuncInt.'],
            'type' => 'POSTUSERFUNC',
            'cObj' => serialize(‪$subject)
        ];
        $this->assertSame(
            $array,
            $frontend->config['INTincScript'][$substKey]
        );
    }
 
    public function ‪stdWrap_preCObject(): void
    {
        $debugKey = '/stdWrap/.preCObject';
        $content = $this->getUniqueId('content');
        $conf = [
            'preCObject' => $this->getUniqueId('preCObject'),
            'preCObject.' => [$this->getUniqueId('preCObject.')],
        ];
        $return = $this->getUniqueId('return');
        ‪$subject = $this->getMockBuilder(ContentObjectRenderer::class)
            ->setMethods(['cObjGetSingle'])->getMock();
        ‪$subject
            ->expects($this->once())
            ->method('cObjGetSingle')
            ->with($conf['preCObject'], $conf['preCObject.'], $debugKey)
            ->willReturn($return);
        $this->assertSame(
            $return . $content,
            ‪$subject->‪stdWrap_preCObject($content, $conf)
        );
    }
 
    public function ‪stdWrap_preIfEmptyListNum(): void
    {
        $content = $this->getUniqueId('content');
        $conf = [
            'preIfEmptyListNum' => $this->getUniqueId('preIfEmptyListNum'),
            'preIfEmptyListNum.' => [
                'splitChar' => $this->getUniqueId('splitChar')
            ],
        ];
        $return = $this->getUniqueId('return');
        ‪$subject = $this->getMockBuilder(ContentObjectRenderer::class)
            ->setMethods(['listNum'])->getMock();
        ‪$subject
            ->expects($this->once())
            ->method('listNum')
            ->with(
                $content,
                $conf['preIfEmptyListNum'],
                $conf['preIfEmptyListNum.']['splitChar']
            )
            ->willReturn($return);
        $this->assertSame(
            $return,
            ‪$subject->‪stdWrap_preIfEmptyListNum($content, $conf)
        );
    }
 
    public function ‪stdWrap_prefixCommentDataProvider(): array
    {
        $content = $this->getUniqueId('content');
        $will = $this->getUniqueId('will');
        $conf['prefixComment'] = $this->getUniqueId('prefixComment');
        $emptyConf1 = [];
        $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)
            ->setMethods(['prefixComment'])->getMock();
        ‪$subject
            ->expects($this->exactly($times))
            ->method('prefixComment')
            ->with($conf['prefixComment'] ?? null, [], $content)
            ->willReturn($will);
        $this->assertSame(
            $expect,
            ‪$subject->‪stdWrap_prefixComment($content, $conf)
        );
    }
 
    public function ‪stdWrap_prepend(): void
    {
        $debugKey = '/stdWrap/.prepend';
        $content = $this->getUniqueId('content');
        $conf = [
            'prepend' => $this->getUniqueId('prepend'),
            'prepend.' => [$this->getUniqueId('prepend.')],
        ];
        $return = $this->getUniqueId('return');
        ‪$subject = $this->getMockBuilder(ContentObjectRenderer::class)
            ->setMethods(['cObjGetSingle'])->getMock();
        ‪$subject
            ->expects($this->once())
            ->method('cObjGetSingle')
            ->with($conf['prepend'], $conf['prepend.'], $debugKey)
            ->willReturn($return);
        $this->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);
        $this->assertSame($expect, $result);
    }
 
    public function ‪stdWrap_preUserFunc(): void
    {
        $content = $this->getUniqueId('content');
        $conf = [
            'preUserFunc' => $this->getUniqueId('preUserFunc'),
            'preUserFunc.' => [$this->getUniqueId('preUserFunc.')],
        ];
        ‪$subject = $this->getMockBuilder(ContentObjectRenderer::class)
            ->setMethods(['callUserFunction'])->getMock();
        ‪$subject->expects($this->once())->method('callUserFunction')
            ->with($conf['preUserFunc'], $conf['preUserFunc.'], $content)
            ->willReturn('return');
        $this->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
    {
        $this->assertSame(
            $expect,
            $this->subject->stdWrap_rawUrlEncode($content)
        );
    }
 
    public function ‪stdWrap_replacement(): void
    {
        $content = $this->getUniqueId('content');
        $conf = [
            'replacement' => $this->getUniqueId('not used'),
            'replacement.' => [$this->getUniqueId('replacement.')],
        ];
        $return = $this->getUniqueId('return');
        ‪$subject = $this->getMockBuilder(ContentObjectRenderer::class)
            ->setMethods(['replacement'])->getMock();
        ‪$subject
            ->expects($this->once())
            ->method('replacement')
            ->with($content, $conf['replacement.'])
            ->willReturn($return);
        $this->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]);
        $this->assertSame($expect, ‪$subject->‪stdWrap_required($content));
        $this->assertSame($stop, ‪$subject->_get('stopRendering')[1]);
    }
 
    public function ‪stdWrap_round(): void
    {
        $content = $this->getUniqueId('content');
        $conf = [
            'round' => $this->getUniqueId('not used'),
            'round.' => [$this->getUniqueId('round.')],
        ];
        $return = $this->getUniqueId('return');
        ‪$subject = $this->getMockBuilder(ContentObjectRenderer::class)
            ->setMethods(['round'])->getMock();
        ‪$subject
            ->expects($this->once())
            ->method('round')
            ->with($content, $conf['round.'])
            ->willReturn($return);
        $this->assertSame($return, ‪$subject->‪stdWrap_round($content, $conf));
    }
 
    public function ‪stdWrap_setContentToCurrent(): void
    {
        $content = $this->getUniqueId('content');
        $this->assertNotSame($content, $this->subject->getData('current'));
        $this->assertSame(
            $content,
            $this->subject->stdWrap_setContentToCurrent($content)
        );
        $this->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'])) {
            $this->assertNotSame($conf['setCurrent'], $this->subject->getData('current'));
        }
        $this->assertSame($input, $this->subject->stdWrap_setCurrent($input, $conf));
        if (isset($conf['setCurrent'])) {
            $this->assertSame($conf['setCurrent'], $this->subject->getData('current'));
        }
    }
 
    public function ‪stdWrap_split(): void
    {
        $content = $this->getUniqueId('content');
        $conf = [
            'split' => $this->getUniqueId('not used'),
            'split.' => [$this->getUniqueId('split.')],
        ];
        $return = $this->getUniqueId('return');
        ‪$subject = $this->getMockBuilder(ContentObjectRenderer::class)
            ->setMethods(['splitObj'])->getMock();
        ‪$subject
            ->expects($this->once())
            ->method('splitObj')
            ->with($content, $conf['split.'])
            ->willReturn($return);
        $this->assertSame(
            $return,
            ‪$subject->‪stdWrap_split($content, $conf)
        );
    }
 
    public function ‪stdWrap_stdWrap(): void
    {
        $content = $this->getUniqueId('content');
        $conf = [
            'stdWrap' => $this->getUniqueId('not used'),
            'stdWrap.' => [$this->getUniqueId('stdWrap.')],
        ];
        $return = $this->getUniqueId('return');
        ‪$subject = $this->getMockBuilder(ContentObjectRenderer::class)
            ->setMethods(['stdWrap'])->getMock();
        ‪$subject
            ->expects($this->once())
            ->method('stdWrap')
            ->with($content, $conf['stdWrap.'])
            ->willReturn($return);
        $this->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',
            ],
            'existing key and array returns stdWrap' => [
                'test',
                [
                    'test' => 'value',
                    'test.' => ['case' => 'upper'],
                ],
                'default',
                'VALUE'
            ],
        ];
    }
 
    public function ‪stdWrap_stdWrapValue(
        string $key,
        array $configuration,
        string $defaultValue,
        string $expected
    ): void {
        $result = $this->subject->stdWrapValue($key, $configuration, $defaultValue);
        $this->assertEquals($expected, $result);
    }
 
    public function ‪stdWrap_strPadDataProvider(): array
    {
        return [
            'pad string with default settings and length 10' => [
                'Alien     ',
                'Alien',
                [
                    '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 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);
        $this->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);
 
        $this->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!';
        $this->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);
 
        $this->assertEquals($expect, $result);
    }
 
    public function ‪stdWrap_substring(): void
    {
        $content = $this->getUniqueId('content');
        $conf = [
            'substring' => $this->getUniqueId('substring'),
            'substring.' => $this->getUniqueId('not used'),
        ];
        $return = $this->getUniqueId('return');
        ‪$subject = $this->getMockBuilder(ContentObjectRenderer::class)
            ->setMethods(['substring'])->getMock();
        ‪$subject
            ->expects($this->once())
            ->method('substring')
            ->with($content, $conf['substring'])
            ->willReturn($return);
        $this->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);
        $this->assertSame($expect, $result);
    }
 
    public function ‪stdWrap_typolink(): void
    {
        $content = $this->getUniqueId('content');
        $conf = [
            'typolink' => $this->getUniqueId('not used'),
            'typolink.' => [$this->getUniqueId('typolink.')],
        ];
        $return = $this->getUniqueId('return');
        ‪$subject = $this->getMockBuilder(ContentObjectRenderer::class)
            ->setMethods(['typolink'])->getMock();
        ‪$subject
            ->expects($this->once())
            ->method('typolink')
            ->with($content, $conf['typolink.'])
            ->willReturn($return);
        $this->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
    {
        $this->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
    {
        $this->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
    {
        $this->assertSame($expected, $this->subject->stdWrap_wrap3($input, $conf));
    }
 
    public function ‪stdWrap_wrapAlignDataProvider(): array
    {
        $format = '<div style="text-align:%s;">%s</div>';
        $content = $this->getUniqueId('content');
        $wrapAlign = $this->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;
        }
        $this->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
    {
        $this->assertEquals('tt_content', $this->subject->getCurrentTable());
    }
 
    public function ‪linkWrapDataProvider(): array
    {
        $content = $this->getUniqueId();
        return [
            'Handles a tag as wrap.' => [
                '<tag>' . $content . '</tag>',
                $content,
                '<tag>|</tag>'
            ],
            'Handles simple text as wrap.' => [
                'alpha' . $content . 'omega',
                $content,
                'alpha|omega'
            ],
            'Trims whitespace around tags.' => [
                '<tag>' . $content . '</tag>',
                $content,
                "\t <tag>\t |\t </tag>\t "
            ],
            'A wrap without pipe is placed before the content.' => [
                '<tag>' . $content,
                $content,
                '<tag>'
            ],
            'For an empty string as wrap the content is returned as is.' => [
                $content,
                $content,
                ''
            ],
            'For null as wrap the content is returned as is.' => [
                $content,
                $content,
                null
            ],
            'For a valid rootline level the uid will be inserted.' => [
                '<a href="?id=55">' . $content . '</a>',
                $content,
                '<a href="?id={3}"> | </a>'
            ],
            'For an invalid rootline level there is no replacement.' => [
                '<a href="?id={4}">' . $content . '</a>',
                $content,
                '<a href="?id={4}"> | </a>'
            ],
        ];
    }
 
    public function ‪linkWrap(string $expected, string $content, $wrap): void
    {
        $this->templateServiceMock->rootLine = [3 => ['uid' => 55]];
        $actual = $this->subject->linkWrap($content, $wrap);
        $this->assertEquals($expected, $actual);
    }
 
    public function ‪prefixCommentDataProvider(): array
    {
        $comment = $this->getUniqueId();
        $content = $this->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);
        $this->assertEquals($expect, $result);
    }
 
    public function ‪setCurrentFile_getCurrentFile(): void
    {
        $storageMock = $this->createMock(ResourceStorage::class);
        $file = new ‪File(['testfile'], $storageMock);
        $this->subject->setCurrentFile($file);
        $this->assertSame($file, $this->subject->getCurrentFile());
    }
 
    public function ‪setCurrentVal_getCurrentVal(): void
    {
        $key = $this->getUniqueId();
        $value = $this->getUniqueId();
        $this->subject->currentValKey = $key;
        $this->subject->setCurrentVal($value);
        $this->assertEquals($value, $this->subject->getCurrentVal());
        $this->assertEquals($value, $this->subject->data[$key]);
    }
 
    public function ‪setUserObjectType_getUserObjectType(): void
    {
        $value = $this->getUniqueId();
        $this->subject->setUserObjectType($value);
        $this->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
    {
        $this->assertSame(
            $expected,
            $this->subject->_call('encryptEmail', $content, 'ascii')
        );
    }
 
    /***************************************************************************
     * End: Mixed tests
     ***************************************************************************/
 
    private function ‪createSiteWithLanguage(array $languageConfiguration): ‪Site
    {
        return new ‪Site('test', 1, [
            'identifier' => 'test',
            'rootPageId' => 1,
            'base' => '/',
            'languages' => [
                array_merge(
                    $languageConfiguration,
                    [
                        'base' => '/',
                    ]
                )
            ]
        ]);
    }
}