ArrayListTest::testShuffle() - Code Metrics - Inspection of "Merge remote-tracking branch 'origin/4'" - silverstripe/silverstripe-framework - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( 32a37c...72e173 )

by Sam
created 2019-05-23 21:25 UTC
ArrayListTest::testShuffle() A

↳ Parent: ArrayListTest
Complexity

Conditions	2
Paths	2
Size

Total Lines	13
Code Lines	6
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	2
eloc	6
nc	2
nop	0
dl	0
loc	13
rs	10
c	0
b	0
f	0
<?php

namespace SilverStripe\ORM\Tests;

use SilverStripe\Dev\Deprecation;
use SilverStripe\Dev\SapphireTest;
use SilverStripe\ORM\ArrayList;
use SilverStripe\ORM\DataObject;
use SilverStripe\ORM\Filterable;
use SilverStripe\ORM\SS_List;
use stdClass;

class ArrayListTest extends SapphireTest
{

    public function testPushOperator()
    {
        $list = new ArrayList(
            array(
            array('Num' => 1)
            )
        );

        $list[] = array('Num' => 2);
        $this->assertEquals(2, count($list));
        $this->assertEquals(array('Num' => 2), $list->last());

        $list[] = array('Num' => 3);
        $this->assertEquals(3, count($list));
        $this->assertEquals(array('Num' => 3), $list->last());
    }

    public function testArrayAccessExists()
    {
        $list = new ArrayList(
            array(
            $one = new DataObject(array('Title' => 'one')),
            $two = new DataObject(array('Title' => 'two')),

            $three = new DataObject(array('Title' => 'three'))

            )
        );
        $this->assertEquals(count($list), 3);
        $this->assertTrue(isset($list[0]), 'First item in the set is set');
        $this->assertEquals($one, $list[0], 'First item in the set is accessible by array notation');
    }

    public function testArrayAccessUnset()
    {
        $list = new ArrayList(
            array(
            $one = new DataObject(array('Title' => 'one')),

            $two = new DataObject(array('Title' => 'two')),

            $three = new DataObject(array('Title' => 'three'))

            )
        );
        unset($list[0]);
        $this->assertEquals(count($list), 2);
    }

    public function testArrayAccessSet()
    {
        $list = new ArrayList();
        $this->assertEquals(0, count($list));
        $list['testing!'] = $test = new DataObject(array('Title' => 'I\'m testing!'));
        $this->assertEquals($test, $list['testing!'], 'Set item is accessible by the key we set it as');
    }

    public function testCount()
    {
        $list = new ArrayList();
        $this->assertEquals(0, $list->count());
        $list = new ArrayList(array(1, 2, 3));
        $this->assertEquals(3, $list->count());
    }

    public function testExists()
    {
        $list = new ArrayList();
        $this->assertFalse($list->exists());
        $list = new ArrayList(array(1, 2, 3));
        $this->assertTrue($list->exists());
    }

    public function testToNestedArray()
    {
        $list = new ArrayList(
            array(
            array('First' => 'FirstFirst', 'Second' => 'FirstSecond'),
            (object) array('First' => 'SecondFirst', 'Second' => 'SecondSecond'),
            new ArrayListTest\TestObject('ThirdFirst', 'ThirdSecond')
            )
        );

        $this->assertEquals(
            $list->toNestedArray(),
            array(
            array('First' => 'FirstFirst', 'Second' => 'FirstSecond'),
            array('First' => 'SecondFirst', 'Second' => 'SecondSecond'),
            array('First' => 'ThirdFirst', 'Second' => 'ThirdSecond')
            )
        );
    }

    public function testEach()
    {
        $list = new ArrayList(array(1, 2, 3));

        $count = 0;
        $test = $this;

        $list->each(
            function ($item) use (&$count, $test) {
                $count++;

                $test->assertTrue(is_int($item));
            }
        );

        $this->assertEquals($list->Count(), $count);
    }

    public function testLimit()
    {
        $list = new ArrayList(
            array(
            array('Key' => 1), array('Key' => 2), array('Key' => 3)
            )
        );
        $this->assertEquals(
            $list->limit(2, 1)->toArray(),
            array(
            array('Key' => 2), array('Key' => 3)
            )
        );
    }

    /**
     * @expectedException \PHPUnit\Framework\Error\Error
     */
    public function testZeroLimit()
    {
        Deprecation::notification_version('4.3.0');
        $list = new ArrayList([
            ['Key' => 1],
            ['Key' => 2],
        ]);
        $list->limit(0);
    }

    public function testAddRemove()
    {
        $list = new ArrayList(
            array(
            array('Key' => 1), array('Key' => 2)
            )
        );

        $list->add(array('Key' => 3));
        $this->assertEquals(
            $list->toArray(),
            array(
            array('Key' => 1), array('Key' => 2), array('Key' => 3)
            )
        );

        $list->remove(array('Key' => 2));
        $this->assertEquals(
            array_values($list->toArray()),
            array(
            array('Key' => 1), array('Key' => 3)
            )
        );
    }

