mirror of
https://github.com/wiosna-dev/common-library.git
synced 2026-03-12 01:31:45 +01:00
1882 lines
54 KiB
PHP
1882 lines
54 KiB
PHP
<?php
|
|
|
|
/**
|
|
* (c) Meritoo.pl, http://www.meritoo.pl
|
|
* For the full copyright and license information, please view the LICENSE
|
|
* file that was distributed with this source code.
|
|
*/
|
|
|
|
namespace Meritoo\Common\Test\Utilities;
|
|
|
|
use Meritoo\Common\Utilities\Arrays;
|
|
use PHPUnit\Framework\TestCase;
|
|
|
|
/**
|
|
* Tests of the useful arrays methods
|
|
*
|
|
* @author Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
|
|
* @copyright Meritoo.pl
|
|
*/
|
|
class ArraysTest extends TestCase
|
|
{
|
|
private $simpleArray;
|
|
private $simpleArrayWithKeys;
|
|
private $twoDimensionsArray;
|
|
private $complexArray;
|
|
private $superComplexArray;
|
|
|
|
public function testValues2string()
|
|
{
|
|
/*
|
|
* Simple array / string
|
|
*/
|
|
$simpleString = 'Lorem,ipsum,dolor,sit,amet';
|
|
$simpleStringWithDots = str_replace(',', '.', $simpleString);
|
|
|
|
self::assertEquals($simpleString, Arrays::values2string($this->simpleArray));
|
|
self::assertEquals('ipsum', Arrays::values2string($this->simpleArray, 1));
|
|
self::assertEquals($simpleStringWithDots, Arrays::values2string($this->simpleArray, '', '.'));
|
|
|
|
/*
|
|
* Complex array / string
|
|
*/
|
|
$complexString = 'sit,egestas,adipiscing,1234,,donec,quis,elit,iaculis,primis';
|
|
$complexStringWithDots = str_replace(',', '.', $complexString);
|
|
|
|
self::assertEquals($complexString, Arrays::values2string($this->complexArray));
|
|
self::assertEquals($complexStringWithDots, Arrays::values2string($this->complexArray, '', '.'));
|
|
|
|
/*
|
|
* Other cases
|
|
*/
|
|
self::assertEquals('', Arrays::values2string([]));
|
|
}
|
|
|
|
public function testValuesKeys2string()
|
|
{
|
|
self::assertEquals('0=Lorem,1=ipsum,2=dolor,3=sit,4=amet', Arrays::valuesKeys2string($this->simpleArray));
|
|
self::assertEquals('0=Lorem;1=ipsum;2=dolor;3=sit;4=amet', Arrays::valuesKeys2string($this->simpleArray, ';'));
|
|
self::assertEquals('0=Lorem 1=ipsum 2=dolor 3=sit 4=amet', Arrays::valuesKeys2string($this->simpleArray, ' '));
|
|
|
|
self::assertEquals('0="Lorem" 1="ipsum" 2="dolor" 3="sit" 4="amet"', Arrays::valuesKeys2string($this->simpleArray, ' ', '=', '"'));
|
|
self::assertEquals('0="Lorem", 1="ipsum", 2="dolor", 3="sit", 4="amet"', Arrays::valuesKeys2string($this->simpleArray, ', ', '=', '"'));
|
|
}
|
|
|
|
public function testValues2csv()
|
|
{
|
|
self::assertEquals('', Arrays::values2csv($this->simpleArray));
|
|
|
|
self::assertEquals("lorem,ipsum,dolor,sit,amet\n"
|
|
. "consectetur,adipiscing,elit\n"
|
|
. 'donec,sagittis,fringilla,eleifend', Arrays::values2csv($this->twoDimensionsArray));
|
|
}
|
|
|
|
public function testGetFirstKey()
|
|
{
|
|
/*
|
|
* Negative cases
|
|
*/
|
|
self::assertNull(Arrays::getFirstKey([]));
|
|
|
|
/*
|
|
* Positive cases
|
|
*/
|
|
self::assertEquals(0, Arrays::getFirstKey($this->simpleArray));
|
|
self::assertEquals('lorem', Arrays::getFirstKey($this->complexArray));
|
|
}
|
|
|
|
public function testGetLastKey()
|
|
{
|
|
self::assertEquals(4, Arrays::getLastKey($this->simpleArray));
|
|
self::assertEquals('amet', Arrays::getLastKey($this->complexArray));
|
|
}
|
|
|
|
public function testGetFirstElement()
|
|
{
|
|
/*
|
|
* Negative cases
|
|
*/
|
|
self::assertNull(Arrays::getFirstElement([]));
|
|
|
|
/*
|
|
* Positive cases
|
|
*/
|
|
self::assertEquals('Lorem', Arrays::getFirstElement($this->simpleArray));
|
|
self::assertEquals('Lorem', Arrays::getFirstElement($this->simpleArray));
|
|
self::assertEquals('lorem', Arrays::getFirstElement($this->twoDimensionsArray, false));
|
|
self::assertEquals('sit', Arrays::getFirstElement($this->complexArray, false));
|
|
}
|
|
|
|
public function testIsFirstElement()
|
|
{
|
|
self::assertTrue(Arrays::isFirstElement($this->simpleArray, 'Lorem'));
|
|
self::assertFalse(Arrays::isFirstElement($this->simpleArray, 'dolor'));
|
|
self::assertFalse(Arrays::isFirstElement($this->simpleArray, ' '));
|
|
self::assertFalse(Arrays::isFirstElement($this->simpleArray, null));
|
|
}
|
|
|
|
public function testGetLastElement()
|
|
{
|
|
/*
|
|
* Negative cases
|
|
*/
|
|
self::assertNull(Arrays::getLastElement([]));
|
|
|
|
/*
|
|
* Positive cases
|
|
*/
|
|
self::assertEquals('amet', Arrays::getLastElement($this->simpleArray));
|
|
self::assertEquals('eleifend', Arrays::getLastElement($this->twoDimensionsArray, false));
|
|
self::assertEquals('primis', Arrays::getLastElement($this->complexArray, false));
|
|
}
|
|
|
|
public function testIsLastElement()
|
|
{
|
|
self::assertTrue(Arrays::isLastElement($this->simpleArray, 'amet'));
|
|
self::assertFalse(Arrays::isLastElement($this->simpleArray, 'ipsum'));
|
|
self::assertFalse(Arrays::isLastElement($this->simpleArray, ''));
|
|
self::assertFalse(Arrays::isLastElement($this->simpleArray, null));
|
|
}
|
|
|
|
public function testGetLastElementBreadCrumb()
|
|
{
|
|
self::assertEquals('4/amet', Arrays::getLastElementBreadCrumb($this->simpleArray));
|
|
self::assertEquals('2/3/eleifend', Arrays::getLastElementBreadCrumb($this->twoDimensionsArray));
|
|
self::assertEquals('amet/1/primis', Arrays::getLastElementBreadCrumb($this->complexArray));
|
|
}
|
|
|
|
public function testGetLastRow()
|
|
{
|
|
/*
|
|
* Negative cases
|
|
*/
|
|
self::assertNull(Arrays::getLastRow([]));
|
|
|
|
/*
|
|
* Positive cases
|
|
*/
|
|
self::assertEquals([], Arrays::getLastRow($this->simpleArray));
|
|
self::assertEquals([], Arrays::getLastRow($this->simpleArrayWithKeys));
|
|
|
|
self::assertEquals([
|
|
'donec',
|
|
'sagittis',
|
|
'fringilla',
|
|
'eleifend',
|
|
], Arrays::getLastRow($this->twoDimensionsArray));
|
|
|
|
self::assertEquals([
|
|
'iaculis',
|
|
'primis',
|
|
], Arrays::getLastRow($this->complexArray));
|
|
}
|
|
|
|
public function testReplaceArrayKeys()
|
|
{
|
|
$effect = [
|
|
'nullam' => 'donec',
|
|
'x' => [
|
|
'vitae' => [
|
|
'x' => 'quis',
|
|
],
|
|
],
|
|
'elit',
|
|
];
|
|
|
|
$dataArray = $this->complexArray['sit'];
|
|
self::assertEquals($effect, Arrays::replaceArrayKeys($dataArray, '|.*li.*|', 'x'));
|
|
|
|
self::assertEquals([
|
|
'x' => 'sit',
|
|
4 => 'amet',
|
|
], Arrays::replaceArrayKeys($this->simpleArray, '|[0-3]+|', 'x'));
|
|
}
|
|
|
|
public function testMakeArray()
|
|
{
|
|
self::assertSame($this->simpleArray, Arrays::makeArray($this->simpleArray));
|
|
self::assertSame(['test'], Arrays::makeArray('test'));
|
|
}
|
|
|
|
public function testArray2JavaScript()
|
|
{
|
|
/*
|
|
* Negative cases
|
|
*/
|
|
self::assertNull(Arrays::array2JavaScript([]));
|
|
|
|
/*
|
|
* Positive cases
|
|
*/
|
|
self::assertEquals('new Array(\'Lorem\', \'ipsum\', \'dolor\', \'sit\', \'amet\');', Arrays::array2JavaScript($this->simpleArray));
|
|
self::assertEquals('var letsTest = new Array(\'Lorem\', \'ipsum\', \'dolor\', \'sit\', \'amet\');', Arrays::array2JavaScript($this->simpleArray, 'letsTest'));
|
|
|
|
$effect = 'var letsTest = new Array(5);
|
|
letsTest[0] = \'Lorem\';
|
|
letsTest[1] = \'ipsum\';
|
|
letsTest[2] = \'dolor\';
|
|
letsTest[3] = \'sit\';
|
|
letsTest[4] = \'amet\';';
|
|
|
|
self::assertEquals($effect, Arrays::array2JavaScript($this->simpleArray, 'letsTest', true));
|
|
|
|
self::assertEquals('new Array(\'ipsum\', \'sit\', \'consectetur\');', Arrays::array2JavaScript($this->simpleArrayWithKeys));
|
|
self::assertEquals('var letsTest = new Array(\'ipsum\', \'sit\', \'consectetur\');', Arrays::array2JavaScript($this->simpleArrayWithKeys, 'letsTest'));
|
|
|
|
$effect = 'var letsTest = new Array(3);
|
|
letsTest[\'Lorem\'] = \'ipsum\';
|
|
letsTest[\'dolor\'] = \'sit\';
|
|
letsTest[\'amet\'] = \'consectetur\';';
|
|
|
|
self::assertEquals($effect, Arrays::array2JavaScript($this->simpleArrayWithKeys, 'letsTest', true));
|
|
|
|
$effect = 'var autoGeneratedVariable = new Array(3);
|
|
var value_0 = new Array(\'lorem\', \'ipsum\', \'dolor\', \'sit\', \'amet\');
|
|
autoGeneratedVariable[0] = value_0;
|
|
var value_1 = new Array(\'consectetur\', \'adipiscing\', \'elit\');
|
|
autoGeneratedVariable[1] = value_1;
|
|
var value_2 = new Array(\'donec\', \'sagittis\', \'fringilla\', \'eleifend\');
|
|
autoGeneratedVariable[2] = value_2;';
|
|
|
|
self::assertEquals($effect, Arrays::array2JavaScript($this->twoDimensionsArray));
|
|
|
|
$effect = 'var letsTest = new Array(3);
|
|
var value_0 = new Array(\'lorem\', \'ipsum\', \'dolor\', \'sit\', \'amet\');
|
|
letsTest[0] = value_0;
|
|
var value_1 = new Array(\'consectetur\', \'adipiscing\', \'elit\');
|
|
letsTest[1] = value_1;
|
|
var value_2 = new Array(\'donec\', \'sagittis\', \'fringilla\', \'eleifend\');
|
|
letsTest[2] = value_2;';
|
|
|
|
self::assertEquals($effect, Arrays::array2JavaScript($this->twoDimensionsArray, 'letsTest'));
|
|
|
|
$effect = 'var letsTest = new Array(3);
|
|
var value_0 = new Array(5);
|
|
value_0[0] = \'lorem\';
|
|
value_0[1] = \'ipsum\';
|
|
value_0[2] = \'dolor\';
|
|
value_0[3] = \'sit\';
|
|
value_0[4] = \'amet\';
|
|
letsTest[0] = value_0;
|
|
var value_1 = new Array(3);
|
|
value_1[0] = \'consectetur\';
|
|
value_1[1] = \'adipiscing\';
|
|
value_1[2] = \'elit\';
|
|
letsTest[1] = value_1;
|
|
var value_2 = new Array(4);
|
|
value_2[0] = \'donec\';
|
|
value_2[1] = \'sagittis\';
|
|
value_2[2] = \'fringilla\';
|
|
value_2[3] = \'eleifend\';
|
|
letsTest[2] = value_2;';
|
|
|
|
self::assertEquals($effect, Arrays::array2JavaScript($this->twoDimensionsArray, 'letsTest', true));
|
|
}
|
|
|
|
public function testRemoveMarginalElement()
|
|
{
|
|
$array = $this->simpleArray;
|
|
$string = 'Lorem ipsum';
|
|
|
|
/*
|
|
* Removing first element
|
|
*/
|
|
self::assertSame([
|
|
0 => 'Lorem',
|
|
1 => 'ipsum',
|
|
2 => 'dolor',
|
|
3 => 'sit',
|
|
], Arrays::removeMarginalElement($array));
|
|
self::assertEquals('Lorem ipsu', Arrays::removeMarginalElement($string));
|
|
|
|
/*
|
|
* Removing last element
|
|
*/
|
|
self::assertSame([
|
|
1 => 'ipsum',
|
|
2 => 'dolor',
|
|
3 => 'sit',
|
|
4 => 'amet',
|
|
], Arrays::removeMarginalElement($array, false));
|
|
self::assertEquals('orem ipsum', Arrays::removeMarginalElement($string, false));
|
|
}
|
|
|
|
public function testRemoveElements()
|
|
{
|
|
$array1 = $this->simpleArray;
|
|
$array2 = $this->simpleArray;
|
|
|
|
Arrays::removeElements($array1, 'ipsum');
|
|
self::assertSame([
|
|
1 => 'ipsum',
|
|
2 => 'dolor',
|
|
3 => 'sit',
|
|
4 => 'amet',
|
|
], $array1);
|
|
|
|
Arrays::removeElements($array2, 'sit', false);
|
|
self::assertSame([
|
|
0 => 'Lorem',
|
|
1 => 'ipsum',
|
|
2 => 'dolor',
|
|
3 => 'sit',
|
|
], $array2);
|
|
|
|
Arrays::removeElements($this->complexArray['lorem'], 'sit', false);
|
|
self::assertSame(['ipsum' => ['dolor' => 'sit']], $this->complexArray['lorem']);
|
|
}
|
|
|
|
public function testRemoveElement()
|
|
{
|
|
self::assertFalse(Arrays::removeElement($this->simpleArray, 'eeee'));
|
|
self::assertTrue(is_array(Arrays::removeElement($this->simpleArray, 'Lorem')));
|
|
|
|
Arrays::removeElement($this->simpleArray, 'amet');
|
|
self::assertFalse(isset($this->simpleArray['amet']));
|
|
}
|
|
|
|
public function testSetKeysAsValuesEmptyArray()
|
|
{
|
|
self::assertEquals([], Arrays::setKeysAsValues([]));
|
|
}
|
|
|
|
public function testSetKeysAsValuesSameKeysValues()
|
|
{
|
|
$array = [
|
|
0,
|
|
1,
|
|
2,
|
|
3,
|
|
];
|
|
|
|
self::assertEquals($array, Arrays::setKeysAsValues($array));
|
|
}
|
|
|
|
/**
|
|
* @param array $array The array to change values with keys
|
|
* @param array $replaced The array with replaced values with keys
|
|
*
|
|
* @dataProvider provideSimpleArrayToSetKeysAsValues
|
|
*/
|
|
public function testSetKeysAsValuesSimpleArray($array, $replaced)
|
|
{
|
|
self::assertEquals($replaced, Arrays::setKeysAsValues($array));
|
|
}
|
|
|
|
public function testSetKeysAsValuesTwoDimensionsArray()
|
|
{
|
|
$replaced = [
|
|
[
|
|
'lorem' => 0,
|
|
'ipsum' => 1,
|
|
'dolor' => 2,
|
|
'sit' => 3,
|
|
'amet' => 4,
|
|
],
|
|
[
|
|
'consectetur' => 0,
|
|
'adipiscing' => 1,
|
|
'elit' => 2,
|
|
],
|
|
[
|
|
'donec' => 0,
|
|
'sagittis' => 1,
|
|
'fringilla' => 2,
|
|
'eleifend' => 3,
|
|
],
|
|
];
|
|
|
|
self::assertEquals($replaced, Arrays::setKeysAsValues($this->twoDimensionsArray));
|
|
}
|
|
|
|
/**
|
|
* @param array $array The array to change values with keys
|
|
* @param array $replaced The array with replaced values with keys
|
|
*
|
|
* @dataProvider provideArrayWithDuplicatedValuesToSetKeysAsValues
|
|
*/
|
|
public function testSetKeysAsValuesDuplicatedValues($array, $replaced)
|
|
{
|
|
self::assertEquals($replaced, Arrays::setKeysAsValues($array, false));
|
|
}
|
|
|
|
public function testGetNonArrayElementsCount()
|
|
{
|
|
/*
|
|
* Negative cases
|
|
*/
|
|
self::assertNull(Arrays::getNonArrayElementsCount([]));
|
|
|
|
/*
|
|
* Positive cases
|
|
*/
|
|
self::assertEquals(5, Arrays::getNonArrayElementsCount($this->simpleArray));
|
|
self::assertEquals(3, Arrays::getNonArrayElementsCount($this->simpleArrayWithKeys));
|
|
self::assertEquals(12, Arrays::getNonArrayElementsCount($this->twoDimensionsArray));
|
|
}
|
|
|
|
public function testString2array()
|
|
{
|
|
/*
|
|
* Negative cases
|
|
*/
|
|
self::assertNull(Arrays::string2array(''));
|
|
self::assertNull(Arrays::string2array(null));
|
|
|
|
/*
|
|
* Positive cases
|
|
*/
|
|
$array = [
|
|
'light' => '#fff',
|
|
'dark' => '#000',
|
|
];
|
|
|
|
self::assertEquals($array, Arrays::string2array('light:#fff|dark:#000'));
|
|
self::assertEquals($array, Arrays::string2array('light: #fff | dark: #000'));
|
|
|
|
$array = [
|
|
'red' => '#f00',
|
|
'green' => '#0f0',
|
|
'blue' => '#00f',
|
|
];
|
|
|
|
self::assertEquals($array, Arrays::string2array('red:#f00|green:#0f0|blue:#00f'));
|
|
self::assertEquals($array, Arrays::string2array('red: #f00 | green: #0f0 | blue: #00f'));
|
|
self::assertEquals($array, Arrays::string2array('red : #f00 | green : #0f0 | blue : #00f'));
|
|
}
|
|
|
|
public function testAreKeysInArray()
|
|
{
|
|
/*
|
|
* Negative cases
|
|
*/
|
|
self::assertFalse(Arrays::areKeysInArray([null], $this->simpleArray));
|
|
self::assertFalse(Arrays::areKeysInArray([''], $this->simpleArray));
|
|
self::assertFalse(Arrays::areKeysInArray(['dolorrr'], $this->simpleArrayWithKeys));
|
|
|
|
$keys1 = [
|
|
1,
|
|
3,
|
|
9,
|
|
];
|
|
|
|
self::assertFalse(Arrays::areKeysInArray($keys1, $this->simpleArray));
|
|
self::assertFalse(Arrays::areKeysInArray($keys1, $this->complexArray));
|
|
self::assertFalse(Arrays::areKeysInArray($keys1, $this->complexArray, false));
|
|
|
|
/*
|
|
* Positive cases
|
|
*/
|
|
$keys12 = [
|
|
2,
|
|
'mollis',
|
|
];
|
|
|
|
$keys13 = [
|
|
1,
|
|
3,
|
|
];
|
|
|
|
$keys14 = [
|
|
'dolor',
|
|
'amet',
|
|
];
|
|
|
|
$keys15 = [
|
|
'dolor',
|
|
'amet',
|
|
];
|
|
|
|
$keys16 = [
|
|
'a' => 'lorem',
|
|
11 => 'amet',
|
|
];
|
|
|
|
$keys17 = [
|
|
'a' => 'lorem',
|
|
11 => 'amet',
|
|
'c' => 'sit__',
|
|
];
|
|
|
|
self::assertTrue(Arrays::areKeysInArray([1], $this->simpleArray));
|
|
self::assertTrue(Arrays::areKeysInArray($keys12, $this->simpleArray, false));
|
|
self::assertTrue(Arrays::areKeysInArray($keys12, $this->complexArray));
|
|
self::assertTrue(Arrays::areKeysInArray($keys13, $this->simpleArray));
|
|
self::assertTrue(Arrays::areKeysInArray($keys14, $this->simpleArrayWithKeys));
|
|
self::assertTrue(Arrays::areKeysInArray($keys15, $this->simpleArrayWithKeys));
|
|
|
|
self::assertTrue(Arrays::areKeysInArray(['a' => 'dolor'], $this->simpleArrayWithKeys));
|
|
self::assertTrue(Arrays::areKeysInArray(['a' => 'dolor'], $this->simpleArrayWithKeys, false));
|
|
|
|
self::assertTrue(Arrays::areKeysInArray($keys16, $this->complexArray));
|
|
self::assertTrue(Arrays::areKeysInArray($keys17, $this->complexArray, false));
|
|
}
|
|
|
|
public function testGetLastElementsPaths()
|
|
{
|
|
/*
|
|
* Using default separator and other default arguments
|
|
*/
|
|
$expected = [
|
|
'lorem.ipsum.dolor' => 'sit',
|
|
'lorem.ipsum.diam.non' => 'egestas',
|
|
'consectetur' => 'adipiscing',
|
|
'mollis' => 1234,
|
|
2 => [],
|
|
'sit.nullam' => 'donec',
|
|
'sit.aliquet.vitae.ligula' => 'quis',
|
|
'sit.0' => 'elit',
|
|
'amet.0' => 'iaculis',
|
|
'amet.1' => 'primis',
|
|
];
|
|
|
|
self::assertEquals($expected, Arrays::getLastElementsPaths($this->complexArray));
|
|
|
|
/*
|
|
* Using custom separator
|
|
*/
|
|
$separator = ' -> ';
|
|
$expected = [
|
|
sprintf('lorem%sipsum%sdolor', $separator, $separator) => 'sit',
|
|
sprintf('lorem%sipsum%sdiam%snon', $separator, $separator, $separator) => 'egestas',
|
|
'consectetur' => 'adipiscing',
|
|
'mollis' => 1234,
|
|
2 => [],
|
|
sprintf('sit%snullam', $separator) => 'donec',
|
|
sprintf('sit%saliquet%svitae%sligula', $separator, $separator, $separator) => 'quis',
|
|
sprintf('sit%s0', $separator) => 'elit',
|
|
sprintf('amet%s0', $separator) => 'iaculis',
|
|
sprintf('amet%s1', $separator) => 'primis',
|
|
];
|
|
|
|
self::assertEquals($expected, Arrays::getLastElementsPaths($this->complexArray, $separator));
|
|
|
|
/*
|
|
* Special exception: do not use, stop recursive on the "diam" key
|
|
*/
|
|
$expected = [
|
|
'lorem.ipsum.dolor' => 'sit',
|
|
'consectetur' => 'adipiscing',
|
|
'mollis' => 1234,
|
|
2 => [],
|
|
'sit.nullam' => 'donec',
|
|
'sit.aliquet.vitae.ligula' => 'quis',
|
|
'sit.0' => 'elit',
|
|
'amet.0' => 'iaculis',
|
|
'amet.1' => 'primis',
|
|
'lorem.ipsum.diam' => [
|
|
'non' => 'egestas',
|
|
],
|
|
];
|
|
|
|
$stopIfMatchedBy = 'diam';
|
|
self::assertEquals($expected, Arrays::getLastElementsPaths($this->complexArray, '.', '', $stopIfMatchedBy));
|
|
|
|
/*
|
|
* Stop building of paths on these keys:
|
|
* - "diam"
|
|
* - "aliquet"
|
|
*/
|
|
$expected = [
|
|
'lorem . ipsum . dolor' => 'sit',
|
|
'consectetur' => 'adipiscing',
|
|
'mollis' => 1234,
|
|
2 => [],
|
|
'sit . nullam' => 'donec',
|
|
'sit . 0' => 'elit',
|
|
'amet . 0' => 'iaculis',
|
|
'amet . 1' => 'primis',
|
|
'lorem . ipsum . diam' => [
|
|
'non' => 'egestas',
|
|
],
|
|
'sit . aliquet' => [
|
|
'vitae' => [
|
|
'ligula' => 'quis',
|
|
],
|
|
],
|
|
];
|
|
|
|
$stopIfMatchedBy = [
|
|
'diam',
|
|
'aliquet',
|
|
];
|
|
|
|
self::assertEquals($expected, Arrays::getLastElementsPaths($this->complexArray, ' . ', '', $stopIfMatchedBy));
|
|
|
|
$expected = [
|
|
'ipsum > quis > vestibulum > porta-1' => [
|
|
'turpis',
|
|
'urna',
|
|
],
|
|
'ipsum > quis > vestibulum > porta-2' => [
|
|
'tortor' => [
|
|
'in' => [
|
|
'dui',
|
|
'dolor' => [
|
|
'aliquam',
|
|
],
|
|
],
|
|
],
|
|
],
|
|
'ipsum > quis > vestibulum > porta-3' => [
|
|
1,
|
|
2,
|
|
3,
|
|
],
|
|
'primis > 0' => [
|
|
'in',
|
|
'faucibus',
|
|
'orci',
|
|
],
|
|
'primis > 1' => [
|
|
'luctus',
|
|
'et',
|
|
'ultrices',
|
|
],
|
|
];
|
|
|
|
/*
|
|
* Stop building of paths on more sophisticated keys
|
|
*/
|
|
$stopIfMatchedBy = [
|
|
'porta\-\d+',
|
|
'^\d+$',
|
|
];
|
|
|
|
self::assertEquals($expected, Arrays::getLastElementsPaths($this->superComplexArray, ' > ', '', $stopIfMatchedBy));
|
|
|
|
/*
|
|
* Stop building of paths on these:
|
|
* - keys
|
|
* and
|
|
* - paths (verify paths too)
|
|
*/
|
|
$expected = [
|
|
'lorem > ipsum > dolor' => 'sit',
|
|
'consectetur' => 'adipiscing',
|
|
'mollis' => 1234,
|
|
2 => [],
|
|
'sit > nullam' => 'donec',
|
|
'sit > 0' => 'elit',
|
|
'amet > 0' => 'iaculis',
|
|
'amet > 1' => 'primis',
|
|
'lorem > ipsum > diam' => [
|
|
'non' => 'egestas',
|
|
],
|
|
'sit > aliquet > vitae' => [
|
|
'ligula' => 'quis',
|
|
],
|
|
];
|
|
|
|
$stopIfMatchedBy = [
|
|
'diam',
|
|
'sit > aliquet > vitae',
|
|
];
|
|
|
|
self::assertEquals($expected, Arrays::getLastElementsPaths($this->complexArray, ' > ', '', $stopIfMatchedBy));
|
|
|
|
/*
|
|
* Stop building of paths on these paths (verify paths only)
|
|
*/
|
|
$expected = [
|
|
'ipsum > quis > vestibulum > porta-1' => [
|
|
'turpis',
|
|
'urna',
|
|
],
|
|
'ipsum > quis > vestibulum > porta-2 > tortor' => [
|
|
'in' => [
|
|
'dui',
|
|
'dolor' => [
|
|
'aliquam',
|
|
],
|
|
],
|
|
],
|
|
'ipsum > quis > vestibulum > porta-3 > 0' => 1,
|
|
'ipsum > quis > vestibulum > porta-3 > 1' => 2,
|
|
'ipsum > quis > vestibulum > porta-3 > 2' => 3,
|
|
'primis > 0 > 0' => 'in',
|
|
'primis > 0 > 1' => 'faucibus',
|
|
'primis > 0 > 2' => 'orci',
|
|
'primis > 1' => [
|
|
'luctus',
|
|
'et',
|
|
'ultrices',
|
|
],
|
|
];
|
|
|
|
$stopIfMatchedBy = [
|
|
'ipsum > quis > vestibulum > porta-1',
|
|
'ipsum > quis > vestibulum > porta-2 > tortor',
|
|
'primis > 1',
|
|
];
|
|
|
|
self::assertEquals($expected, Arrays::getLastElementsPaths($this->superComplexArray, ' > ', '', $stopIfMatchedBy));
|
|
|
|
/*
|
|
* Stop building of paths if path contains any of these part (verify part of paths only)
|
|
*/
|
|
$expected = [
|
|
'ipsum > quis > vestibulum > porta-1' => [
|
|
'turpis',
|
|
'urna',
|
|
],
|
|
'ipsum > quis > vestibulum > porta-2 > tortor > in' => [
|
|
'dui',
|
|
'dolor' => [
|
|
'aliquam',
|
|
],
|
|
],
|
|
'ipsum > quis > vestibulum > porta-3 > 0' => 1,
|
|
'ipsum > quis > vestibulum > porta-3 > 1' => 2,
|
|
'ipsum > quis > vestibulum > porta-3 > 2' => 3,
|
|
'primis > 0' => [
|
|
'in',
|
|
'faucibus',
|
|
'orci',
|
|
],
|
|
'primis > 1' => [
|
|
'luctus',
|
|
'et',
|
|
'ultrices',
|
|
],
|
|
];
|
|
|
|
$stopIfMatchedBy = [
|
|
'vestibulum > porta-1',
|
|
'tortor > in',
|
|
'[a-z]+ > \d+',
|
|
];
|
|
|
|
self::assertEquals($expected, Arrays::getLastElementsPaths($this->superComplexArray, ' > ', '', $stopIfMatchedBy));
|
|
}
|
|
|
|
public function testAreAllKeysMatchedByPattern()
|
|
{
|
|
$pattern = '\d+';
|
|
|
|
/*
|
|
* Complex array with strings and integers as keys
|
|
*/
|
|
self::assertFalse(Arrays::areAllKeysMatchedByPattern($this->complexArray, $pattern));
|
|
|
|
/*
|
|
* Simple array with integers as keys only
|
|
*/
|
|
self::assertTrue(Arrays::areAllKeysMatchedByPattern($this->simpleArray, $pattern));
|
|
|
|
/*
|
|
* Empty array
|
|
*/
|
|
self::assertFalse(Arrays::areAllKeysMatchedByPattern([], $pattern));
|
|
|
|
$array = [
|
|
'a' => 'b',
|
|
'c' => 'd',
|
|
];
|
|
|
|
/*
|
|
* Yet another simple array, but with strings as keys
|
|
*/
|
|
self::assertFalse(Arrays::areAllKeysMatchedByPattern($array, $pattern));
|
|
|
|
/*
|
|
* The same array with another pattern
|
|
*/
|
|
$pattern = '\w+';
|
|
self::assertTrue(Arrays::areAllKeysMatchedByPattern($array, $pattern));
|
|
|
|
/*
|
|
* The same array with mixed keys (strings and integers as keys)
|
|
*/
|
|
$array[1] = 'x';
|
|
$pattern = '\d+';
|
|
self::assertFalse(Arrays::areAllKeysMatchedByPattern($array, $pattern));
|
|
|
|
/*
|
|
* Multidimensional array - negative case
|
|
*/
|
|
$array['e'] = ['f' => 'g'];
|
|
self::assertFalse(Arrays::areAllKeysMatchedByPattern($array, $pattern));
|
|
|
|
/*
|
|
* Multidimensional array - positive case
|
|
*/
|
|
unset($array[1]);
|
|
$pattern = '\w+';
|
|
self::assertTrue(Arrays::areAllKeysMatchedByPattern($array, $pattern));
|
|
}
|
|
|
|
public function testAreAllKeysIntegers()
|
|
{
|
|
self::assertEquals(1, Arrays::areAllKeysIntegers($this->simpleArray));
|
|
self::assertEquals(2, Arrays::areAllKeysIntegers($this->simpleArray));
|
|
self::assertEquals('', Arrays::areAllKeysIntegers($this->complexArray));
|
|
}
|
|
|
|
public function testIssetRecursive()
|
|
{
|
|
/*
|
|
* Negative cases
|
|
*/
|
|
self::assertFalse(Arrays::issetRecursive([], []));
|
|
|
|
/*
|
|
* Positive cases
|
|
*/
|
|
$unExistingKeys = [
|
|
'a',
|
|
'b',
|
|
3,
|
|
];
|
|
|
|
$existingKeys = [
|
|
'simpleArray' => [
|
|
1,
|
|
3,
|
|
4,
|
|
],
|
|
'simpleArrayWithKeys' => [
|
|
'dolor',
|
|
'amet',
|
|
],
|
|
'twoDimensionsArray' => [
|
|
2,
|
|
3,
|
|
],
|
|
'complexArray' => [
|
|
'sit',
|
|
'aliquet',
|
|
'vitae',
|
|
],
|
|
];
|
|
|
|
self::assertFalse(Arrays::issetRecursive($this->simpleArray, $unExistingKeys));
|
|
self::assertTrue(Arrays::issetRecursive($this->simpleArray, $existingKeys['simpleArray']));
|
|
|
|
self::assertFalse(Arrays::issetRecursive($this->simpleArrayWithKeys, $unExistingKeys));
|
|
self::assertTrue(Arrays::issetRecursive($this->simpleArrayWithKeys, $existingKeys['simpleArrayWithKeys']));
|
|
|
|
self::assertFalse(Arrays::issetRecursive($this->twoDimensionsArray, $unExistingKeys));
|
|
self::assertTrue(Arrays::issetRecursive($this->twoDimensionsArray, $existingKeys['twoDimensionsArray']));
|
|
|
|
self::assertFalse(Arrays::issetRecursive($this->complexArray, $unExistingKeys));
|
|
self::assertTrue(Arrays::issetRecursive($this->complexArray, $existingKeys['complexArray']));
|
|
}
|
|
|
|
public function testGetValueByKeysPath()
|
|
{
|
|
/*
|
|
* Negative cases
|
|
*/
|
|
self::assertNull(Arrays::getValueByKeysPath([], []));
|
|
|
|
/*
|
|
* Positive cases
|
|
*/
|
|
self::assertNull(Arrays::getValueByKeysPath($this->simpleArray, []));
|
|
self::assertEquals('ipsum', Arrays::getValueByKeysPath($this->simpleArray, [1]));
|
|
self::assertEquals('sit', Arrays::getValueByKeysPath($this->simpleArray, [3]));
|
|
self::assertEquals('sit', Arrays::getValueByKeysPath($this->simpleArrayWithKeys, ['dolor']));
|
|
|
|
$keys = [
|
|
'twoDimensionsArray' => [
|
|
2,
|
|
2,
|
|
],
|
|
'complexArray' => [
|
|
[
|
|
'lorem',
|
|
'ipsum',
|
|
'diam',
|
|
],
|
|
[
|
|
'sit',
|
|
'aliquet',
|
|
],
|
|
],
|
|
];
|
|
|
|
$value = [
|
|
[
|
|
'non' => 'egestas',
|
|
],
|
|
[
|
|
'vitae' => [
|
|
'ligula' => 'quis',
|
|
],
|
|
],
|
|
];
|
|
|
|
self::assertEquals('fringilla', Arrays::getValueByKeysPath($this->twoDimensionsArray, $keys['twoDimensionsArray']));
|
|
self::assertEquals($value[0], Arrays::getValueByKeysPath($this->complexArray, $keys['complexArray'][0]));
|
|
self::assertEquals($value[1], Arrays::getValueByKeysPath($this->complexArray, $keys['complexArray'][1]));
|
|
}
|
|
|
|
public function testGetAllValuesOfKeyEmptyValue()
|
|
{
|
|
self::assertNull(Arrays::getAllValuesOfKey([], ''));
|
|
self::assertNull(Arrays::getAllValuesOfKey([], 'test'));
|
|
}
|
|
|
|
public function testGetAllValuesOfKeyNotExistingKey()
|
|
{
|
|
self::assertNull(Arrays::getAllValuesOfKey([], 'ipsum'));
|
|
self::assertEquals([], Arrays::getAllValuesOfKey($this->simpleArray, 'ipsum'));
|
|
}
|
|
|
|
public function testGetAllValuesOfKey()
|
|
{
|
|
/*
|
|
* Positive case - 1-dimension array
|
|
*/
|
|
self::assertEquals(['ipsum'], Arrays::getAllValuesOfKey($this->simpleArray, 1));
|
|
|
|
/*
|
|
* Positive case - 2-dimensions array
|
|
*/
|
|
$effect = [
|
|
[
|
|
'lorem',
|
|
'ipsum',
|
|
'dolor',
|
|
'sit',
|
|
'amet',
|
|
],
|
|
1 => 'consectetur',
|
|
2 => 'donec',
|
|
];
|
|
|
|
self::assertEquals($effect, Arrays::getAllValuesOfKey($this->twoDimensionsArray, 0));
|
|
|
|
/*
|
|
* Positive case - multi-dimensions array
|
|
*/
|
|
self::assertEquals(['primis'], Arrays::getAllValuesOfKey($this->complexArray, 1));
|
|
|
|
/*
|
|
* Positive case - multi-dimensions array
|
|
*/
|
|
$effect = [
|
|
0 => [
|
|
'in' => [
|
|
'dui',
|
|
'dolor' => [
|
|
'aliquam',
|
|
],
|
|
],
|
|
],
|
|
];
|
|
|
|
self::assertEquals($effect, Arrays::getAllValuesOfKey($this->superComplexArray, 'tortor'));
|
|
}
|
|
|
|
public function testKsortRecursive()
|
|
{
|
|
/*
|
|
* Negative cases
|
|
*/
|
|
$array = [];
|
|
self::assertNull(Arrays::ksortRecursive($array));
|
|
|
|
/*
|
|
* Positive cases
|
|
*/
|
|
self::assertEquals($this->simpleArray, Arrays::ksortRecursive($this->simpleArray));
|
|
self::assertEquals($this->simpleArray, Arrays::ksortRecursive($this->simpleArray, SORT_NUMERIC));
|
|
self::assertEquals($this->twoDimensionsArray, Arrays::ksortRecursive($this->twoDimensionsArray));
|
|
|
|
/*
|
|
* Positive case - multi-dimensions array
|
|
*/
|
|
$effect = [
|
|
'amet' => [
|
|
'iaculis',
|
|
'primis',
|
|
],
|
|
'consectetur' => 'adipiscing',
|
|
'lorem' => [
|
|
'ipsum' => [
|
|
'dolor' => 'sit',
|
|
'diam' => [
|
|
'non' => 'egestas',
|
|
],
|
|
],
|
|
],
|
|
'mollis' => 1234,
|
|
'sit' => [
|
|
'nullam' => 'donec',
|
|
'aliquet' => [
|
|
'vitae' => [
|
|
'ligula' => 'quis',
|
|
],
|
|
],
|
|
'elit',
|
|
],
|
|
2 => [],
|
|
];
|
|
|
|
self::assertEquals($effect, Arrays::ksortRecursive($this->complexArray));
|
|
|
|
/*
|
|
* Positive case - multi-dimensions array - with options of ksort() function
|
|
*/
|
|
$effect = [
|
|
2 => [],
|
|
'amet' => [
|
|
'iaculis',
|
|
'primis',
|
|
],
|
|
'consectetur' => 'adipiscing',
|
|
'lorem' => [
|
|
'ipsum' => [
|
|
'dolor' => 'sit',
|
|
'diam' => [
|
|
'non' => 'egestas',
|
|
],
|
|
],
|
|
],
|
|
'mollis' => 1234,
|
|
'sit' => [
|
|
'nullam' => 'donec',
|
|
'aliquet' => [
|
|
'vitae' => [
|
|
'ligula' => 'quis',
|
|
],
|
|
],
|
|
'elit',
|
|
],
|
|
];
|
|
|
|
self::assertEquals($effect, Arrays::ksortRecursive($this->complexArray, SORT_STRING & SORT_NATURAL));
|
|
}
|
|
|
|
public function testSetPositions()
|
|
{
|
|
/*
|
|
* Negative cases
|
|
*/
|
|
self::assertEmpty(Arrays::setPositions([]));
|
|
self::assertEquals([], Arrays::setPositions([]));
|
|
|
|
/*
|
|
* Positive case - 1-dimension array
|
|
*/
|
|
$array = [
|
|
'abc',
|
|
];
|
|
|
|
self::assertEquals($array, Arrays::setPositions($array));
|
|
|
|
/*
|
|
* Positive case - 2-dimensions array
|
|
*/
|
|
$effect = $this->twoDimensionsArray;
|
|
$effect[0][Arrays::POSITION_KEY_NAME] = 1;
|
|
$effect[1][Arrays::POSITION_KEY_NAME] = 2;
|
|
$effect[2][Arrays::POSITION_KEY_NAME] = 3;
|
|
|
|
self::assertEquals($effect, Arrays::setPositions($this->twoDimensionsArray));
|
|
|
|
/*
|
|
* Positive case - multi-level array
|
|
*/
|
|
$array = [
|
|
'lorem',
|
|
'ipsum' => [
|
|
'dolor',
|
|
'sit',
|
|
],
|
|
'amet' => [
|
|
'consectetur',
|
|
'adipiscing' => [
|
|
'elit' => [
|
|
'cras',
|
|
'quis',
|
|
'ligula',
|
|
],
|
|
],
|
|
],
|
|
];
|
|
|
|
$effect = [
|
|
'lorem',
|
|
'ipsum' => [
|
|
'dolor',
|
|
'sit',
|
|
Arrays::POSITION_KEY_NAME => 1,
|
|
],
|
|
'amet' => [
|
|
'consectetur',
|
|
'adipiscing' => [
|
|
'elit' => [
|
|
'cras',
|
|
'quis',
|
|
'ligula',
|
|
Arrays::POSITION_KEY_NAME => 1,
|
|
],
|
|
Arrays::POSITION_KEY_NAME => 1,
|
|
],
|
|
Arrays::POSITION_KEY_NAME => 2,
|
|
],
|
|
];
|
|
|
|
self::assertEquals($effect, Arrays::setPositions($array));
|
|
|
|
/*
|
|
* Positive case - non-default name of key with position value & 2-dimensions array
|
|
*/
|
|
$keyName = 'level';
|
|
$effect = $this->twoDimensionsArray;
|
|
|
|
$effect[0][$keyName] = 1;
|
|
$effect[1][$keyName] = 2;
|
|
$effect[2][$keyName] = 3;
|
|
|
|
self::assertEquals($effect, Arrays::setPositions($this->twoDimensionsArray, $keyName));
|
|
|
|
/*
|
|
* Positive case - non-default start value of position & 2-dimensions array
|
|
*/
|
|
$startPosition = 5;
|
|
$effect = $this->twoDimensionsArray;
|
|
|
|
$effect[Arrays::POSITION_KEY_NAME] = $startPosition;
|
|
$effect[0][Arrays::POSITION_KEY_NAME] = 1;
|
|
$effect[1][Arrays::POSITION_KEY_NAME] = 2;
|
|
$effect[2][Arrays::POSITION_KEY_NAME] = 3;
|
|
|
|
self::assertEquals($effect, Arrays::setPositions($this->twoDimensionsArray, Arrays::POSITION_KEY_NAME, $startPosition));
|
|
}
|
|
|
|
public function testTrimRecursive()
|
|
{
|
|
/*
|
|
* Negative cases
|
|
*/
|
|
self::assertEquals([], Arrays::trimRecursive([]));
|
|
|
|
/*
|
|
* Positive cases
|
|
*/
|
|
self::assertEquals(['a'], Arrays::trimRecursive([' a ']));
|
|
self::assertEquals([
|
|
'a',
|
|
'b',
|
|
], Arrays::trimRecursive([
|
|
' a ',
|
|
'b ',
|
|
]));
|
|
|
|
$array = [
|
|
'abc ',
|
|
[
|
|
'def',
|
|
'ghi ',
|
|
],
|
|
];
|
|
|
|
$result = [
|
|
'abc',
|
|
[
|
|
'def',
|
|
'ghi',
|
|
],
|
|
];
|
|
|
|
self::assertEquals($result, Arrays::trimRecursive($array));
|
|
|
|
$array = [
|
|
'abc ',
|
|
[
|
|
' def ',
|
|
'ghi ',
|
|
'oo' => [
|
|
' ee ',
|
|
'g' => 'h hhh ',
|
|
],
|
|
],
|
|
];
|
|
|
|
$result = [
|
|
'abc',
|
|
[
|
|
'def',
|
|
'ghi',
|
|
'oo' => [
|
|
'ee',
|
|
'g' => 'h hhh',
|
|
],
|
|
],
|
|
];
|
|
|
|
self::assertEquals($result, Arrays::trimRecursive($array));
|
|
}
|
|
|
|
public function testSortByCustomKeysOrder()
|
|
{
|
|
/*
|
|
* Negative cases
|
|
*/
|
|
self::assertNull(Arrays::sortByCustomKeysOrder([], []));
|
|
|
|
/*
|
|
* Positive cases
|
|
*/
|
|
self::assertEquals([0], Arrays::sortByCustomKeysOrder([0], []));
|
|
self::assertEquals($this->simpleArray, Arrays::sortByCustomKeysOrder($this->simpleArray, []));
|
|
|
|
$keysOrder = [
|
|
'amet',
|
|
'dolor',
|
|
'Lorem',
|
|
];
|
|
|
|
$sorted = [
|
|
'dolor' => 'sit',
|
|
'amet' => 'consectetur',
|
|
'Lorem' => 'ipsum',
|
|
];
|
|
|
|
self::assertEquals($sorted, Arrays::sortByCustomKeysOrder($this->simpleArrayWithKeys, $keysOrder));
|
|
|
|
$array = [
|
|
'Lorem',
|
|
'ipsum',
|
|
'dolor',
|
|
'sit',
|
|
'amet',
|
|
];
|
|
|
|
$keysOrder = [
|
|
0,
|
|
3,
|
|
1,
|
|
2,
|
|
];
|
|
|
|
$sorted = [
|
|
0 => 'Lorem',
|
|
3 => 'sit',
|
|
1 => 'ipsum',
|
|
2 => 'dolor',
|
|
4 => 'amet',
|
|
];
|
|
|
|
self::assertEquals($sorted, Arrays::sortByCustomKeysOrder($array, $keysOrder));
|
|
|
|
$array = [
|
|
'Lorem',
|
|
'ipsum',
|
|
'dolor',
|
|
'sit',
|
|
'amet',
|
|
];
|
|
|
|
$keysOrder = [
|
|
0,
|
|
3,
|
|
];
|
|
|
|
$sorted = [
|
|
0 => 'Lorem',
|
|
3 => 'sit',
|
|
1 => 'ipsum',
|
|
2 => 'dolor',
|
|
4 => 'amet',
|
|
];
|
|
|
|
self::assertEquals($sorted, Arrays::sortByCustomKeysOrder($array, $keysOrder));
|
|
}
|
|
|
|
public function testImplodeSmart()
|
|
{
|
|
$separator = '/';
|
|
|
|
/*
|
|
* Empty array
|
|
*/
|
|
self::assertEmpty(Arrays::implodeSmart([], $separator));
|
|
|
|
/*
|
|
* Simple, one-dimension array
|
|
*/
|
|
self::assertEquals(implode($separator, $this->simpleArray), Arrays::implodeSmart($this->simpleArray, $separator));
|
|
|
|
/*
|
|
* An array with elements that contain separator
|
|
*/
|
|
$array = [
|
|
'lorem' . $separator,
|
|
'ipsum',
|
|
$separator . 'dolor',
|
|
];
|
|
|
|
self::assertEquals(implode($separator, [
|
|
'lorem',
|
|
'ipsum',
|
|
'dolor',
|
|
]), Arrays::implodeSmart($array, $separator));
|
|
|
|
/*
|
|
* Complex array
|
|
*/
|
|
self::assertEquals(implode($separator, [
|
|
'donec',
|
|
'quis',
|
|
'elit',
|
|
]), Arrays::implodeSmart($this->complexArray['sit'], $separator));
|
|
}
|
|
|
|
public function testGetNextElement()
|
|
{
|
|
/*
|
|
* Negative cases
|
|
*/
|
|
self::assertNull(Arrays::getNextElement($this->simpleArray, 'amet'));
|
|
self::assertNull(Arrays::getNextElement($this->simpleArray, 'xyz'));
|
|
self::assertNull(Arrays::getNextElement($this->simpleArray, 0));
|
|
self::assertNull(Arrays::getNextElement([], ''));
|
|
self::assertNull(Arrays::getNextElement([], null));
|
|
|
|
/*
|
|
* Positive cases
|
|
*/
|
|
self::assertEquals('ipsum', Arrays::getNextElement($this->simpleArray, 'Lorem'));
|
|
self::assertEquals('sit', Arrays::getNextElement($this->simpleArray, 'dolor'));
|
|
}
|
|
|
|
public function testGetPreviousElement()
|
|
{
|
|
/*
|
|
* Negative cases
|
|
*/
|
|
self::assertNull(Arrays::getPreviousElement($this->simpleArray, 'Lorem'));
|
|
self::assertNull(Arrays::getPreviousElement($this->simpleArray, 'xyz'));
|
|
self::assertNull(Arrays::getPreviousElement($this->simpleArray, 0));
|
|
self::assertNull(Arrays::getPreviousElement([], ''));
|
|
self::assertNull(Arrays::getPreviousElement([], null));
|
|
|
|
/*
|
|
* Positive cases
|
|
*/
|
|
self::assertEquals('ipsum', Arrays::getPreviousElement($this->simpleArray, 'dolor'));
|
|
self::assertEquals('sit', Arrays::getPreviousElement($this->simpleArray, 'amet'));
|
|
}
|
|
|
|
public function testGetIndexOf()
|
|
{
|
|
/*
|
|
* Negative cases
|
|
*/
|
|
self::assertFalse(Arrays::getIndexOf([], 'a'));
|
|
self::assertNull(Arrays::getIndexOf($this->simpleArray, 'loremmm'));
|
|
|
|
/*
|
|
* Positive cases
|
|
*/
|
|
self::assertEquals(1, Arrays::getIndexOf($this->simpleArray, 'ipsum'));
|
|
self::assertEquals('dolor', Arrays::getIndexOf($this->simpleArrayWithKeys, 'sit'));
|
|
self::assertEquals('mollis', Arrays::getIndexOf($this->complexArray, 1234));
|
|
}
|
|
|
|
public function testIncrementIndexes()
|
|
{
|
|
/*
|
|
* Negative cases
|
|
*/
|
|
self::assertEquals([], Arrays::incrementIndexes([]));
|
|
|
|
/*
|
|
* Positive cases
|
|
*/
|
|
$array = [
|
|
1 => 'Lorem',
|
|
2 => 'ipsum',
|
|
3 => 'dolor',
|
|
4 => 'sit',
|
|
5 => 'amet',
|
|
];
|
|
self::assertEquals($array, Arrays::incrementIndexes($this->simpleArray));
|
|
|
|
$array = [
|
|
0 => 'Lorem',
|
|
2 => 'ipsum',
|
|
3 => 'dolor',
|
|
4 => 'sit',
|
|
5 => 'amet',
|
|
];
|
|
self::assertEquals($array, Arrays::incrementIndexes($this->simpleArray, 1));
|
|
|
|
$array = [
|
|
0 => 'Lorem',
|
|
1 => 'ipsum',
|
|
3 => 'dolor',
|
|
4 => 'sit',
|
|
5 => 'amet',
|
|
];
|
|
self::assertEquals($array, Arrays::incrementIndexes($this->simpleArray, 2));
|
|
}
|
|
|
|
public function testAreAllValuesEmpty()
|
|
{
|
|
/*
|
|
* Negative cases
|
|
*/
|
|
self::assertFalse(Arrays::areAllValuesEmpty([]));
|
|
self::assertFalse(Arrays::areAllValuesEmpty([], true));
|
|
self::assertFalse(Arrays::areAllValuesEmpty($this->simpleArray));
|
|
self::assertFalse(Arrays::areAllValuesEmpty($this->simpleArray, true));
|
|
|
|
$array = [
|
|
null,
|
|
0,
|
|
];
|
|
self::assertFalse(Arrays::areAllValuesEmpty($array, true));
|
|
|
|
$array = [
|
|
null,
|
|
[
|
|
null,
|
|
],
|
|
];
|
|
self::assertFalse(Arrays::areAllValuesEmpty($array, true));
|
|
|
|
/*
|
|
* Positive cases
|
|
*/
|
|
$array = [
|
|
'',
|
|
0,
|
|
];
|
|
self::assertTrue(Arrays::areAllValuesEmpty($array));
|
|
|
|
$array = [
|
|
null,
|
|
null,
|
|
];
|
|
self::assertTrue(Arrays::areAllValuesEmpty($array, true));
|
|
}
|
|
|
|
public function testDiffRecursive()
|
|
{
|
|
/*
|
|
* Negative cases
|
|
*/
|
|
self::assertEquals([], Arrays::arrayDiffRecursive([], []));
|
|
self::assertEquals([], Arrays::arrayDiffRecursive([], [], true));
|
|
|
|
/*
|
|
* Positive cases - full comparison (keys and values)
|
|
*/
|
|
self::assertEquals(['a'], Arrays::arrayDiffRecursive(['a'], []));
|
|
self::assertEquals([], Arrays::arrayDiffRecursive([], ['a']));
|
|
self::assertEquals([], Arrays::arrayDiffRecursive($this->simpleArray, $this->simpleArray));
|
|
|
|
$array = [
|
|
'Lorem',
|
|
'ipsum',
|
|
'dolor',
|
|
];
|
|
self::assertEquals([], Arrays::arrayDiffRecursive($array, $this->simpleArray));
|
|
|
|
$array = [
|
|
'Lorem',
|
|
'ipsum',
|
|
'dolor',
|
|
];
|
|
|
|
$diff = [
|
|
3 => 'sit',
|
|
4 => 'amet',
|
|
];
|
|
self::assertEquals($diff, Arrays::arrayDiffRecursive($this->simpleArray, $array));
|
|
|
|
$array1 = [
|
|
[
|
|
'a',
|
|
'b',
|
|
'c',
|
|
],
|
|
[
|
|
'd',
|
|
'e',
|
|
],
|
|
];
|
|
|
|
$array2 = [
|
|
[
|
|
'a',
|
|
'b',
|
|
],
|
|
'f',
|
|
];
|
|
|
|
$diff = [
|
|
[
|
|
2 => 'c',
|
|
],
|
|
];
|
|
self::assertEquals($diff, Arrays::arrayDiffRecursive($array1, $array2));
|
|
|
|
self::assertEquals($this->twoDimensionsArray[1], Arrays::arrayDiffRecursive($this->twoDimensionsArray[1], $this->twoDimensionsArray));
|
|
|
|
/*
|
|
* Positive cases - simple comparison (values only)
|
|
*/
|
|
self::assertEquals(['a'], Arrays::arrayDiffRecursive(['a'], [], true));
|
|
|
|
$array = [
|
|
'amet',
|
|
'sit',
|
|
1234,
|
|
'ipsum',
|
|
];
|
|
|
|
$diff = [
|
|
0 => 'Lorem',
|
|
2 => 'dolor',
|
|
];
|
|
|
|
self::assertEquals($diff, Arrays::arrayDiffRecursive($this->simpleArray, $array, true));
|
|
|
|
$array = [
|
|
[
|
|
'lorem',
|
|
'ipsum',
|
|
'dolor',
|
|
],
|
|
[
|
|
'consectetur',
|
|
'adipiscing',
|
|
],
|
|
[
|
|
'sagittis',
|
|
],
|
|
];
|
|
|
|
$diff = [
|
|
[
|
|
3 => 'sit',
|
|
4 => 'amet',
|
|
],
|
|
[
|
|
2 => 'elit',
|
|
],
|
|
[
|
|
0 => 'donec',
|
|
2 => 'fringilla',
|
|
3 => 'eleifend',
|
|
],
|
|
];
|
|
|
|
self::assertEquals($diff, Arrays::arrayDiffRecursive($this->twoDimensionsArray, $array, true));
|
|
|
|
$array = [
|
|
[
|
|
'lorem',
|
|
'ipsum',
|
|
'dolor',
|
|
],
|
|
[
|
|
'consectetur',
|
|
'adipiscing',
|
|
],
|
|
'Lorem ipsum',
|
|
];
|
|
|
|
$diff = [
|
|
[
|
|
3 => 'sit',
|
|
4 => 'amet',
|
|
],
|
|
[
|
|
2 => 'elit',
|
|
],
|
|
];
|
|
|
|
self::assertEquals($diff, Arrays::arrayDiffRecursive($this->twoDimensionsArray, $array, true));
|
|
|
|
$array = [
|
|
'Lorem ipsum',
|
|
[
|
|
'lorem',
|
|
'ipsum',
|
|
'dolor',
|
|
],
|
|
'donec sagittis',
|
|
];
|
|
|
|
$diff = [
|
|
0 => 'Lorem ipsum',
|
|
1 => [
|
|
'lorem',
|
|
'ipsum',
|
|
'dolor',
|
|
],
|
|
2 => 'donec sagittis',
|
|
];
|
|
|
|
self::assertEquals($diff, Arrays::arrayDiffRecursive($array, $this->twoDimensionsArray, true));
|
|
}
|
|
|
|
public function testGetDimensionsCount()
|
|
{
|
|
/*
|
|
* Basic cases
|
|
*/
|
|
self::assertEquals(1, Arrays::getDimensionsCount([]));
|
|
self::assertEquals(1, Arrays::getDimensionsCount(['']));
|
|
|
|
/*
|
|
* Simple cases
|
|
*/
|
|
self::assertEquals(1, Arrays::getDimensionsCount($this->simpleArray));
|
|
self::assertEquals(1, Arrays::getDimensionsCount($this->simpleArrayWithKeys));
|
|
|
|
/*
|
|
* Complex cases
|
|
*/
|
|
self::assertEquals(2, Arrays::getDimensionsCount($this->twoDimensionsArray));
|
|
self::assertEquals(4, Arrays::getDimensionsCount($this->complexArray));
|
|
}
|
|
|
|
public function testIsMultiDimensional()
|
|
{
|
|
/*
|
|
* Negative cases
|
|
*/
|
|
self::assertNull(Arrays::isMultiDimensional([]));
|
|
|
|
/*
|
|
* Positive cases
|
|
*/
|
|
self::assertFalse(Arrays::isMultiDimensional($this->simpleArray));
|
|
self::assertFalse(Arrays::isMultiDimensional($this->simpleArrayWithKeys));
|
|
|
|
self::assertTrue(Arrays::isMultiDimensional($this->twoDimensionsArray));
|
|
self::assertTrue(Arrays::isMultiDimensional($this->complexArray));
|
|
}
|
|
|
|
/**
|
|
* Provides simple array to set/replace values with keys
|
|
*
|
|
* @return \Generator
|
|
*/
|
|
public function provideSimpleArrayToSetKeysAsValues()
|
|
{
|
|
yield[
|
|
[
|
|
1,
|
|
2,
|
|
3,
|
|
4,
|
|
],
|
|
[
|
|
1 => 0,
|
|
2 => 1,
|
|
3 => 2,
|
|
4 => 3,
|
|
],
|
|
];
|
|
|
|
yield[
|
|
[
|
|
'Lorem',
|
|
'ipsum',
|
|
'dolor',
|
|
'sit',
|
|
'amet',
|
|
],
|
|
[
|
|
'Lorem' => 0,
|
|
'ipsum' => 1,
|
|
'dolor' => 2,
|
|
'sit' => 3,
|
|
'amet' => 4,
|
|
],
|
|
];
|
|
}
|
|
|
|
/**
|
|
* Provides an array with duplicated values to set/replace values with keys
|
|
*
|
|
* @return \Generator
|
|
*/
|
|
public function provideArrayWithDuplicatedValuesToSetKeysAsValues()
|
|
{
|
|
yield[
|
|
[
|
|
'lorem' => 'ipsum',
|
|
'dolor' => 'ipsum',
|
|
'sit' => 'amet',
|
|
'diam' => 'non',
|
|
'elit' => 'non',
|
|
'in' => 'non',
|
|
],
|
|
[
|
|
'ipsum' => [
|
|
'lorem',
|
|
'dolor',
|
|
],
|
|
'amet' => 'sit',
|
|
'non' => [
|
|
'diam',
|
|
'elit',
|
|
'in',
|
|
],
|
|
],
|
|
];
|
|
|
|
yield[
|
|
[
|
|
'lorem' => [
|
|
'diam' => 'non',
|
|
'elit' => 'non',
|
|
'in' => 'non',
|
|
],
|
|
'dolor1' => 'ipsum',
|
|
'dolor2' => 'ipsum',
|
|
'sit' => 'amet',
|
|
],
|
|
[
|
|
'lorem' => [
|
|
'non' => [
|
|
'diam',
|
|
'elit',
|
|
'in',
|
|
],
|
|
],
|
|
'ipsum' => [
|
|
'dolor1',
|
|
'dolor2',
|
|
],
|
|
'amet' => 'sit',
|
|
],
|
|
];
|
|
}
|
|
|
|
/**
|
|
* {@inheritdoc}
|
|
*/
|
|
protected function setUp()
|
|
{
|
|
parent::setUp();
|
|
|
|
$this->simpleArray = [
|
|
'Lorem',
|
|
'ipsum',
|
|
'dolor',
|
|
'sit',
|
|
'amet',
|
|
];
|
|
|
|
$this->simpleArrayWithKeys = [
|
|
'Lorem' => 'ipsum',
|
|
'dolor' => 'sit',
|
|
'amet' => 'consectetur',
|
|
];
|
|
|
|
$this->twoDimensionsArray = [
|
|
[
|
|
'lorem',
|
|
'ipsum',
|
|
'dolor',
|
|
'sit',
|
|
'amet',
|
|
],
|
|
[
|
|
'consectetur',
|
|
'adipiscing',
|
|
'elit',
|
|
],
|
|
[
|
|
'donec',
|
|
'sagittis',
|
|
'fringilla',
|
|
'eleifend',
|
|
],
|
|
];
|
|
|
|
$this->complexArray = [
|
|
'lorem' => [
|
|
'ipsum' => [
|
|
'dolor' => 'sit',
|
|
'diam' => [
|
|
'non' => 'egestas',
|
|
],
|
|
],
|
|
],
|
|
'consectetur' => 'adipiscing',
|
|
'mollis' => 1234,
|
|
2 => [],
|
|
'sit' => [
|
|
'nullam' => 'donec',
|
|
'aliquet' => [
|
|
'vitae' => [
|
|
'ligula' => 'quis',
|
|
],
|
|
],
|
|
'elit',
|
|
],
|
|
'amet' => [
|
|
'iaculis',
|
|
'primis',
|
|
],
|
|
];
|
|
|
|
$this->superComplexArray = [
|
|
'ipsum' => [
|
|
'quis' => [
|
|
'vestibulum' => [
|
|
'porta-1' => [
|
|
'turpis',
|
|
'urna',
|
|
],
|
|
'porta-2' => [
|
|
'tortor' => [
|
|
'in' => [
|
|
'dui',
|
|
'dolor' => [
|
|
'aliquam',
|
|
],
|
|
],
|
|
],
|
|
],
|
|
'porta-3' => [
|
|
1,
|
|
2,
|
|
3,
|
|
],
|
|
],
|
|
],
|
|
],
|
|
'primis' => [
|
|
[
|
|
'in',
|
|
'faucibus',
|
|
'orci',
|
|
],
|
|
[
|
|
'luctus',
|
|
'et',
|
|
'ultrices',
|
|
],
|
|
],
|
|
];
|
|
}
|
|
|
|
/**
|
|
* {@inheritdoc}
|
|
*/
|
|
protected function tearDown()
|
|
{
|
|
parent::tearDown();
|
|
|
|
unset($this->simpleArray);
|
|
unset($this->simpleArrayWithKeys);
|
|
unset($this->twoDimensionsArray);
|
|
unset($this->complexArray);
|
|
unset($this->superComplexArray);
|
|
}
|
|
}
|