Tests\DataValues\Geo\Values\DataValueTest

Complexity

Total Complexity

14

Size/Duplication

Total Lines	178
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes

0

16 Methods

Rating	Name	Duplication	Size	Complexity
	getClass()	0	1	?
	validConstructorArgumentsProvider()	0	1	?
	invalidConstructorArgumentsProvider()	0	1	?
A	newInstance()	0	6	1
A	instanceProvider()	0	13	1
A	testConstructorWithValidArguments()	0	8	1
A	testConstructorWithInvalidArguments()	0	8	1
A	testImplements()	0	7	1
A	testGetType()	0	9	1
A	testSerialization()	0	10	1
A	testEquals()	0	7	2
A	testGetHash()	0	7	1
A	testGetCopy()	0	6	1
A	testGetValueSimple()	0	4	1
A	testGetArrayValueSimple()	0	4	1
A	testToArray()	0	11	1

<?php

namespace Tests\DataValues\Geo\Values;

use Comparable;
use DataValues\DataValue;
use Exception;
use Hashable;
use Immutable;
use PHPUnit\Framework\TestCase;
use ReflectionClass;
use Serializable;

/**
 * TODO: this class is a copy of the one in DataValues Interfaces.
 * Since it abuses inheritance, the two derivatives in this component
 * should be refactored to the point where this code can be deleted.
 *
 * @license GPL-2.0+
 * @author Jeroen De Dauw < jeroendedauw@gmail.com >
 */
abstract class DataValueTest extends TestCase {

	/**
	 * Returns the name of the concrete class tested by this test.
	 *
	 * @since 0.1
	 *
	 * @return string
	 */
	abstract public function getClass();

	abstract public function validConstructorArgumentsProvider();

	abstract public function invalidConstructorArgumentsProvider();

	/**
	 * Creates and returns a new instance of the concrete class.
	 *
	 * @since 0.1
	 *
	 * @return mixed
	 */
	public function newInstance() {
		$reflector = new ReflectionClass( $this->getClass() );
		$args = func_get_args();
		$instance = $reflector->newInstanceArgs( $args );
		return $instance;
	}

	/**
	 * @since 0.1
	 *
	 * @return array [instance, constructor args]
	 */
	public function instanceProvider() {
		$instanceBuilder = [ $this, 'newInstance' ];

		return array_map(
			function ( array $args ) use ( $instanceBuilder ) {
				return [
					call_user_func_array( $instanceBuilder, $args ),
					$args
				];
			},
			$this->validConstructorArgumentsProvider()
		);
	}

	/**
	 * @dataProvider validConstructorArgumentsProvider
	 *
	 * @since 0.1
	 */
	public function testConstructorWithValidArguments() {
		$dataItem = call_user_func_array(
			[ $this, 'newInstance' ],
			func_get_args()
		);

		$this->assertInstanceOf( $this->getClass(), $dataItem );
	}

	/**
	 * @dataProvider invalidConstructorArgumentsProvider
	 *
	 * @since 0.1
	 */
	public function testConstructorWithInvalidArguments() {
		$this->expectException( Exception::class );

		call_user_func_array(
			[ $this, 'newInstance' ],
			func_get_args()
		);
	}

	/**
	 * @dataProvider instanceProvider
	 */
	public function testImplements( DataValue $value, array $arguments ) {

The parameter $arguments is not used and could be removed.

		$this->assertInstanceOf( Immutable::class, $value );
		$this->assertInstanceOf( Hashable::class, $value );
		$this->assertInstanceOf( Comparable::class, $value );
		$this->assertInstanceOf( Serializable::class, $value );
		$this->assertInstanceOf( DataValue::class, $value );
	}

	/**
	 * @dataProvider instanceProvider
	 */
	public function testGetType( DataValue $value, array $arguments ) {

The parameter $arguments is not used and could be removed.

		$valueType = $value->getType();
		$this->assertInternalType( 'string', $valueType );
		$this->assertTrue( strlen( $valueType ) > 0 );

		// Check whether using getType statically returns the same as called from an instance:
		$staticValueType = call_user_func( [ $this->getClass(), 'getType' ] );
		$this->assertEquals( $staticValueType, $valueType );
	}

	/**
	 * @dataProvider instanceProvider
	 */
	public function testSerialization( DataValue $value, array $arguments ) {

The parameter $arguments is not used and could be removed.

		$serialization = serialize( $value );
		$this->assertInternalType( 'string', $serialization );

		$unserialized = unserialize( $serialization );
		$this->assertInstanceOf( DataValue::class, $unserialized );

		$this->assertTrue( $value->equals( $unserialized ) );
		$this->assertEquals( $value, $unserialized );
	}

	/**
	 * @dataProvider instanceProvider
	 */
	public function testEquals( DataValue $value, array $arguments ) {

The parameter $arguments is not used and could be removed.

		$this->assertTrue( $value->equals( $value ) );

		foreach ( [ true, false, null, 'foo', 42, [], 4.2 ] as $otherValue ) {
			$this->assertFalse( $value->equals( $otherValue ) );
		}
	}

	/**
	 * @dataProvider instanceProvider
	 */
	public function testGetHash( DataValue $value, array $arguments ) {

The parameter $arguments is not used and could be removed.

		$hash = $value->getHash();

		$this->assertInternalType( 'string', $hash );
		$this->assertEquals( $hash, $value->getHash() );
		$this->assertEquals( $hash, $value->getCopy()->getHash() );
	}

	/**
	 * @dataProvider instanceProvider
	 */
	public function testGetCopy( DataValue $value, array $arguments ) {

The parameter $arguments is not used and could be removed.

		$copy = $value->getCopy();

		$this->assertInstanceOf( DataValue::class, $copy );
		$this->assertTrue( $value->equals( $copy ) );
	}

	/**
	 * @dataProvider instanceProvider
	 */
	public function testGetValueSimple( DataValue $value, array $arguments ) {

The parameter $arguments is not used and could be removed.

		$value->getValue();
		$this->assertTrue( true );
	}

	/**
	 * @dataProvider instanceProvider
	 */
	public function testGetArrayValueSimple( DataValue $value, array $arguments ) {

The parameter $arguments is not used and could be removed.

		$value->getArrayValue();
		$this->assertTrue( true );
	}

	/**
	 * @dataProvider instanceProvider
	 */
	public function testToArray( DataValue $value, array $arguments ) {

The parameter $arguments is not used and could be removed.

		$array = $value->toArray();

		$this->assertInternalType( 'array', $array );

		$this->assertTrue( array_key_exists( 'type', $array ) );
		$this->assertTrue( array_key_exists( 'value', $array ) );

		$this->assertEquals( $value->getType(), $array['type'] );
		$this->assertEquals( $value->getArrayValue(), $array['value'] );
	}

}