    public function testReplace()
    {
        $list = new ArrayList(
            array(
            array('Key' => 1),
            $two = (object) array('Key' => 2),
            (object) array('Key' => 3)
            )
        );

        $this->assertEquals(array('Key' => 1), $list[0]);
        $list->replace(array('Key' => 1), array('Replaced' => 1));
        $this->assertEquals(3, count($list));
        $this->assertEquals(array('Replaced' => 1), $list[0]);

        $this->assertEquals($two, $list[1]);
        $list->replace($two, array('Replaced' => 2));
        $this->assertEquals(3, count($list));
        $this->assertEquals(array('Replaced' => 2), $list[1]);
    }

    public function testMerge()
    {
        $list = new ArrayList(
            array(
            array('Num' => 1), array('Num' => 2)
            )
        );
        $list->merge(
            array(
            array('Num' => 3), array('Num' => 4)
            )
        );

        $this->assertEquals(4, count($list));
        $this->assertEquals(
            $list->toArray(),
            array(
            array('Num' => 1), array('Num' => 2), array('Num' => 3), array('Num' => 4)
            )
        );
    }

    public function testRemoveDuplicates()
    {
        $list = new ArrayList(
            array(
            array('ID' => 1, 'Field' => 1),
            array('ID' => 2, 'Field' => 2),
            array('ID' => 3, 'Field' => 3),
            array('ID' => 4, 'Field' => 1),
            (object) array('ID' => 5, 'Field' => 2)
            )
        );

        $this->assertEquals(5, count($list));
        $list->removeDuplicates();
        $this->assertEquals(5, count($list));

        $list->removeDuplicates('Field');
        $this->assertEquals(3, count($list));
        $this->assertEquals(array(1, 2, 3), $list->column('Field'));
        $this->assertEquals(array(1, 2, 3), $list->column('ID'));
    }

    public function testPushPop()
    {
        $list = new ArrayList(array('Num' => 1));
        $this->assertEquals(1, count($list));

        $list->push(array('Num' => 2));
        $this->assertEquals(2, count($list));
        $this->assertEquals(array('Num' => 2), $list->last());

        $list->push(array('Num' => 3));
        $this->assertEquals(3, count($list));
        $this->assertEquals(array('Num' => 3), $list->last());

        $this->assertEquals(array('Num' => 3), $list->pop());
        $this->assertEquals(2, count($list));
        $this->assertEquals(array('Num' => 2), $list->last());
    }

    public function testShiftUnshift()
    {
        $list = new ArrayList(array('Num' => 1));
        $this->assertEquals(1, count($list));

        $list->unshift(array('Num' => 2));
        $this->assertEquals(2, count($list));
        $this->assertEquals(array('Num' => 2), $list->first());

        $list->unshift(array('Num' => 3));
        $this->assertEquals(3, count($list));
        $this->assertEquals(array('Num' => 3), $list->first());

        $this->assertEquals(array('Num' => 3), $list->shift());
        $this->assertEquals(2, count($list));
        $this->assertEquals(array('Num' => 2), $list->first());
    }

    public function testFirstLast()
    {
        $list = new ArrayList(
            array(
            array('Key' => 1), array('Key' => 2), array('Key' => 3)
            )
        );
        $this->assertEquals($list->first(), array('Key' => 1));
        $this->assertEquals($list->last(), array('Key' => 3));
    }

    public function testMap()
    {
        $list = new ArrayList(
            array(
            array('ID' => 1, 'Name' => 'Steve',),
            (object) array('ID' => 3, 'Name' => 'Bob'),
            array('ID' => 5, 'Name' => 'John')
            )
        );
        $map = $list->map('ID', 'Name');
        // Items added after calling map should not be included retroactively
        $list->add(array('ID' => 7, 'Name' => 'Andrew'));
        $this->assertInstanceOf('SilverStripe\\ORM\\Map', $map);
        $this->assertEquals(
            array(
            1 => 'Steve',
            3 => 'Bob',
            5 => 'John'
            ),
            $map->toArray()
        );
    }

    public function testFind()
    {
        $list = new ArrayList(
            array(
            array('Name' => 'Steve'),
            (object) array('Name' => 'Bob'),
            array('Name' => 'John')
            )
        );
        $this->assertEquals(
            $list->find('Name', 'Bob'),
            (object) array(
            'Name' => 'Bob'
            )
        );
    }

    public function testColumn()
    {
        $list = new ArrayList(
            array(
            array('Name' => 'Steve'),
            (object) array('Name' => 'Bob'),
            array('Name' => 'John')
            )
        );
        $this->assertEquals(
            $list->column('Name'),
            array(
            'Steve', 'Bob', 'John'
            )
        );
    }

