[!!!][TASK] Removed deprecated TYPO3\CMS\Extbase\Utility\ArrayUtility 10/52510/2
authorThomas Hohn <thomas@hohn.dk>
Thu, 20 Apr 2017 07:31:45 +0000 (09:31 +0200)
committerBenni Mack <benni@typo3.org>
Thu, 20 Apr 2017 09:04:47 +0000 (11:04 +0200)
Removed the class `TYPO3\CMS\Extbase\Utility\ArrayUtility`, since
it was deprecated with TYPO3 v8.

Resolves: #80701
Releases: master
Change-Id: I6b12c9f8a4bce015ef64686032961fd34bfd484c
Reviewed-on: https://review.typo3.org/52510
Tested-by: TYPO3com <no-reply@typo3.com>
Reviewed-by: Wouter Wolters <typo3@wouterwolters.nl>
Tested-by: Wouter Wolters <typo3@wouterwolters.nl>
Reviewed-by: Benni Mack <benni@typo3.org>
Tested-by: Benni Mack <benni@typo3.org>
typo3/sysext/core/Documentation/Changelog/master/Breaking-80700-DeprecatedFunctionalityRemoved.rst
typo3/sysext/extbase/Classes/Utility/ArrayUtility.php [deleted file]
typo3/sysext/extbase/Tests/Unit/Utility/ArrayUtilityTest.php [deleted file]

index 6978154..1a82de8 100644 (file)
@@ -18,6 +18,7 @@ The following PHP classes that have been previously deprecated for v8 have been
 * TYPO3\CMS\Core\Messaging\AbstractStandaloneMessage
 * TYPO3\CMS\Core\Messaging\ErrorpageMessage
 * TYPO3\CMS\Core\TimeTracker\NullTimeTracker
+* TYPO3\CMS\Extbase\Utility\ArrayUtility
 * TYPO3\CMS\Frontend\Page\FramesetRenderer
 * TYPO3\CMS\Lowlevel\CleanerCommand
 
