ArrayFunctionTests::testCanUseColumn() - Code Metrics - Inspection of "Feature/update readme" - gin0115/pinkcrab_function_constructors - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — develop (#27)

by Glynn

created 2022-05-20 22:24 UTC

ArrayFunctionTests::testCanUseColumn() A

↳ Parent: Project

Complexity

Conditions	1
Paths	1

Size

Total Lines	57
Code Lines	44

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	44
nc	1
nop	0
dl	0
loc	57
rs	9.216
c	0
b	0
f	0

How to fix Long Method

<?php

declare(strict_types=1);

require_once dirname(__FILE__, 2) . '/FunctionsLoader.php';

/**
 * Tests for the Array functions class.
 *
 * @since 0.1.0
 * @author Glynn Quelch <[email protected]>
 */

use PHPUnit\Framework\TestCase;
use PinkCrab\FunctionConstructors\Arrays as Arr;
use PinkCrab\FunctionConstructors\Numbers as Num;
use PinkCrab\FunctionConstructors\Strings as Str;
use PinkCrab\FunctionConstructors\FunctionsLoader;
use PinkCrab\FunctionConstructors\GeneralFunctions as Func;

use function PHPUnit\Framework\throwException;

/**
 * ArrayFunction class.
 */
class ArrayFunctionTests extends TestCase
{
    /**
     * Random pollyfills
     */
    public function __call($method, $params)
    {
        switch ($method) {
            case 'assertIsArray':
                $this->assertTrue(is_array($params));
                break;
        }
    }

    public function setup(): void
    {
        FunctionsLoader::include();
    }

    public function testCanPushToHead(): void
    {
        $pushToHead = Arr\pushHead(array(3, 4, 5, 6));
        $added2     = $pushToHead(2);
        $this->assertEquals(2, $added2[0]);

        $pushToHead = Arr\pushHead($added2);
        $added1     = $pushToHead(1);
        $this->assertEquals(1, $added1[0]);

        // As curried.
        $curried = Arr\pushHead(array(3, 4, 5, 6))(2);
        $this->assertEquals(2, $curried[0]);
    }

    public function testCanPushToTail(): void
    {
        $pushToTail = Arr\pushTail(array(1, 2, 3, 4));
        $added2     = $pushToTail(5);
        $this->assertEquals(5, $added2[4]);

        $pushToTail = Arr\pushTail($added2);
        $added1     = $pushToTail(6);
        $this->assertEquals(6, $added1[5]);

        // As curried.
        $curried = Arr\pushTail(array(1, 2, 3, 4))(5);
        $this->assertEquals(5, $curried[4]);
    }

    public function testCanUseTail()
    {
        $names = array('Sam Smith', 'Barry Smith', 'Sam Power', 'Rebecca Smith');
        $this->assertEquals('Rebecca Smith', Arr\tail($names));
        // Check returns null if empty.
        $this->assertNull(Arr\tail(array()));
    }

    public function testCanUseHead()
    {
        $names = array('Sam Smith', 'Barry Smith', 'Sam Power', 'Rebecca Smith');
        $this->assertEquals('Sam Smith', Arr\head($names));
        // Check returns null if empty.
        $this->assertNull(Arr\head(array()));
    }

    public function testCanCompileArray(): void
    {
        $arrayCompiler = Arr\arrayCompiler();
        $arrayCompiler = $arrayCompiler('Hello');
        $arrayCompiler = $arrayCompiler('ERROR');
        $this->assertEquals('Hello', $arrayCompiler()[0]);
        $this->assertEquals('ERROR', $arrayCompiler()[1]);

        // As curried
        $arrayCompiler = $arrayCompiler('NO PLEASE GOD NO')('what')('more');
        $this->assertEquals('NO PLEASE GOD NO', $arrayCompiler()[2]);
        $this->assertEquals('what', $arrayCompiler()[3]);
        $this->assertEquals('more', $arrayCompiler()[4]);

        // Test can output on invoke.
        $this->assertTrue(is_array($arrayCompiler()));
    }

    public function testCanCompileArrayTyped()
    {
        $arrayCompiler = Arr\arrayCompilerTyped('is_string');
        $arrayCompiler = $arrayCompiler('Hello');
        $arrayCompiler = $arrayCompiler('ERROR');
        $arrayCompiler = $arrayCompiler(array('ERROR'));
        $this->assertCount(2, $arrayCompiler());

        $arrayCompiler = $arrayCompiler('Hello')(1)(NAN)('so 4?');
        $this->assertCount(4, $arrayCompiler());
    }

    public function testCanGroupByArray(): void
    {
        $groupByPerfectNumbers = Arr\groupBy(
            function ($e) {
                return in_array($e, array(1, 2, 3, 6, 12)) ? 'Perfect' : 'Not Perfect';
            }
        );

        $grouped = $groupByPerfectNumbers(range(1, 12));

        $this->assertArrayHasKey('Perfect', $grouped);
        $this->assertArrayHasKey('Not Perfect', $grouped);
        $this->assertContains(1, $grouped['Perfect']);
        $this->assertContains(2, $grouped['Perfect']);
        $this->assertContains(3, $grouped['Perfect']);
        $this->assertContains(5, $grouped['Not Perfect']);
        $this->assertContains(7, $grouped['Not Perfect']);
        $this->assertContains(9, $grouped['Not Perfect']);
    }

    public function testCanChunk(): void
    {
        $chunkIn5     = Arr\chunk(5);
        $chunkedRange = $chunkIn5(range(1, 500));
        $this->assertCount(100, $chunkedRange);
        $this->assertCount(5, $chunkedRange[5]);
        $this->assertCount(5, $chunkedRange[78]);

        // Check that keys are retained.
        $chunkInPairs = Arr\chunk(2, true);
        $chunkedNames = $chunkInPairs(array('Jim', 'Bob', 'Gem', 'Fay'));
        $this->assertCount(2, $chunkedNames);
        $this->assertEquals('Bob', $chunkedNames[0][1]);
        $this->assertEquals('Fay', $chunkedNames[1][3]);
    }

    public function testCanUseZip()
    {
        $array = ['a', 'b', 'c'];

        // Missing Key.
        $arrayMissing = ['A', 'B'];
        $expectedMissing = [['a', 'A'], ['b', 'B'], ['c', 'FALLBACK']];
        $resultMissing = Arr\zip($arrayMissing, 'FALLBACK')($array);
        $this->assertSame($resultMissing, $expectedMissing);

        // Matching length.
        $arrayFull = ['A', 'B', 'C'];
        $expectedFull = [['a', 'A'], ['b', 'B'], ['c', 'C']];
        $resultFull = Arr\zip($arrayFull, 'FALLBACK')($array);
        $this->assertSame($resultFull, $expectedFull);
    }

    public function testCanUseColumn(): void
    {
        $data = array(
            array(
                'id'   => 41,
                'name' => 'Bob',
                'foo'  => rand(1, 7),
            ),
            array(
                'id'   => 26,
                'name' => 'Jane',
                'foo'  => rand(1, 7),
            ),
            array(
                'id'   => 53,
                'name' => 'Sam',
                'foo'  => rand(1, 7),
            ),
            array(
                'id'   => 64,
                'name' => 'Bev',
                'foo'  => rand(1, 7),
            ),
            array(
                'id'   => 55,
                'name' => 'Joan',
                'foo'  => rand(1, 7),
            ),
            array(
                'id'   => 644,
                'name' => 'Bazza',
                'foo'  => rand(1, 7),
            ),
            array(
                'id'   => 66667,
                'name' => 'Duke',
                'foo'  => rand(1, 7),
            ),
            array(
                'id'   => 666668,
                'name' => 'Guybrush',
                'foo'  => rand(1, 7),
            ),
        );

        $getUsersNames = Arr\column('name', 'id');
        $this->assertCount(8, $getUsersNames($data));
        $this->assertEquals('Bob', $getUsersNames($data)[41]);
        $this->assertEquals('Bev', $getUsersNames($data)[64]);
        $this->assertEquals('Guybrush', $getUsersNames($data)[666668]);

        $getUsersRandoms = Arr\column('foo', 'name');
        $this->assertCount(8, $getUsersRandoms($data));
        $this->assertArrayHasKey('Bev', $getUsersRandoms($data));
        $this->assertArrayHasKey('Duke', $getUsersRandoms($data));
        $this->assertArrayNotHasKey(2, $getUsersRandoms($data));
        $this->assertArrayHasKey('Bazza', $getUsersRandoms($data));
    }

    public function testCanFlattenArray(): void
    {
        $array = array(
            1,
            2,
            array(3, 4),
            array(
                5,
                6,
                7,
                8,
                array(
                    9,
                    10,
                    array(11, 12, 13),
                ),
            ),
        );
        $this->assertArrayHasKey(2, Arr\flattenByN(2)($array));
        $this->assertIsArray(Arr\flattenByN(1)($array)[8]);

        $this->assertArrayHasKey(9, Arr\flattenByN(2)($array));
        $this->assertIsArray(Arr\flattenByN(2)($array)[10]);

        $this->assertArrayHasKey(12, Arr\flattenByN(3)($array));
        $this->assertEquals(13, Arr\flattenByN(3)($array)[12]);

        // Check will fully flatten if no depth defined.
        $this->assertArrayHasKey(12, Arr\flattenByN()($array));
        $this->assertEquals(13, Arr\flattenByN()($array)[12]);
    }

    public function testCanUseReplace()
    {
        $base          = array('orange', 'banana', 'apple', 'raspberry');
        $replacements  = array(
            0 => 'pineapple',
            4 => 'cherry',
        );
        $replacements2 = array(0 => 'grape');

        $replaceItems = Arr\replace($replacements, $replacements2);

        $this->assertIsArray($replaceItems($base));
        $this->assertEquals('grape', $replaceItems($base)[0]);
        $this->assertEquals('banana', $replaceItems($base)[1]);
        $this->assertEquals('apple', $replaceItems($base)[2]);
        $this->assertEquals('raspberry', $replaceItems($base)[3]);
        $this->assertEquals('cherry', $replaceItems($base)[4]);
    }
    public function testCanUseReplaceRecursive(): void
    {
        $base = array(
            'citrus'  => array('orange'),
            'berries' => array('apple', 'raspberry'),
        );

        $replacements = array(
            'citrus'  => array('pineapple'),
            'berries' => array('blueberry'),
        );

        $replaceItems = Arr\replaceRecursive($replacements);

        $this->assertIsArray($replaceItems($base));
        $this->assertArrayHasKey('citrus', $replaceItems($base));
        $this->assertArrayHasKey('berries', $replaceItems($base));
        $this->assertEquals('pineapple', $replaceItems($base)['citrus'][0]);
        $this->assertEquals('raspberry', $replaceItems($base)['berries'][1]);
    }

    public function testCanUseSumWhere()
    {
        $data = array(
            (object) array(
                'id'   => 1,
                'cost' => 12.55,
            ),
            (object) array(
                'id'   => 3,
                'cost' => 2.45,
            ),
            (object) array(
                'id'   => 34,
                'cost' => 99.99,
            ),
            (object) array(
                'id'   => 12,
                'cost' => 100.01,
            ),
        );

        $costSum = Arr\sumWhere(
            function ($e) {
                return $e->cost;
            }
        );

        $this->assertEquals(215.00, $costSum($data));
    }



    public function testCanSortArray(): void
    {
        $array         = array('b', 'c', 'a', 'f', 'd', 'z', 'g');
        $sortAsStrings = Arr\sort(SORT_STRING);

        $sortedArray = $sortAsStrings($array);
        $this->assertEquals('a', $sortedArray[0]);
        $this->assertEquals('b', $sortedArray[1]);
        $this->assertEquals('c', $sortedArray[2]);
        $this->assertEquals('z', $sortedArray[6]);

        // Check hasnt changed inital array.
        $this->assertEquals('c', $array[1]);
        $this->assertEquals('a', $array[2]);
    }

    public function testCanDoUasortOnArray(): void
    {
        $array = array(
            'a' => 4,
            'b' => 8,
            'c' => -1,
            'd' => -9,
            'e' => 2,
            'f' => 5,
            'g' => 3,
            'h' => -4,
        );

        $lowestFirstCallback = function ($a, $b) {
            if ($a == $b) {
                return 0;
            }
            return ($a < $b) ? -1 : 1;
        };

        $sortByLowest = Arr\uasort($lowestFirstCallback);

        // Still retains the key.
        $sortedArray = $sortByLowest($array);

        $this->assertEquals(-9, $sortedArray['d']);
        $this->assertEquals(-9, array_values($sortedArray)[0]);

        $this->assertEquals(2, $sortedArray['e']);
        $this->assertEquals(2, array_values($sortedArray)[3]);

        $this->assertEquals(8, $sortedArray['b']);
        $this->assertEquals(8, array_values($sortedArray)[7]);
    }


    public function testCanDoUsortOnArray(): void
    {
        $array = array(3, 2, 5, 6, 1);

        $lowestFirstCallback = function ($a, $b) {
            if ($a == $b) {
                return 0;
            }
            return ($a < $b) ? -1 : 1;
        };

        $sortByLowest = Arr\usort($lowestFirstCallback);

        // Still retains the key.
        $sortedArray = $sortByLowest($array);

        $this->assertEquals(1, $sortedArray[0]);
        $this->assertEquals(2, $sortedArray[1]);
        $this->assertEquals(5, $sortedArray[3]);
        $this->assertEquals(6, $sortedArray[4]);
    }

    public function testCanPartitionTable()
    {
        $isEven = function ($e) {
            return $e % 2 === 0;
        };

        $sortByOddEven = Arr\partition($isEven);

        $data = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

        $sorted = $sortByOddEven($data);
        $this->assertCount(5, $sorted[0]);
        $this->assertCount(5, $sorted[1]);

        $this->assertContains(2, $sorted[1]);
        $this->assertContains(4, $sorted[1]);
        $this->assertContains(8, $sorted[1]);
        $this->assertContains(3, $sorted[0]);
        $this->assertContains(7, $sorted[0]);
    }

    public function testCanDoToString(): void
    {
        $source = array(
            'hi',
            'there',
            'how',
            'are',
            'you',
            3,
            12.7,
            true,
            null,
        );

        $noSpacing   = Arr\toString();
        $withSpacing = Arr\toString(' ');

        $this->assertEquals('hitherehowareyou312.71', $noSpacing($source));
        $this->assertEquals('hi there how are you 3 12.7 1 ', $withSpacing($source));
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			require_once dirname(__FILE__, 2) . '/FunctionsLoader.php';
6
7			/**
8			* Tests for the Array functions class.
9			*
10			* @since 0.1.0
11			* @author Glynn Quelch <[email protected]>
12			*/
13
14			use PHPUnit\Framework\TestCase;
15			use PinkCrab\FunctionConstructors\Arrays as Arr;
16			use PinkCrab\FunctionConstructors\Numbers as Num;
17			use PinkCrab\FunctionConstructors\Strings as Str;
18			use PinkCrab\FunctionConstructors\FunctionsLoader;
19			use PinkCrab\FunctionConstructors\GeneralFunctions as Func;
20
21			use function PHPUnit\Framework\throwException;
22
23			/**
24			* ArrayFunction class.
25			*/
26			class ArrayFunctionTests extends TestCase
27			{
28			/**
29			* Random pollyfills
30			*/
31			public function __call($method, $params)
32			{
33			switch ($method) {
34			case 'assertIsArray':
35			$this->assertTrue(is_array($params));
36			break;
37			}
38			}
39
40			public function setup(): void
41			{
42			FunctionsLoader::include();
43			}
44
45			public function testCanPushToHead(): void
46			{
47			$pushToHead = Arr\pushHead(array(3, 4, 5, 6));
48			$added2 = $pushToHead(2);
49			$this->assertEquals(2, $added2[0]);
50
51			$pushToHead = Arr\pushHead($added2);
52			$added1 = $pushToHead(1);
53			$this->assertEquals(1, $added1[0]);
54
55			// As curried.
56			$curried = Arr\pushHead(array(3, 4, 5, 6))(2);
57			$this->assertEquals(2, $curried[0]);
58			}
59
60			public function testCanPushToTail(): void
61			{
62			$pushToTail = Arr\pushTail(array(1, 2, 3, 4));
63			$added2 = $pushToTail(5);
64			$this->assertEquals(5, $added2[4]);
65
66			$pushToTail = Arr\pushTail($added2);
67			$added1 = $pushToTail(6);
68			$this->assertEquals(6, $added1[5]);
69
70			// As curried.
71			$curried = Arr\pushTail(array(1, 2, 3, 4))(5);
72			$this->assertEquals(5, $curried[4]);
73			}
74
75			public function testCanUseTail()
76			{
77			$names = array('Sam Smith', 'Barry Smith', 'Sam Power', 'Rebecca Smith');
78			$this->assertEquals('Rebecca Smith', Arr\tail($names));
79			// Check returns null if empty.
80			$this->assertNull(Arr\tail(array()));
81			}
82
83			public function testCanUseHead()
84			{
85			$names = array('Sam Smith', 'Barry Smith', 'Sam Power', 'Rebecca Smith');
86			$this->assertEquals('Sam Smith', Arr\head($names));
87			// Check returns null if empty.
88			$this->assertNull(Arr\head(array()));
89			}
90
91			public function testCanCompileArray(): void
92			{
93			$arrayCompiler = Arr\arrayCompiler();
94			$arrayCompiler = $arrayCompiler('Hello');
95			$arrayCompiler = $arrayCompiler('ERROR');
96			$this->assertEquals('Hello', $arrayCompiler()[0]);
97			$this->assertEquals('ERROR', $arrayCompiler()[1]);
98
99			// As curried
100			$arrayCompiler = $arrayCompiler('NO PLEASE GOD NO')('what')('more');
101			$this->assertEquals('NO PLEASE GOD NO', $arrayCompiler()[2]);
102			$this->assertEquals('what', $arrayCompiler()[3]);
103			$this->assertEquals('more', $arrayCompiler()[4]);
104
105			// Test can output on invoke.
106			$this->assertTrue(is_array($arrayCompiler()));
107			}
108
109			public function testCanCompileArrayTyped()
110			{
111			$arrayCompiler = Arr\arrayCompilerTyped('is_string');
112			$arrayCompiler = $arrayCompiler('Hello');
113			$arrayCompiler = $arrayCompiler('ERROR');
114			$arrayCompiler = $arrayCompiler(array('ERROR'));
115			$this->assertCount(2, $arrayCompiler());
116
117			$arrayCompiler = $arrayCompiler('Hello')(1)(NAN)('so 4?');
118			$this->assertCount(4, $arrayCompiler());
119			}
120
121			public function testCanGroupByArray(): void
122			{
123			$groupByPerfectNumbers = Arr\groupBy(
124			function ($e) {
125			return in_array($e, array(1, 2, 3, 6, 12)) ? 'Perfect' : 'Not Perfect';
126			}
127			);
128
129			$grouped = $groupByPerfectNumbers(range(1, 12));
130
131			$this->assertArrayHasKey('Perfect', $grouped);
132			$this->assertArrayHasKey('Not Perfect', $grouped);
133			$this->assertContains(1, $grouped['Perfect']);
134			$this->assertContains(2, $grouped['Perfect']);
135			$this->assertContains(3, $grouped['Perfect']);
136			$this->assertContains(5, $grouped['Not Perfect']);
137			$this->assertContains(7, $grouped['Not Perfect']);
138			$this->assertContains(9, $grouped['Not Perfect']);
139			}
140
141			public function testCanChunk(): void
142			{
143			$chunkIn5 = Arr\chunk(5);
144			$chunkedRange = $chunkIn5(range(1, 500));
145			$this->assertCount(100, $chunkedRange);
146			$this->assertCount(5, $chunkedRange[5]);
147			$this->assertCount(5, $chunkedRange[78]);
148
149			// Check that keys are retained.
150			$chunkInPairs = Arr\chunk(2, true);
151			$chunkedNames = $chunkInPairs(array('Jim', 'Bob', 'Gem', 'Fay'));
152			$this->assertCount(2, $chunkedNames);
153			$this->assertEquals('Bob', $chunkedNames[0][1]);
154			$this->assertEquals('Fay', $chunkedNames[1][3]);
155			}
156
157			public function testCanUseZip()
158			{
159			$array = ['a', 'b', 'c'];
160
161			// Missing Key.
162			$arrayMissing = ['A', 'B'];
163			$expectedMissing = [['a', 'A'], ['b', 'B'], ['c', 'FALLBACK']];
164			$resultMissing = Arr\zip($arrayMissing, 'FALLBACK')($array);
165			$this->assertSame($resultMissing, $expectedMissing);
166
167			// Matching length.
168			$arrayFull = ['A', 'B', 'C'];
169			$expectedFull = [['a', 'A'], ['b', 'B'], ['c', 'C']];
170			$resultFull = Arr\zip($arrayFull, 'FALLBACK')($array);
171			$this->assertSame($resultFull, $expectedFull);
172			}
173
174			public function testCanUseColumn(): void
175			{
176			$data = array(
177			array(
178			'id' => 41,
179			'name' => 'Bob',
180			'foo' => rand(1, 7),
181			),
182			array(
183			'id' => 26,
184			'name' => 'Jane',
185			'foo' => rand(1, 7),
186			),
187			array(
188			'id' => 53,
189			'name' => 'Sam',
190			'foo' => rand(1, 7),
191			),
192			array(
193			'id' => 64,
194			'name' => 'Bev',
195			'foo' => rand(1, 7),
196			),
197			array(
198			'id' => 55,
199			'name' => 'Joan',
200			'foo' => rand(1, 7),
201			),
202			array(
203			'id' => 644,
204			'name' => 'Bazza',
205			'foo' => rand(1, 7),
206			),
207			array(
208			'id' => 66667,
209			'name' => 'Duke',
210			'foo' => rand(1, 7),
211			),
212			array(
213			'id' => 666668,
214			'name' => 'Guybrush',
215			'foo' => rand(1, 7),
216			),
217			);
218
219			$getUsersNames = Arr\column('name', 'id');
220			$this->assertCount(8, $getUsersNames($data));
221			$this->assertEquals('Bob', $getUsersNames($data)[41]);
222			$this->assertEquals('Bev', $getUsersNames($data)[64]);
223			$this->assertEquals('Guybrush', $getUsersNames($data)[666668]);
224
225			$getUsersRandoms = Arr\column('foo', 'name');
226			$this->assertCount(8, $getUsersRandoms($data));
227			$this->assertArrayHasKey('Bev', $getUsersRandoms($data));
228			$this->assertArrayHasKey('Duke', $getUsersRandoms($data));
229			$this->assertArrayNotHasKey(2, $getUsersRandoms($data));
230			$this->assertArrayHasKey('Bazza', $getUsersRandoms($data));
231			}
232
233			public function testCanFlattenArray(): void
234			{
235			$array = array(
236			1,
237			2,
238			array(3, 4),
239			array(
240			5,
241			6,
242			7,
243			8,
244			array(
245			9,
246			10,
247			array(11, 12, 13),
248			),
249			),
250			);
251			$this->assertArrayHasKey(2, Arr\flattenByN(2)($array));
252			$this->assertIsArray(Arr\flattenByN(1)($array)[8]);
253
254			$this->assertArrayHasKey(9, Arr\flattenByN(2)($array));
255			$this->assertIsArray(Arr\flattenByN(2)($array)[10]);
256
257			$this->assertArrayHasKey(12, Arr\flattenByN(3)($array));
258			$this->assertEquals(13, Arr\flattenByN(3)($array)[12]);
259
260			// Check will fully flatten if no depth defined.
261			$this->assertArrayHasKey(12, Arr\flattenByN()($array));
262			$this->assertEquals(13, Arr\flattenByN()($array)[12]);
263			}
264
265			public function testCanUseReplace()
266			{
267			$base = array('orange', 'banana', 'apple', 'raspberry');
268			$replacements = array(
269			0 => 'pineapple',
270			4 => 'cherry',
271			);
272			$replacements2 = array(0 => 'grape');
273
274			$replaceItems = Arr\replace($replacements, $replacements2);
275
276			$this->assertIsArray($replaceItems($base));
277			$this->assertEquals('grape', $replaceItems($base)[0]);
278			$this->assertEquals('banana', $replaceItems($base)[1]);
279			$this->assertEquals('apple', $replaceItems($base)[2]);
280			$this->assertEquals('raspberry', $replaceItems($base)[3]);
281			$this->assertEquals('cherry', $replaceItems($base)[4]);
282			}
283			public function testCanUseReplaceRecursive(): void
284			{
285			$base = array(
286			'citrus' => array('orange'),
287			'berries' => array('apple', 'raspberry'),
288			);
289
290			$replacements = array(
291			'citrus' => array('pineapple'),
292			'berries' => array('blueberry'),
293			);
294
295			$replaceItems = Arr\replaceRecursive($replacements);
296
297			$this->assertIsArray($replaceItems($base));
298			$this->assertArrayHasKey('citrus', $replaceItems($base));
299			$this->assertArrayHasKey('berries', $replaceItems($base));
300			$this->assertEquals('pineapple', $replaceItems($base)['citrus'][0]);
301			$this->assertEquals('raspberry', $replaceItems($base)['berries'][1]);
302			}
303
304			public function testCanUseSumWhere()
305			{
306			$data = array(
307			(object) array(
308			'id' => 1,
309			'cost' => 12.55,
310			),
311			(object) array(
312			'id' => 3,
313			'cost' => 2.45,
314			),
315			(object) array(
316			'id' => 34,
317			'cost' => 99.99,
318			),
319			(object) array(
320			'id' => 12,
321			'cost' => 100.01,
322			),
323			);
324
325			$costSum = Arr\sumWhere(
326			function ($e) {
327			return $e->cost;
328			}
329			);
330
331			$this->assertEquals(215.00, $costSum($data));
332			}
333
334
335
336			public function testCanSortArray(): void
337			{
338			$array = array('b', 'c', 'a', 'f', 'd', 'z', 'g');
339			$sortAsStrings = Arr\sort(SORT_STRING);
340
341			$sortedArray = $sortAsStrings($array);
342			$this->assertEquals('a', $sortedArray[0]);
343			$this->assertEquals('b', $sortedArray[1]);
344			$this->assertEquals('c', $sortedArray[2]);
345			$this->assertEquals('z', $sortedArray[6]);
346
347			// Check hasnt changed inital array.
348			$this->assertEquals('c', $array[1]);
349			$this->assertEquals('a', $array[2]);
350			}
351
352			public function testCanDoUasortOnArray(): void
353			{
354			$array = array(
355			'a' => 4,
356			'b' => 8,
357			'c' => -1,
358			'd' => -9,
359			'e' => 2,
360			'f' => 5,
361			'g' => 3,
362			'h' => -4,
363			);
364
365			$lowestFirstCallback = function ($a, $b) {
366			if ($a == $b) {
367			return 0;
368			}
369			return ($a < $b) ? -1 : 1;
370			};
371
372			$sortByLowest = Arr\uasort($lowestFirstCallback);
373
374			// Still retains the key.
375			$sortedArray = $sortByLowest($array);
376
377			$this->assertEquals(-9, $sortedArray['d']);
378			$this->assertEquals(-9, array_values($sortedArray)[0]);
379
380			$this->assertEquals(2, $sortedArray['e']);
381			$this->assertEquals(2, array_values($sortedArray)[3]);
382
383			$this->assertEquals(8, $sortedArray['b']);
384			$this->assertEquals(8, array_values($sortedArray)[7]);
385			}
386
387
388			public function testCanDoUsortOnArray(): void
389			{
390			$array = array(3, 2, 5, 6, 1);
391
392			$lowestFirstCallback = function ($a, $b) {
393			if ($a == $b) {
394			return 0;
395			}
396			return ($a < $b) ? -1 : 1;
397			};
398
399			$sortByLowest = Arr\usort($lowestFirstCallback);
400
401			// Still retains the key.
402			$sortedArray = $sortByLowest($array);
403
404			$this->assertEquals(1, $sortedArray[0]);
405			$this->assertEquals(2, $sortedArray[1]);
406			$this->assertEquals(5, $sortedArray[3]);
407			$this->assertEquals(6, $sortedArray[4]);
408			}
409
410			public function testCanPartitionTable()
411			{
412			$isEven = function ($e) {
413			return $e % 2 === 0;
414			};
415
416			$sortByOddEven = Arr\partition($isEven);
417
418			$data = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
419
420			$sorted = $sortByOddEven($data);
421			$this->assertCount(5, $sorted[0]);
422			$this->assertCount(5, $sorted[1]);
423
424			$this->assertContains(2, $sorted[1]);
425			$this->assertContains(4, $sorted[1]);
426			$this->assertContains(8, $sorted[1]);
427			$this->assertContains(3, $sorted[0]);
428			$this->assertContains(7, $sorted[0]);
429			}
430
431			public function testCanDoToString(): void
432			{
433			$source = array(
434			'hi',
435			'there',
436			'how',
437			'are',
438			'you',
439			3,
440			12.7,
441			true,
442			null,
443			);
444
445			$noSpacing = Arr\toString();
446			$withSpacing = Arr\toString(' ');
447
448			$this->assertEquals('hitherehowareyou312.71', $noSpacing($source));
449			$this->assertEquals('hi there how are you 3 12.7 1 ', $withSpacing($source));
450			}
451			}
452

gin0115 / pinkcrab_function_constructors

Pull Request — develop (#27)

ArrayFunctionTests::testCanUseColumn() A

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like