    public function testSortSimpleDefaultIsSortedASC()
    {
        $list = new ArrayList(
            array(
            array('Name' => 'Steve'),
            (object) array('Name' => 'Bob'),
            array('Name' => 'John'),
            array('Name' => 'bonny'),
            )
        );

        // Unquoted name
        $list1 = $list->sort('Name');
        $this->assertEquals(
            array(
            (object) array('Name' => 'Bob'),
            array('Name' => 'bonny'),
            array('Name' => 'John'),
            array('Name' => 'Steve'),
            ),
            $list1->toArray()
        );

        // Quoted name name
        $list2 = $list->sort('"Name"');
        $this->assertEquals(
            array(
            (object) array('Name' => 'Bob'),
            array('Name' => 'bonny'),
            array('Name' => 'John'),
            array('Name' => 'Steve'),
            ),
            $list2->toArray()
        );

        // Array (non-associative)

        $list3 = $list->sort(array('"Name"'));
        $this->assertEquals(
            array(
            (object) array('Name' => 'Bob'),
            array('Name' => 'bonny'),
            array('Name' => 'John'),
            array('Name' => 'Steve'),
            ),
            $list3->toArray()
        );

        // Quoted name name with table
        $list4 = $list->sort('"Record"."Name"');
        $this->assertEquals(
            array(
            (object) array('Name' => 'Bob'),
            array('Name' => 'bonny'),
            array('Name' => 'John'),
            array('Name' => 'Steve')
            ),
            $list4->toArray()
        );

        // Quoted name name with table (desc)
        $list5 = $list->sort('"Record"."Name" DESC');
        $this->assertEquals(
            array(
            array('Name' => 'Steve'),
            array('Name' => 'John'),
            array('Name' => 'bonny'),
            (object) array('Name' => 'Bob')
            ),
            $list5->toArray()
        );

        // Table without quotes
        $list6 = $list->sort('Record.Name');
        $this->assertEquals(
            array(
            (object) array('Name' => 'Bob'),
            array('Name' => 'bonny'),
            array('Name' => 'John'),
            array('Name' => 'Steve')
            ),
            $list6->toArray()
        );

        // Check original list isn't altered
        $this->assertEquals(
            array(
            array('Name' => 'Steve'),
            (object) array('Name' => 'Bob'),
            array('Name' => 'John'),
            array('Name' => 'bonny'),
            ),
            $list->toArray()
        );
    }

    public function testMixedCaseSort()
    {
        // Note: Natural sorting is not expected, so if 'bonny10' were included
        // below we would expect it to appear between bonny1 and bonny2. That's
        // undesirable though so we're not enforcing it in tests.
        $original = array(
            array('Name' => 'Steve'),
            (object) array('Name' => 'Bob'),
            array('Name' => 'John'),
            array('Name' => 'bonny'),
            array('Name' => 'bonny1'),
            //array('Name' => 'bonny10'),

            array('Name' => 'bonny2'),
        );

        $list = new ArrayList($original);

        $expected = array(
            (object) array('Name' => 'Bob'),
            array('Name' => 'bonny'),
            array('Name' => 'bonny1'),
            //array('Name' => 'bonny10'),

            array('Name' => 'bonny2'),
            array('Name' => 'John'),
            array('Name' => 'Steve'),
        );

        // Unquoted name
        $list1 = $list->sort('Name');
        $this->assertEquals($expected, $list1->toArray());

        // Quoted name name
        $list2 = $list->sort('"Name"');
        $this->assertEquals($expected, $list2->toArray());

        // Array (non-associative)

        $list3 = $list->sort(array('"Name"'));
        $this->assertEquals($expected, $list3->toArray());

        // Check original list isn't altered
        $this->assertEquals($original, $list->toArray());
    }

    public function testSortSimpleASCOrder()
    {
        $list = new ArrayList(
            array(
            array('Name' => 'Steve'),
            (object) array('Name' => 'Bob'),
            array('Name' => 'John')
            )
        );

        // Sort two arguments
        $list1 = $list->sort('Name', 'ASC');
        $this->assertEquals(
            $list1->toArray(),
            array(
            (object) array('Name' => 'Bob'),
            array('Name' => 'John'),
            array('Name' => 'Steve')
            )
        );

        // Sort single string
        $list2 = $list->sort('Name asc');
        $this->assertEquals(
            $list2->toArray(),
            array(
            (object) array('Name' => 'Bob'),
            array('Name' => 'John'),
            array('Name' => 'Steve')
            )
        );

        // Sort quoted string
        $list3 = $list->sort('"Name" ASCENDING');
        $this->assertEquals(
            $list3->toArray(),
            array(
            (object) array('Name' => 'Bob'),
            array('Name' => 'John'),
            array('Name' => 'Steve')
            )
        );

        // Sort array specifier
        $list4 = $list->sort(array('Name' => 'ascending'));
        $this->assertEquals(
            $list4->toArray(),
            array(
            (object) array('Name' => 'Bob'),
            array('Name' => 'John'),
            array('Name' => 'Steve')
            )
        );

        // Check original list isn't altered
        $this->assertEquals(
            $list->toArray(),
            array(
            array('Name' => 'Steve'),
            (object) array('Name' => 'Bob'),
            array('Name' => 'John')
            )
        );
    }