diff --git a/typo3/sysext/extbase/Classes/Utility/ArrayUtility.php b/typo3/sysext/extbase/Classes/Utility/ArrayUtility.php
deleted file mode 100644 (file)
index 6d49c36..0000000
+++ /dev/null
@@ -1,368 +0,0 @@
-<?php
-namespace TYPO3\CMS\Extbase\Utility;
-
-/*
- * 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 TYPO3\CMS\Core\Utility\GeneralUtility;
-
-/**
- * The array functions from good old GeneralUtility plus new code.
- * This class has been deprecated as PHP's native functionality and the Core's own ArrayUtility
- * provides the same functionality.
- * Do not use it anymore, it will be removed in TYPO3 v9.
- *
- * @api
- */
-class ArrayUtility
-{
-    /**
-     * Explodes a $string delimited by $delimiter and casts each item in the array to (int).
-     * Corresponds to explode(), but with conversion to integers for all values.
-     *
-     * @param string $delimiter Delimiter string to explode with
-     * @param string $string The string to explode
-     * @return array Exploded values, all converted to integers
-     * @api
-     * @deprecated since TYPO3 v8, will be removed in TYPO3 v9, use GeneralUtility::intExplode()
-     */
-    public static function integerExplode($delimiter, $string)
-    {
-        GeneralUtility::logDeprecatedFunction();
-        $explodedValues = explode($delimiter, $string);
-        foreach ($explodedValues as &$value) {
-            $value = (int)$value;
-        }
-        unset($value);
-        return $explodedValues;
-    }
-
-    /**
-     * Explodes a string and trims all values for whitespace in the ends.
-     * If $onlyNonEmptyValues is set, then all blank ('') values are removed.
-     *
-     * @param string $delimiter Delimiter string to explode with
-     * @param string $string The string to explode
-     * @param bool $onlyNonEmptyValues If set, all empty values (='') will NOT be set in output
-     * @return array Exploded values
-     * @api
-     * @deprecated since TYPO3 v8, will be removed in TYPO3 v9, use GeneralUtility::trimExplode() instead
-     */
-    public static function trimExplode($delimiter, $string, $onlyNonEmptyValues = false)
-    {
-        GeneralUtility::logDeprecatedFunction();
-        $chunksArr = explode($delimiter, $string);
-        $newChunksArr = [];
-        foreach ($chunksArr as $value) {
-            if ($onlyNonEmptyValues === false || trim($value) !== '') {
-                $newChunksArr[] = trim($value);
-            }
-        }
-        reset($newChunksArr);
-        return $newChunksArr;
-    }
-
-    /**
-     * Merges two arrays recursively and "binary safe" (integer keys are overridden as well), overruling similar values in the first array ($firstArray) with the values of the second array ($secondArray)
-     * In case of identical keys, ie. keeping the values of the second.
-     *
-     * @param array $firstArray First array
-     * @param array $secondArray Second array, overruling the first array
-     * @param bool $dontAddNewKeys If set, keys that are NOT found in $firstArray (first array) will not be set. Thus only existing value can/will be overruled from second array.
-     * @param bool $emptyValuesOverride If set (which is the default), values from $secondArray will overrule if they are empty (according to PHP's empty() function)
-     * @return array Resulting array where $secondArray values has overruled $firstArray values
-     * @api
-     * @deprecated since TYPO3 v8, will be removed in TYPO3 v9, use array_replace_recursive() instead if possible, other see the ArrayUtility in EXT:core
-     */
-    public static function arrayMergeRecursiveOverrule(array $firstArray, array $secondArray, $dontAddNewKeys = false, $emptyValuesOverride = true)
-    {
-        GeneralUtility::logDeprecatedFunction();
-        foreach ($secondArray as $key => $value) {
-            if (array_key_exists($key, $firstArray) && is_array($firstArray[$key])) {
-                if (is_array($secondArray[$key])) {
-                    $firstArray[$key] = self::arrayMergeRecursiveOverrule($firstArray[$key], $secondArray[$key], $dontAddNewKeys, $emptyValuesOverride);
-                } else {
-                    $firstArray[$key] = $secondArray[$key];
-                }
-            } else {
-                if ($dontAddNewKeys) {
-                    if (array_key_exists($key, $firstArray)) {
-                        if ($emptyValuesOverride || !empty($value)) {
-                            $firstArray[$key] = $value;
-                        }
-                    }
-                } else {
-                    if ($emptyValuesOverride || !empty($value)) {
-                        $firstArray[$key] = $value;
-                    }
-                }
-            }
-        }
-        reset($firstArray);
-        return $firstArray;
-    }
-
-    /**
-     * Randomizes the order of array values. The array should not be an associative array
-     * as the key-value relations will be lost.
-     *
-     * @param array $array Array to reorder
-     * @return array The array with randomly ordered values
-     * @api
-     * @deprecated since TYPO3 v8, will be removed in TYPO3 v9
-     */
-    public static function randomizeArrayOrder(array $array)
-    {
-        GeneralUtility::logDeprecatedFunction();
-        $reorderedArray = [];
-        if (count($array) > 1) {
-            $keysInRandomOrder = array_rand($array, count($array));
-            foreach ($keysInRandomOrder as $key) {
-                $reorderedArray[] = $array[$key];
-            }
-        } else {
-            $reorderedArray = $array;
-        }
-        return $reorderedArray;
-    }
-
-    /**
-     * Returns TRUE if the given array contains elements of varying types
-     *
-     * @param array $array
-     * @return bool
-     * @api
-     * @deprecated since TYPO3 v8, will be removed in TYPO3 v9
-     */
-    public static function containsMultipleTypes(array $array)
-    {
-        GeneralUtility::logDeprecatedFunction();
-        if (!empty($array)) {
-            foreach ($array as $value) {
-                if (!isset($previousType)) {
-                    $previousType = gettype($value);
-                } elseif ($previousType !== gettype($value)) {
-                    return true;
-                }
-            }
-        }
-        return false;
-    }
-
-    /**
-     * Replacement for array_reduce that allows any type for $initial (instead
-     * of only integer)
-     *
-     * @param array $array the array to reduce
-     * @param string $function the reduce function with the same order of parameters as in the native array_reduce (i.e. accumulator first, then current array element)
-     * @param mixed $initial the initial accumulator value
-     * @return mixed
-     * @api
-     * @deprecated since TYPO3 v8, will be removed in TYPO3 v9
-     */
-    public static function array_reduce(array $array, $function, $initial = null)
-    {
-        GeneralUtility::logDeprecatedFunction();
-        $accumlator = $initial;
-        foreach ($array as $value) {
-            $accumlator = $function($accumlator, $value);
-        }
-        return $accumlator;
-    }
-
-    /**
-     * Returns the value of a nested array by following the specified path.
-     *
-     * @param array &$array The array to traverse as a reference
-     * @param array|string $path The path to follow. Either a simple array of keys or a string in the format 'foo.bar.baz'
-     * @throws \InvalidArgumentException
-     * @return mixed The value found, NULL if the path didn't exist
-     * @api
-     * @deprecated since TYPO3 v8, will be removed in TYPO3 v9, use ArrayUtility provided by EXT:core instead.
-     */
-    public static function getValueByPath(array &$array, $path)
-    {
-        GeneralUtility::logDeprecatedFunction();
-        if (is_string($path)) {
-            $path = explode('.', $path);
-        } elseif (!is_array($path)) {
-            throw new \InvalidArgumentException('getValueByPath() expects $path to be string or array, "' . gettype($path) . '" given.', 1304950007);
-        }
-        $key = array_shift($path);
-        if (isset($array[$key])) {
-            if (!empty($path)) {
-                return is_array($array[$key]) ? self::getValueByPath($array[$key], $path) : null;
-            }
-            return $array[$key];
-        } else {
-            return null;
-        }
-    }
-
-    /**
-     * Sets the given value in a nested array or object by following the specified path.
-     *
-     * @param array|\ArrayAccess $subject The array or ArrayAccess instance to work on
-     * @param array|string $path The path to follow. Either a simple array of keys or a string in the format 'foo.bar.baz'
-     * @param mixed $value The value to set
-     * @throws \InvalidArgumentException
-     * @return array The modified array or object
-     * @deprecated since TYPO3 v8, will be removed in TYPO3 v9, use ArrayUtility provided by EXT:core instead.
-     */
-    public static function setValueByPath($subject, $path, $value)
-    {
-        GeneralUtility::logDeprecatedFunction();
-        if (!is_array($subject) && !$subject instanceof \ArrayAccess) {
-            throw new \InvalidArgumentException('setValueByPath() expects $subject to be array or an object implementing \\ArrayAccess, "' . (is_object($subject) ? get_class($subject) : gettype($subject)) . '" given.', 1306424308);
-        }
-        if (is_string($path)) {
-            $path = explode('.', $path);
-        } elseif (!is_array($path)) {
-            throw new \InvalidArgumentException('setValueByPath() expects $path to be string or array, "' . gettype($path) . '" given.', 1305111499);
-        }
-        $key = array_shift($path);
-        if (empty($path)) {
-            $subject[$key] = $value;
-        } else {
-            if (!isset($subject[$key]) || !is_array($subject[$key])) {
-                $subject[$key] = [];
-            }
-            $subject[$key] = self::setValueByPath($subject[$key], $path, $value);
-        }
-        return $subject;
-    }
-
-    /**
-     * Unsets an element/part of a nested array by following the specified path.
-     *
-     * @param array $array The array
-     * @param array|string $path The path to follow. Either a simple array of keys or a string in the format 'foo.bar.baz'
-     * @throws \InvalidArgumentException
-     * @return array The modified array
-     * @deprecated since TYPO3 v8, will be removed in TYPO3 v9, see ArrayUtility::removeByPath()
-     */
-    public static function unsetValueByPath(array $array, $path)
-    {
-        GeneralUtility::logDeprecatedFunction();
-        if (is_string($path)) {
-            $path = explode('.', $path);
-        } elseif (!is_array($path)) {
-            throw new \InvalidArgumentException('unsetValueByPath() expects $path to be string or array, "' . gettype($path) . '" given.', 1305111513);
-        }
-        $key = array_shift($path);
-        if (empty($path)) {
-            unset($array[$key]);
-        } else {
-            if (!isset($array[$key]) || !is_array($array[$key])) {
-                return $array;
-            }
-            $array[$key] = self::unsetValueByPath($array[$key], $path);
-        }
-        return $array;
-    }
-
-    /**
-     * Sorts multidimensional arrays by recursively calling ksort on its elements.
-     *
-     * @param array &$array the array to sort
-     * @param int $sortFlags may be used to modify the sorting behavior using these values (see http://www.php.net/manual/en/function.sort.php)
-     * @return bool TRUE on success, FALSE on failure
-     * @see asort()
-     * @api
-     * @deprecated since TYPO3 v8, will be removed in TYPO3 v9
-     */
-    public static function sortKeysRecursively(array &$array, $sortFlags = null)
-    {
-        GeneralUtility::logDeprecatedFunction();
-        foreach ($array as &$value) {
-            if (is_array($value)) {
-                if (self::sortKeysRecursively($value, $sortFlags) === false) {
-                    return false;
-                }
-            }
-        }
-        return ksort($array, $sortFlags);
-    }
-
-    /**
-     * Recursively convert an object hierarchy into an associative array.
-     *
-     * @param mixed $subject An object or array of objects
-     * @throws \InvalidArgumentException
-     * @return array The subject represented as an array
-     * @deprecated since TYPO3 v8, will be removed in TYPO3 v9
-     */
-    public static function convertObjectToArray($subject)
-    {
-        GeneralUtility::logDeprecatedFunction();
-        if (!is_object($subject) && !is_array($subject)) {
-            throw new \InvalidArgumentException('convertObjectToArray expects either array or object as input, ' . gettype($subject) . ' given.', 1287059709);
-        }
-        if (is_object($subject)) {
-            $subject = (array)$subject;
-        }
-        foreach ($subject as $key => $value) {
-            if (is_array($value) || is_object($value)) {
-                $subject[$key] = self::convertObjectToArray($value);
-            }
-        }
-        return $subject;
-    }
-
-    /**
-     * Recursively removes empty array elements.
-     *
-     * @param array $array
-     * @return array the modified array
-     * @deprecated since TYPO3 v8, will be removed in TYPO3 v9
-     */
-    public static function removeEmptyElementsRecursively(array $array)
-    {
-        GeneralUtility::logDeprecatedFunction();
-        $result = $array;
-        foreach ($result as $key => $value) {
-            if (is_array($value)) {
-                $result[$key] = self::removeEmptyElementsRecursively($value);
-                if ($result[$key] === []) {
-                    unset($result[$key]);
-                }
-            } elseif ($value === null) {
-                unset($result[$key]);
-            }
-        }
-        return $result;
-    }
-
-    /**
-     * If the array contains numerical keys only, sort it in ascending order
-     *
-     * @param array $array
-     *
-     * @return array
-     * @deprecated since TYPO3 v8, will be removed in TYPO3 v9, use the same method provided in TYPO3\CMS\Core\Utility\ArrayUtility
-     */
-    public static function sortArrayWithIntegerKeys($array)
-    {
-        GeneralUtility::logDeprecatedFunction();
-        $containsNumericalKeysOnly = true;
-        array_walk($array, function ($value, $key) use (&$containsNumericalKeysOnly) {
-            if (!is_int($key)) {
-                $containsNumericalKeysOnly = false;
-                return;
-            }
-        });
-        if ($containsNumericalKeysOnly === true) {
-            ksort($array);
-        }
-        return $array;
-    }
-}
diff --git a/typo3/sysext/extbase/Tests/Unit/Utility/ArrayUtilityTest.php b/typo3/sysext/extbase/Tests/Unit/Utility/ArrayUtilityTest.php
deleted file mode 100644 (file)
index b5b1274..0000000
+++ /dev/null
@@ -1,491 +0,0 @@
-<?php
-namespace TYPO3\CMS\Extbase\Tests\Unit\Utility;
-
-/*
- * 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!
- */
-
-/**
- * Test case
- */
-class ArrayUtilityTest extends \TYPO3\TestingFramework\Core\Unit\UnitTestCase
-{
-    /**
-     * @test
-     */
-    public function containsMultipleTypesReturnsFalseOnEmptyArray()
-    {
-        $this->assertFalse(\TYPO3\CMS\Extbase\Utility\ArrayUtility::containsMultipleTypes([]));
-    }
-
-    /**
-     * @test
-     */
-    public function containsMultipleTypesReturnsFalseOnArrayWithIntegers()
-    {
-        $this->assertFalse(\TYPO3\CMS\Extbase\Utility\ArrayUtility::containsMultipleTypes([1, 2, 3]));
-    }
-
-    /**
-     * @test
-     */
-    public function containsMultipleTypesReturnsFalseOnArrayWithObjects()
-    {
-        $this->assertFalse(\TYPO3\CMS\Extbase\Utility\ArrayUtility::containsMultipleTypes([new \stdClass(), new \stdClass(), new \stdClass()]));
-    }
-
-    /**
-     * @test
-     */
-    public function containsMultipleTypesReturnsTrueOnMixedArray()
-    {
-        $this->assertTrue(\TYPO3\CMS\Extbase\Utility\ArrayUtility::containsMultipleTypes([1, 'string', 1.25, new \stdClass()]));
-    }
-
-    /**
-     * @test
-     */
-    public function getValueByPathReturnsTheValueOfANestedArrayByFollowingTheGivenSimplePath()
-    {
-        $array = ['Foo' => 'the value'];
-        $this->assertSame('the value', \TYPO3\CMS\Extbase\Utility\ArrayUtility::getValueByPath($array, ['Foo']));
-    }
-
-    /**
-     * @test
-     */
-    public function getValueByPathReturnsTheValueOfANestedArrayByFollowingTheGivenPath()
-    {
-        $array = ['Foo' => ['Bar' => ['Baz' => [2 => 'the value']]]];
-        $this->assertSame('the value', \TYPO3\CMS\Extbase\Utility\ArrayUtility::getValueByPath($array, ['Foo', 'Bar', 'Baz', 2]));
-    }
-
-    /**
-     * @test
-     */
-    public function getValueByPathReturnsTheValueOfANestedArrayByFollowingTheGivenPathIfPathIsString()
-    {
-        $path = 'Foo.Bar.Baz.2';
-        $array = ['Foo' => ['Bar' => ['Baz' => [2 => 'the value']]]];
-        $expectedResult = 'the value';
-        $actualResult = \TYPO3\CMS\Extbase\Utility\ArrayUtility::getValueByPath($array, $path);
-        $this->assertSame($expectedResult, $actualResult);
-    }
-
-    /**
-     * @test
-     */
-    public function getValueByPathThrowsExceptionIfPathIsNoArrayOrString()
-    {
-        $this->expectException(\InvalidArgumentException::class);
-        $this->expectExceptionCode(1304950007);
-        $array = ['Foo' => ['Bar' => ['Baz' => [2 => 'the value']]]];
-        \TYPO3\CMS\Extbase\Utility\ArrayUtility::getValueByPath($array, null);
-    }
-
-    /**
-     * @test
-     */
-    public function getValueByPathReturnsNullIfTheSegementsOfThePathDontExist()
-    {
-        $array = ['Foo' => ['Bar' => ['Baz' => [2 => 'the value']]]];
-        $this->assertNull(\TYPO3\CMS\Extbase\Utility\ArrayUtility::getValueByPath($array, ['Foo', 'Bar', 'Bax', 2]));
-    }
-
-    /**
-     * @test
-     */
-    public function getValueByPathReturnsNullIfThePathHasMoreSegmentsThanTheGivenArray()
-    {
-        $array = ['Foo' => ['Bar' => ['Baz' => 'the value']]];
-        $this->assertNull(\TYPO3\CMS\Extbase\Utility\ArrayUtility::getValueByPath($array, ['Foo', 'Bar', 'Baz', 'Bux']));
-    }
-
-    /**
-     * @test
-     */
-    public function convertObjectToArrayConvertsNestedObjectsToArray()
-    {
-        $object = new \stdClass();
-        $object->a = 'v';
-        $object->b = new \stdClass();
-        $object->b->c = 'w';
-        $object->d = ['i' => 'foo', 'j' => 12, 'k' => true, 'l' => new \stdClass()];
-        $array = \TYPO3\CMS\Extbase\Utility\ArrayUtility::convertObjectToArray($object);
-        $expected = [
-            'a' => 'v',
-            'b' => [
-                'c' => 'w'
-            ],
-            'd' => [
-                'i' => 'foo',
-                'j' => 12,
-                'k' => true,
-                'l' => []
-            ]
-        ];
-        $this->assertSame($expected, $array);
-    }
-
-    /**
-     * @test
-     */
-    public function setValueByPathSetsValueRecursivelyIfPathIsArray()
-    {
-        $array = [];
-        $path = ['foo', 'bar', 'baz'];
-        $expectedValue = ['foo' => ['bar' => ['baz' => 'The Value']]];
-        $actualValue = \TYPO3\CMS\Extbase\Utility\ArrayUtility::setValueByPath($array, $path, 'The Value');
-        $this->assertSame($expectedValue, $actualValue);
-    }
-
-    /**
-     * @test
-     */
-    public function setValueByPathSetsValueRecursivelyIfPathIsString()
-    {
-        $array = [];
-        $path = 'foo.bar.baz';
-        $expectedValue = ['foo' => ['bar' => ['baz' => 'The Value']]];
-        $actualValue = \TYPO3\CMS\Extbase\Utility\ArrayUtility::setValueByPath($array, $path, 'The Value');
-        $this->assertSame($expectedValue, $actualValue);
-    }
-
-    /**
-     * @test
-     */
-    public function setValueByPathRecursivelyMergesAnArray()
-    {
-        $array = ['foo' => ['bar' => 'should be overriden'], 'bar' => 'Baz'];
-        $path = ['foo', 'bar', 'baz'];
-        $expectedValue = ['foo' => ['bar' => ['baz' => 'The Value']], 'bar' => 'Baz'];
-        $actualValue = \TYPO3\CMS\Extbase\Utility\ArrayUtility::setValueByPath($array, $path, 'The Value');
-        $this->assertSame($expectedValue, $actualValue);
-    }
-
-    /**
-     * @test
-     */
-    public function setValueByPathThrowsExceptionIfPathIsNoArrayOrString()
-    {
-        $this->expectException(\InvalidArgumentException::class);
-        $this->expectExceptionCode(1305111499);
-        $array = ['Foo' => ['Bar' => ['Baz' => [2 => 'the value']]]];
-        \TYPO3\CMS\Extbase\Utility\ArrayUtility::setValueByPath($array, null, 'Some Value');
-    }
-
-    /**
-     * @test
-     */
-    public function setValueByPathThrowsExceptionIfSubjectIsNoArray()
-    {
-        $this->expectException(\InvalidArgumentException::class);
-        $this->expectExceptionCode(1306424308);
-        $subject = 'foobar';
-        \TYPO3\CMS\Extbase\Utility\ArrayUtility::setValueByPath($subject, 'foo', 'bar');
-    }
-
-    /**
-     * @test
-     */
-    public function setValueByPathThrowsExceptionIfSubjectIsNoArrayAccess()
-    {
-        $this->expectException(\InvalidArgumentException::class);
-        $this->expectExceptionCode(1306424308);
-        $subject = new \stdClass();
-        \TYPO3\CMS\Extbase\Utility\ArrayUtility::setValueByPath($subject, 'foo', 'bar');
-    }
-
-    /**
-     * @test
-     */
-    public function setValueByLeavesInputArrayUnchanged()
-    {
-        $subject = ($subjectBackup = ['foo' => 'bar']);
-        \TYPO3\CMS\Extbase\Utility\ArrayUtility::setValueByPath($subject, 'foo', 'baz');
-        $this->assertSame($subject, $subjectBackup);
-    }
-
-    /**
-     * @test
-     */
-    public function unsetValueByPathDoesNotModifyAnArrayIfThePathWasNotFound()
-    {
-        $array = ['foo' => ['bar' => ['baz' => 'Some Value']], 'bar' => 'Baz'];
-        $path = ['foo', 'bar', 'nonExistingKey'];
-        $expectedValue = $array;
-        $actualValue = \TYPO3\CMS\Extbase\Utility\ArrayUtility::unsetValueByPath($array, $path);
-        $this->assertSame($expectedValue, $actualValue);
-    }
-
-    /**
-     * @test
-     */
-    public function unsetValueByPathRemovesSpecifiedKey()
-    {
-        $array = ['foo' => ['bar' => ['baz' => 'Some Value']], 'bar' => 'Baz'];
-        $path = ['foo', 'bar', 'baz'];
-        $expectedValue = ['foo' => ['bar' => []], 'bar' => 'Baz'];
-        $actualValue = \TYPO3\CMS\Extbase\Utility\ArrayUtility::unsetValueByPath($array, $path);
-        $this->assertSame($expectedValue, $actualValue);
-    }
-
-    /**
-     * @test
-     */
-    public function unsetValueByPathRemovesSpecifiedKeyIfPathIsString()
-    {
-        $array = ['foo' => ['bar' => ['baz' => 'Some Value']], 'bar' => 'Baz'];
-        $path = 'foo.bar.baz';
-        $expectedValue = ['foo' => ['bar' => []], 'bar' => 'Baz'];
-        $actualValue = \TYPO3\CMS\Extbase\Utility\ArrayUtility::unsetValueByPath($array, $path);
-        $this->assertSame($expectedValue, $actualValue);
-    }
-
-    /**
-     * @test
-     */
-    public function unsetValueByPathRemovesSpecifiedBranch()
-    {
-        $array = ['foo' => ['bar' => ['baz' => 'Some Value']], 'bar' => 'Baz'];
-        $path = ['foo'];
-        $expectedValue = ['bar' => 'Baz'];
-        $actualValue = \TYPO3\CMS\Extbase\Utility\ArrayUtility::unsetValueByPath($array, $path);
-        $this->assertSame($expectedValue, $actualValue);
-    }
-
-    /**
-     * @test
-     */
-    public function unsetValueByPathThrowsExceptionIfPathIsNoArrayOrString()
-    {
-        $this->expectException(\InvalidArgumentException::class);
-        $this->expectExceptionCode(1305111513);
-        $array = ['Foo' => ['Bar' => ['Baz' => [2 => 'the value']]]];
-        \TYPO3\CMS\Extbase\Utility\ArrayUtility::unsetValueByPath($array, null);
-    }
-
-    /**
-     * @test
-     */
-    public function removeEmptyElementsRecursivelyRemovesNullValues()
-    {
-        $array = ['EmptyElement' => null, 'Foo' => ['Bar' => ['Baz' => ['NotNull' => '', 'AnotherEmptyElement' => null]]]];
-        $expectedResult = ['Foo' => ['Bar' => ['Baz' => ['NotNull' => '']]]];
-        $actualResult = \TYPO3\CMS\Extbase\Utility\ArrayUtility::removeEmptyElementsRecursively($array);
-        $this->assertSame($expectedResult, $actualResult);
-    }
-
-    /**
-     * @test
-     */
-    public function removeEmptyElementsRecursivelyRemovesEmptySubArrays()
-    {
-        $array = ['EmptyElement' => [], 'Foo' => ['Bar' => ['Baz' => ['AnotherEmptyElement' => null]]], 'NotNull' => 123];
-        $expectedResult = ['NotNull' => 123];
-        $actualResult = \TYPO3\CMS\Extbase\Utility\ArrayUtility::removeEmptyElementsRecursively($array);
-        $this->assertSame($expectedResult, $actualResult);
-    }
-
-    public function arrayMergeRecursiveOverruleData()
-    {
-        return [
-            'simple usage' => [
-                'inputArray1' => [
-                    'k1' => 'v1',
-                    'k2' => 'v2'
-                ],
-                'inputArray2' => [
-                    'k2' => 'v2a',
-                    'k3' => 'v3'
-                ],
-                'dontAddNewKeys' => false,
-                // default
-                'emptyValuesOverride' => true,
-                // default
-                'expected' => [
-                    'k1' => 'v1',
-                    'k2' => 'v2a',
-                    'k3' => 'v3'
-                ]
-            ],
-            'simple usage with recursion' => [
-                'inputArray1' => [
-                    'k1' => 'v1',
-                    'k2' => [
-                        'k2.1' => 'v2.1',
-                        'k2.2' => 'v2.2'
-                    ]
-                ],
-                'inputArray2' => [
-                    'k2' => [
-                        'k2.2' => 'v2.2a',
-                        'k2.3' => 'v2.3'
-                    ],
-                    'k3' => 'v3'
-                ],
-                'dontAddNewKeys' => false,
-                // default
-                'emptyValuesOverride' => true,
-                // default
-                'expected' => [
-                    'k1' => 'v1',
-                    'k2' => [
-                        'k2.1' => 'v2.1',
-                        'k2.2' => 'v2.2a',
-                        'k2.3' => 'v2.3'
-                    ],
-                    'k3' => 'v3'
-                ]
-            ],
-            'simple type should override array (k2)' => [
-                'inputArray1' => [
-                    'k1' => 'v1',
-                    'k2' => [
-                        'k2.1' => 'v2.1'
-                    ]
-                ],
-                'inputArray2' => [
-                    'k2' => 'v2a',
-                    'k3' => 'v3'
-                ],
-                'dontAddNewKeys' => false,
-                // default
-                'emptyValuesOverride' => true,
-                // default
-                'expected' => [
-                    'k1' => 'v1',
-                    'k2' => 'v2a',
-                    'k3' => 'v3'
-                ]
-            ],
-            'null should override array (k2)' => [
-                'inputArray1' => [
-                    'k1' => 'v1',
-                    'k2' => [
-                        'k2.1' => 'v2.1'
-                    ]
-                ],
-                'inputArray2' => [
-                    'k2' => null,
-                    'k3' => 'v3'
-                ],
-                'dontAddNewKeys' => false,
-                // default
-                'emptyValuesOverride' => true,
-                // default
-                'expected' => [
-                    'k1' => 'v1',
-                    'k2' => null,
-                    'k3' => 'v3'
-                ]
-            ]
-        ];
-    }
-
-    /**
-     * @test
-     *
-     * @param array $inputArray1
-     * @param array $inputArray2
-     * @param bool $dontAddNewKeys
-     * @param bool $emptyValuesOverride
-     * @param array $expected
-     *
-     * @dataProvider arrayMergeRecursiveOverruleData
-     */
-    public function arrayMergeRecursiveOverruleMergesSimpleArrays(array $inputArray1, array $inputArray2, $dontAddNewKeys, $emptyValuesOverride, array $expected)
-    {
-        $this->assertSame($expected, \TYPO3\CMS\Extbase\Utility\ArrayUtility::arrayMergeRecursiveOverrule($inputArray1, $inputArray2, $dontAddNewKeys, $emptyValuesOverride));
-    }
-
-    /**
-     * @test
-     */
-    public function integerExplodeReturnsArrayOfIntegers()
-    {
-        $inputString = '1,2,3,4,5,6';
-        $expected = [1, 2, 3, 4, 5, 6];
-        $this->assertSame($expected, \TYPO3\CMS\Extbase\Utility\ArrayUtility::integerExplode(',', $inputString));
-    }
-
-    /**
-     * @test
-     */
-    public function integerExplodeReturnsZeroForStringValues()
-    {
-        $inputString = '1,abc,3,,5';
-        $expected = [1, 0, 3, 0, 5];
-        $this->assertSame($expected, \TYPO3\CMS\Extbase\Utility\ArrayUtility::integerExplode(',', $inputString));
-    }
-
-    /**
-     * dataProvider for sortArrayWithIntegerKeys
-     *
-     * @return array
-     */
-    public function sortArrayWithIntegerKeysDataProvider()
-    {
-        return [
-            [
-                [
-                    '20' => 'test1',
-                    '11' => 'test2',
-                    '16' => 'test3',
-                ],
-                [
-                    '11' => 'test2',
-                    '16' => 'test3',
-                    '20' => 'test1',
-                ]
-            ],
-            [
-                [
-                    '20' => 'test1',
-                    '16.5' => 'test2',
-                    '16' => 'test3',
-                ],
-                [
-                    '20' => 'test1',
-                    '16.5' => 'test2',
-                    '16' => 'test3',
-                ]
-            ],
-            [
-                [
-                    '20' => 'test20',
-                    'somestring' => 'teststring',
-                    '16' => 'test16',
-                ],
-                [
-                    '20' => 'test20',
-                    'somestring' => 'teststring',
-                    '16' => 'test16',
-                ]
-            ],
-        ];
-    }
-
-    /**
-     * @test
-     *
-     * @param array $arrayToSort
-     * @param array $expectedArray
-     *
-     * @dataProvider sortArrayWithIntegerKeysDataProvider
-     */
-    public function sortArrayWithIntegerKeysSortsNumericArrays(array $arrayToSort, array $expectedArray)
-    {
-        $sortedArray = \TYPO3\CMS\Extbase\Utility\ArrayUtility::sortArrayWithIntegerKeys($arrayToSort);
-        $this->assertSame($sortedArray, $expectedArray);
-    }
-}