GenericArrayObjectTest.php

Go to the documentation of this file.

<?php
 
abstract class GenericArrayObjectTest extends PHPUnit_Framework_TestCase {
 
    abstract public function elementInstancesProvider();
 
    abstract public function getInstanceClass();
 
    public function instanceProvider() {
        $instances = [];
 
        foreach ( $this->elementInstancesProvider() as $elementInstances ) {
            $instances[] = $this->getNew( $elementInstances[0] );
        }
 
        return $this->arrayWrap( $instances );
    }
 
    protected function getNew( array $elements = [] ) {
        $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 === [], $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 ( [ 42, 'foo', [], 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 === [] ) {
            $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 );
    }
}