    public function testSortSimpleDESCOrder()
    {
        $list = new ArrayList(
            array(
            array('Name' => 'Steve'),
            (object) array('Name' => 'Bob'),
            array('Name' => 'John')
            )
        );

        // Sort two arguments
        $list1 = $list->sort('Name', 'DESC');
        $this->assertEquals(
            $list1->toArray(),
            array(
            array('Name' => 'Steve'),
            array('Name' => 'John'),
            (object) array('Name' => 'Bob')
            )
        );

        // Sort single string
        $list2 = $list->sort('Name desc');
        $this->assertEquals(
            $list2->toArray(),
            array(
            array('Name' => 'Steve'),
            array('Name' => 'John'),
            (object) array('Name' => 'Bob')
            )
        );

        // Sort quoted string
        $list3 = $list->sort('"Name" DESCENDING');
        $this->assertEquals(
            $list3->toArray(),
            array(
            array('Name' => 'Steve'),
            array('Name' => 'John'),
            (object) array('Name' => 'Bob')
            )
        );

        // Sort array specifier
        $list4 = $list->sort(array('Name' => 'descending'));
        $this->assertEquals(
            $list4->toArray(),
            array(
            array('Name' => 'Steve'),
            array('Name' => 'John'),
            (object) array('Name' => 'Bob')
            )
        );

        // Check original list isn't altered
        $this->assertEquals(
            $list->toArray(),
            array(
            array('Name' => 'Steve'),
            (object) array('Name' => 'Bob'),
            array('Name' => 'John')
            )
        );
    }

    public function testSortNumeric()
    {
        $list = new ArrayList(
            array(
            array('Sort' => 0),
            array('Sort' => -1),
            array('Sort' => 1),
            array('Sort' => -2),
            array('Sort' => 2),
            array('Sort' => -10),
            array('Sort' => 10)
            )
        );

        // Sort descending
        $list1 = $list->sort('Sort', 'DESC');
        $this->assertEquals(
            array(
            array('Sort' => 10),
            array('Sort' => 2),
            array('Sort' => 1),
            array('Sort' => 0),
            array('Sort' => -1),
            array('Sort' => -2),
            array('Sort' => -10)
            ),
            $list1->toArray()
        );

        // Sort ascending
        $list1 = $list->sort('Sort', 'ASC');
        $this->assertEquals(
            array(
            array('Sort' => -10),
            array('Sort' => -2),
            array('Sort' => -1),
            array('Sort' => 0),
            array('Sort' => 1),
            array('Sort' => 2),
            array('Sort' => 10)
            ),
            $list1->toArray()
        );
    }

    public function testReverse()
    {
        $list = new ArrayList(
            array(
            array('Name' => 'John'),
            array('Name' => 'Bob'),
            array('Name' => 'Steve')
            )
        );

        $list = $list->sort('Name', 'ASC');
        $list = $list->reverse();

        $this->assertEquals(
            $list->toArray(),
            array(
            array('Name' => 'Steve'),
            array('Name' => 'John'),
            array('Name' => 'Bob')
            )
        );
    }

    public function testSimpleMultiSort()
    {
        $list = new ArrayList(
            array(
            (object) array('Name'=>'Object1', 'F1'=>1, 'F2'=>2, 'F3'=>3),
            (object) array('Name'=>'Object2', 'F1'=>2, 'F2'=>1, 'F3'=>4),
            (object) array('Name'=>'Object3', 'F1'=>5, 'F2'=>2, 'F3'=>2),
            )
        );

        $list = $list->sort('F3', 'ASC');
        $this->assertEquals($list->first()->Name, 'Object3', 'Object3 should be first in the list');
        $this->assertEquals($list->last()->Name, 'Object2', 'Object2 should be last in the list');

        $list = $list->sort('F3', 'DESC');
        $this->assertEquals($list->first()->Name, 'Object2', 'Object2 should be first in the list');
        $this->assertEquals($list->last()->Name, 'Object3', 'Object3 should be last in the list');
    }

    public function testMultiSort()
    {
        $list = new ArrayList(
            array(
            (object) array('ID'=>3, 'Name'=>'Bert', 'Importance'=>1),
            (object) array('ID'=>1, 'Name'=>'Aron', 'Importance'=>2),
            (object) array('ID'=>2, 'Name'=>'Aron', 'Importance'=>1),
            )
        );

        $list = $list->sort(array('Name'=>'ASC', 'Importance'=>'ASC'));
        $this->assertEquals($list->first()->ID, 2, 'Aron.2 should be first in the list');
        $this->assertEquals($list->last()->ID, 3, 'Bert.3 should be last in the list');

        $list = $list->sort(array('Name'=>'ASC', 'Importance'=>'DESC'));
        $this->assertEquals($list->first()->ID, 1, 'Aron.2 should be first in the list');
        $this->assertEquals($list->last()->ID, 3, 'Bert.3 should be last in the list');
    }

