GenericArrayObjectTest.php

Go to the documentation of this file.

<?php

abstract class GenericArrayObjectTest extends MediaWikiTestCase {

    abstract public function elementInstancesProvider();

    abstract public function getInstanceClass();

    public function instanceProvider() {
        $instances = array();

        foreach ( $this->elementInstancesProvider() as $elementInstances ) {
            $instances[] = $this->getNew( $elementInstances[0] );
        }

        return $this->arrayWrap( $instances );
    }

    protected function getNew( array $elements = array() ) {
        $class = $this->getInstanceClass();

        return new $class( $elements );
    }

    public function testConstructor( array $elements ) {
        $arrayObject = $this->getNew( $elements );

        $this->assertEquals( count( $elements ), $arrayObject->count() );
    }

    public function testIsEmpty( array $elements ) {
        $arrayObject = $this->getNew( $elements );

        $this->assertEquals( $elements === array(), $arrayObject->isEmpty() );
    }

    public function testUnset( GenericArrayObject $list ) {
        if ( $list->isEmpty() ) {
            $this->assertTrue( true ); // We cannot test unset if there are no elements
        } else {
            $offset = $list->getIterator()->key();
            $count = $list->count();
            $list->offsetUnset( $offset );
            $this->assertEquals( $count - 1, $list->count() );
        }

        if ( !$list->isEmpty() ) {
            $offset = $list->getIterator()->key();
            $count = $list->count();
            unset( $list[$offset] );
            $this->assertEquals( $count - 1, $list->count() );
        }
    }

    public function testAppend( array $elements ) {
        $list = $this->getNew();

        $listSize = count( $elements );

        foreach ( $elements as $element ) {
            $list->append( $element );
        }

        $this->assertEquals( $listSize, $list->count() );

        $list = $this->getNew();

        foreach ( $elements as $element ) {
            $list[] = $element;
        }

        $this->assertEquals( $listSize, $list->count() );

        $this->checkTypeChecks( function ( GenericArrayObject $list, $element ) {
            $list->append( $element );
        } );
    }

    protected function checkTypeChecks( $function ) {
        $excption = null;
        $list = $this->getNew();

        $elementClass = $list->getObjectType();

        foreach ( array( 42, 'foo', array(), new stdClass(), 4.2 ) as $element ) {
            $validValid = $element instanceof $elementClass;

            try {
                call_user_func( $function, $list, $element );
                $valid = true;
            } catch ( InvalidArgumentException $exception ) {
                $valid = false;
            }

            $this->assertEquals(
                $validValid,
                $valid,
                'Object of invalid type got successfully added to a GenericArrayObject'
            );
        }
    }

    public function testOffsetSet( array $elements ) {
        if ( $elements === array() ) {
            $this->assertTrue( true );

            return;
        }

        $list = $this->getNew();

        $element = reset( $elements );
        $list->offsetSet( 42, $element );
        $this->assertEquals( $element, $list->offsetGet( 42 ) );

        $list = $this->getNew();

        $element = reset( $elements );
        $list['oHai'] = $element;
        $this->assertEquals( $element, $list['oHai'] );

        $list = $this->getNew();

        $element = reset( $elements );
        $list->offsetSet( 9001, $element );
        $this->assertEquals( $element, $list[9001] );

        $list = $this->getNew();

        $element = reset( $elements );
        $list->offsetSet( null, $element );
        $this->assertEquals( $element, $list[0] );

        $list = $this->getNew();
        $offset = 0;

        foreach ( $elements as $element ) {
            $list->offsetSet( null, $element );
            $this->assertEquals( $element, $list[$offset++] );
        }

        $this->assertEquals( count( $elements ), $list->count() );

        $this->checkTypeChecks( function ( GenericArrayObject $list, $element ) {
            $list->offsetSet( mt_rand(), $element );
        } );
    }

    public function testSerialization( GenericArrayObject $list ) {
        $serialization = serialize( $list );
        $copy = unserialize( $serialization );

        $this->assertEquals( $serialization, serialize( $copy ) );
        $this->assertEquals( count( $list ), count( $copy ) );

        $list = $list->getArrayCopy();
        $copy = $copy->getArrayCopy();

        $this->assertArrayEquals( $list, $copy, true, true );
    }
}