    /**
     * Check that we don't cause recursion errors with array_multisort() and circular dependencies
     */
    public function testSortWithCircularDependencies()
    {
        $itemA = new stdClass;
        $childA = new stdClass;
        $itemA->child = $childA;
        $childA->parent = $itemA;
        $itemA->Sort = 1;

        $itemB = new stdClass;
        $childB = new stdClass;
        $itemB->child = $childB;
        $childB->parent = $itemB;
        $itemB->Sort = 1;

        $items = new ArrayList;
        $items->add($itemA);
        $items->add($itemB);

        // This call will trigger a fatal error if there are issues with circular dependencies
        $this->assertInstanceOf(SS_List::class, $items->sort('Sort'));
    }

    /**
     * $list->filter('Name', 'bob'); // only bob in the list
     */
    public function testSimpleFilter()
    {
        $list = new ArrayList(
            array(
            array('Name' => 'Steve'),
            (object) array('Name' => 'Bob'),
            array('Name' => 'John')
            )
        );
        $list = $list->filter('Name', 'Bob');
        $this->assertEquals(array((object)array('Name'=>'Bob')), $list->toArray(), 'List should only contain Bob');
    }

    /**
     * $list->filter('Name', array('Steve', 'John'); // Steve and John in list
     */
    public function testSimpleFilterWithMultiple()
    {
        $list = new ArrayList(
            array(
            array('Name' => 'Steve'),
            (object) array('Name' => 'Bob'),
            array('Name' => 'John')
            )
        );

        $expected = array(
            array('Name' => 'Steve'),
            array('Name' => 'John')
        );
        $list = $list->filter('Name', array('Steve','John'));
        $this->assertEquals($expected, $list->toArray(), 'List should only contain Steve and John');
    }

    /**
     * $list->filter('Name', array('Steve', 'John'); // negative version
     */
    public function testSimpleFilterWithMultipleNoMatch()
    {
        $list = new ArrayList(
            array(
            array('Name' => 'Steve', 'ID' => 1),
            (object) array('Name' => 'Steve', 'ID' => 2),
            array('Name' => 'John', 'ID' => 2)
            )
        );
        $list = $list->filter(array('Name'=>'Clair'));
        $this->assertEquals(array(), $list->toArray(), 'List should be empty');
    }

    /**
     * $list->filter(array('Name'=>'bob, 'Age'=>21)); // bob with the Age 21 in list
     */
    public function testMultipleFilter()
    {
        $list = new ArrayList(
            array(
            array('Name' => 'Steve', 'ID' => 1),
            (object) array('Name' => 'Steve', 'ID' => 2),
            array('Name' => 'John', 'ID' => 2)
            )
        );
        $list = $list->filter(array('Name'=>'Steve', 'ID'=>2));
        $this->assertEquals(
            array((object)array('Name'=>'Steve', 'ID'=>2)),
            $list->toArray(),
            'List should only contain object Steve'
        );
    }

    /**
     * $list->filter(array('Name'=>'bob, 'Age'=>21)); // negative version
     */
    public function testMultipleFilterNoMatch()
    {
        $list = new ArrayList(
            array(
            array('Name' => 'Steve', 'ID' => 1),
            (object) array('Name' => 'Steve', 'ID' => 2),
            array('Name' => 'John', 'ID' => 2)
            )
        );
        $list = $list->filter(array('Name'=>'Steve', 'ID'=>4));
        $this->assertEquals(array(), $list->toArray(), 'List should be empty');
    }

    /**
     * $list->filter(array('Name'=>'Steve', 'Age'=>array(21, 43))); // Steve with the Age 21 or 43
     */
    public function testMultipleWithArrayFilter()
    {
        $list = new ArrayList(
            array(
            array('Name' => 'Steve', 'ID' => 1, 'Age'=>21),
            array('Name' => 'Steve', 'ID' => 2, 'Age'=>18),
            array('Name' => 'Clair', 'ID' => 2, 'Age'=>21),
            array('Name' => 'Steve', 'ID' => 3, 'Age'=>43)
            )
        );

        $list = $list->filter(array('Name'=>'Steve','Age'=>array(21, 43)));

        $expected = array(
            array('Name' => 'Steve', 'ID' => 1, 'Age'=>21),
            array('Name' => 'Steve', 'ID' => 3, 'Age'=>43)
        );
        $this->assertEquals(2, $list->count());
        $this->assertEquals($expected, $list->toArray(), 'List should only contain Steve and Steve');
    }

    /**
     * $list->filter(array('Name'=>array('aziz','bob'), 'Age'=>array(21, 43)));
     */
    public function testMultipleWithArrayFilterAdvanced()
    {
        $list = new ArrayList(
            array(
            array('Name' => 'Steve', 'ID' => 1, 'Age'=>21),
            array('Name' => 'Steve', 'ID' => 2, 'Age'=>18),
            array('Name' => 'Clair', 'ID' => 2, 'Age'=>21),
            array('Name' => 'Clair', 'ID' => 2, 'Age'=>52),
            array('Name' => 'Steve', 'ID' => 3, 'Age'=>43)
            )
        );

        $list = $list->filter(array('Name'=>array('Steve','Clair'),'Age'=>array(21, 43)));

        $expected = array(
            array('Name' => 'Steve', 'ID' => 1, 'Age'=>21),
            array('Name' => 'Clair', 'ID' => 2, 'Age'=>21),
            array('Name' => 'Steve', 'ID' => 3, 'Age'=>43)
        );

        $this->assertEquals(3, $list->count());
        $this->assertEquals($expected, $list->toArray(), 'List should only contain Steve and Steve and Clair');
    }

    public function testFilterAny()
    {

        $list = new ArrayList(
            array(
            $steve = array('Name' => 'Steve', 'ID' => 1, 'Age' => 21),
            $bob = array('Name' => 'Bob', 'ID' => 2, 'Age' => 18),
            $clair = array('Name' => 'Clair', 'ID' => 3, 'Age' => 21),
            $phil = array('Name' => 'Phil', 'ID' => 4, 'Age' => 21),
            $oscar = array('Name' => 'Oscar', 'ID' => 5, 'Age' => 52),

            $mike = array('Name' => 'Mike', 'ID' => 6, 'Age' => 43),
            )
        );

        // only bob in the list
        //$list = $list->filterAny('Name', 'bob');

        $filteredList = $list->filterAny('Name', 'Bob')->toArray();
        $this->assertCount(1, $filteredList);
        $this->assertContains($bob, $filteredList);

        // azis or bob in the list
        //$list = $list->filterAny('Name', array('aziz', 'bob');

        $filteredList = $list->filterAny('Name', array('Aziz', 'Bob'))->toArray();
        $this->assertCount(1, $filteredList);
        $this->assertContains($bob, $filteredList);

        $filteredList = $list->filterAny('Name', array('Steve', 'Bob'))->toArray();
        $this->assertCount(2, $filteredList);
        $this->assertContains($steve, $filteredList);
        $this->assertContains($bob, $filteredList);

        // bob or anyone aged 21 in the list
        //$list = $list->filterAny(array('Name'=>'bob, 'Age'=>21));
        $filteredList = $list->filterAny(array('Name' => 'Bob', 'Age' => 21))->toArray();
        $this->assertCount(4, $filteredList);
        $this->assertContains($bob, $filteredList);
        $this->assertContains($steve, $filteredList);
        $this->assertContains($clair, $filteredList);
        $this->assertContains($phil, $filteredList);

        // bob or anyone aged 21 or 43 in the list
        // $list = $list->filterAny(array('Name'=>'bob, 'Age'=>array(21, 43)));
        $filteredList = $list->filterAny(array('Name' => 'Bob', 'Age' => array(21, 43)))->toArray();
        $this->assertCount(5, $filteredList);
        $this->assertContains($bob, $filteredList);
        $this->assertContains($steve, $filteredList);
        $this->assertContains($clair, $filteredList);
        $this->assertContains($mike, $filteredList);
        $this->assertContains($phil, $filteredList);

        // all bobs, phils or anyone aged 21 or 43 in the list
        //$list = $list->filterAny(array('Name'=>array('bob','phil'), 'Age'=>array(21, 43)));

        $filteredList = $list->filterAny(array('Name' => array('Bob', 'Phil'), 'Age' => array(21, 43)))->toArray();
        $this->assertCount(5, $filteredList);
        $this->assertContains($bob, $filteredList);
        $this->assertContains($steve, $filteredList);
        $this->assertContains($clair, $filteredList);
        $this->assertContains($mike, $filteredList);
        $this->assertContains($phil, $filteredList);

        $filteredList = $list->filterAny(array('Name' => array('Bob', 'Nobody'), 'Age' => array(21, 43)))->toArray();
        $this->assertCount(5, $filteredList);
        $this->assertContains($bob, $filteredList);
        $this->assertContains($steve, $filteredList);
        $this->assertContains($clair, $filteredList);
        $this->assertContains($mike, $filteredList);
        $this->assertContains($phil, $filteredList);
    }

    /**
     * $list = $list->filterByCallback(function($item, $list) { return $item->Age == 21; })
     */
    public function testFilterByCallback()
    {
        $list = new ArrayList(
            array(
            $steve = array('Name' => 'Steve', 'ID' => 1, 'Age' => 21),
            array('Name' => 'Bob', 'ID' => 2, 'Age' => 18),
            $clair = array('Name' => 'Clair', 'ID' => 2, 'Age' => 21),
            array('Name' => 'Oscar', 'ID' => 2, 'Age' => 52),
            array('Name' => 'Mike', 'ID' => 3, 'Age' => 43)
            )
        );

        $list = $list->filterByCallback(
            function ($item, $list) {
            function ($item, /** @scrutinizer ignore-unused */ $list) {
                return $item->Age == 21;
            }
        );

        $this->assertEquals(2, $list->count());
        $this->assertEquals($steve, $list[0]->toMap(), 'List should only contain Steve and Clair');
        $this->assertEquals($clair, $list[1]->toMap(), 'List should only contain Steve and Clair');
        $this->assertTrue($list instanceof Filterable, 'The List should be of type SS_Filterable');
    }

    /**
     * $list->exclude('Name', 'bob'); // exclude bob from list
     */
    public function testSimpleExclude()
    {
        $list = new ArrayList(
            array(
            array('Name' => 'Steve'),
            array('Name' => 'Bob'),
            array('Name' => 'John')
            )
        );

        $list = $list->exclude('Name', 'Bob');
        $expected = array(
            array('Name' => 'Steve'),
            array('Name' => 'John')
        );
        $this->assertEquals(2, $list->count());
        $this->assertEquals($expected, $list->toArray(), 'List should not contain Bob');
    }

    /**
     * $list->exclude('Name', 'bob'); // No exclusion version
     */
    public function testSimpleExcludeNoMatch()
    {
        $list = new ArrayList(
            array(
            array('Name' => 'Steve'),
            array('Name' => 'Bob'),
            array('Name' => 'John')
            )
        );

        $list = $list->exclude('Name', 'Clair');
        $expected = array(
            array('Name' => 'Steve'),
            array('Name' => 'Bob'),
            array('Name' => 'John')
        );
        $this->assertEquals($expected, $list->toArray(), 'List should be unchanged');
    }

    /**
     * $list->exclude('Name', array('Steve','John'));
     */
    public function testSimpleExcludeWithArray()
    {
        $list = new ArrayList(
            array(
            array('Name' => 'Steve'),
            array('Name' => 'Bob'),
            array('Name' => 'John')
            )
        );
        $list = $list->exclude('Name', array('Steve','John'));
        $expected = array(array('Name' => 'Bob'));
        $this->assertEquals(1, $list->count());
        $this->assertEquals($expected, $list->toArray(), 'List should only contain Bob');
    }

    /**
     * $list->exclude(array('Name'=>'bob, 'Age'=>21)); // exclude all Bob that has Age 21
     */
    public function testExcludeWithTwoArrays()
    {
        $list = new ArrayList(
            array(
            array('Name' => 'Bob' , 'Age' => 21),
            array('Name' => 'Bob' , 'Age' => 32),
            array('Name' => 'John', 'Age' => 21)
            )
        );

        $list = $list->exclude(array('Name' => 'Bob', 'Age' => 21));

        $expected = array(
            array('Name' => 'Bob', 'Age' => 32),
            array('Name' => 'John', 'Age' => 21)
        );

        $this->assertEquals(2, $list->count());
        $this->assertEquals($expected, $list->toArray(), 'List should only contain John and Bob');
    }

    /**
     * $list->exclude(array('Name'=>array('bob','phil'), 'Age'=>array(10, 16)));
     */
    public function testMultipleExclude()
    {
        $list = new ArrayList(
            array(
            array('Name' => 'bob', 'Age' => 10),
            array('Name' => 'phil', 'Age' => 11),
            array('Name' => 'bob', 'Age' => 12),
            array('Name' => 'phil', 'Age' => 12),
            array('Name' => 'bob', 'Age' => 14),
            array('Name' => 'phil', 'Age' => 14),
            array('Name' => 'bob', 'Age' => 16),
            array('Name' => 'phil', 'Age' => 16)
            )
        );

        $list = $list->exclude(array('Name'=>array('bob','phil'),'Age'=>array(10, 16)));
        $expected = array(
            array('Name' => 'phil', 'Age' => 11),
            array('Name' => 'bob', 'Age' => 12),
            array('Name' => 'phil', 'Age' => 12),
            array('Name' => 'bob', 'Age' => 14),
            array('Name' => 'phil', 'Age' => 14),
        );
        $this->assertEquals($expected, $list->toArray());
    }

    /**
     * $list->exclude(array('Name'=>array('bob','phil'), 'Age'=>array(10, 16), 'Bananas'=>true));
     */
    public function testMultipleExcludeNoMatch()
    {
        $list = new ArrayList(
            array(
            array('Name' => 'bob', 'Age' => 10),
            array('Name' => 'phil', 'Age' => 11),
            array('Name' => 'bob', 'Age' => 12),
            array('Name' => 'phil', 'Age' => 12),
            array('Name' => 'bob', 'Age' => 14),
            array('Name' => 'phil', 'Age' => 14),
            array('Name' => 'bob', 'Age' => 16),
            array('Name' => 'phil', 'Age' => 16)
            )
        );

        $list = $list->exclude(array('Name'=>array('bob','phil'),'Age'=>array(10, 16),'Bananas'=>true));
        $expected = array(
            array('Name' => 'bob', 'Age' => 10),
            array('Name' => 'phil', 'Age' => 11),
            array('Name' => 'bob', 'Age' => 12),
            array('Name' => 'phil', 'Age' => 12),
            array('Name' => 'bob', 'Age' => 14),
            array('Name' => 'phil', 'Age' => 14),
            array('Name' => 'bob', 'Age' => 16),
            array('Name' => 'phil', 'Age' => 16)
        );
        $this->assertEquals($expected, $list->toArray());
    }

    /**
     * $list->exclude(array('Name'=>array('bob','phil'), 'Age'=>array(10, 16), 'HasBananas'=>true));
     */
    public function testMultipleExcludeThreeArguments()
    {
        $list = new ArrayList(
            array(
            array('Name' => 'bob', 'Age' => 10, 'HasBananas'=>false),
            array('Name' => 'phil','Age' => 11, 'HasBananas'=>true),
            array('Name' => 'bob', 'Age' => 12, 'HasBananas'=>true),
            array('Name' => 'phil','Age' => 12, 'HasBananas'=>true),
            array('Name' => 'bob', 'Age' => 14, 'HasBananas'=>false),
            array('Name' => 'ann', 'Age' => 14, 'HasBananas'=>true),
            array('Name' => 'phil','Age' => 14, 'HasBananas'=>false),
            array('Name' => 'bob', 'Age' => 16, 'HasBananas'=>false),
            array('Name' => 'phil','Age' => 16, 'HasBananas'=>true),
            array('Name' => 'clair','Age' => 16, 'HasBananas'=>true)
            )
        );

        $list = $list->exclude(array('Name'=>array('bob','phil'),'Age'=>array(10, 16),'HasBananas'=>true));
        $expected = array(
            array('Name' => 'bob', 'Age' => 10, 'HasBananas'=>false),
            array('Name' => 'phil','Age' => 11, 'HasBananas'=>true),
            array('Name' => 'bob', 'Age' => 12, 'HasBananas'=>true),
            array('Name' => 'phil','Age' => 12, 'HasBananas'=>true),
            array('Name' => 'bob', 'Age' => 14, 'HasBananas'=>false),
            array('Name' => 'ann', 'Age' => 14, 'HasBananas'=>true),
            array('Name' => 'phil','Age' => 14, 'HasBananas'=>false),
            array('Name' => 'bob', 'Age' => 16, 'HasBananas'=>false),
            array('Name' => 'clair','Age' => 16, 'HasBananas'=>true)
        );
        $this->assertEquals($expected, $list->toArray());
    }

    public function testCanFilterBy()
    {
        $list = new ArrayList(
            array(
            array('Name' => 'Steve'),
            array('Name' => 'Bob'),
            array('Name' => 'John')
            )
        );

        $this->assertTrue($list->canFilterBy('Name'));
        $this->assertFalse($list->canFilterBy('Age'));
    }

    public function testCanFilterByEmpty()
    {
        $list = new ArrayList();

        $this->assertFalse($list->canFilterBy('Name'));
        $this->assertFalse($list->canFilterBy('Age'));
    }

    public function testByID()
    {
        $list = new ArrayList(
            array(
            array('ID' => 1, 'Name' => 'Steve'),
            array('ID' => 2, 'Name' => 'Bob'),
            array('ID' => 3, 'Name' => 'John')
            )
        );

        $element = $list->byID(1);
        $this->assertEquals($element['Name'], 'Steve');

        $element = $list->byID(2);
        $this->assertEquals($element['Name'], 'Bob');

        $element = $list->byID(4);
        $this->assertNull($element);
    }

    public function testByIDs()
    {
        $list = new ArrayList(
            array(
            array('ID' => 1, 'Name' => 'Steve'),
            array('ID' => 2, 'Name' => 'Bob'),
            array('ID' => 3, 'Name' => 'John')
            )
        );
        $knownIDs = $list->column('ID');
        $removedID = array_pop($knownIDs);
        $filteredItems = $list->byIDs($knownIDs);
        foreach ($filteredItems as $item) {
            $this->assertContains($item->ID, $knownIDs);

            $this->assertNotEquals($removedID, $item->ID);
        }
    }

    public function testByIDEmpty()
    {
        $list = new ArrayList();

        $element = $list->byID(1);
        $this->assertNull($element);
    }

    public function testDataClass()
    {
        $list = new ArrayList([
            new DataObject(['Title' => 'one']),
        ]);
        $this->assertEquals(DataObject::class, $list->dataClass());
        $list->pop();
        $this->assertNull($list->dataClass());
        $list->setDataClass(DataObject::class);
        $this->assertEquals(DataObject::class, $list->dataClass());
    }

    public function testShuffle()
    {
        $upperLimit = 50;

        $list = new ArrayList(range(1, $upperLimit));

        $list->shuffle();

        for ($i = 1; $i <= $upperLimit; $i++) {
            $this->assertContains($i, $list);
        }

        $this->assertNotEquals(range(1, $upperLimit), $list->toArray());
    }
}

silverstripe / silverstripe-framework

Push — master ( 32a37c...72e173 )

ArrayListTest::testShuffle() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
