Wikibase\DataModel\Tests\HashArray\HashArrayWithoutDuplicatesTest

Complexity

Total Complexity

13

Size/Duplication

Total Lines	155
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Importance

Changes	1
Bugs	0	Features	0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	constructorProvider()	0	8	1
A	getInstanceClass()	0	3	1
A	elementInstancesProvider()	0	6	1
B	testAddElement()	0	34	2
A	testHasElement()	0	14	2
B	testRemoveElement()	0	27	3
A	testGetHash()	0	17	2
A	testIndicesAreUpToDate()	0	15	1

<?php

namespace Wikibase\DataModel\Tests\HashArray;

use Hashable;
use Wikibase\DataModel\Fixtures\HashArrayElement;
use Wikibase\DataModel\Fixtures\MutableHashable;
use Wikibase\DataModel\HashArray;
use Wikibase\DataModel\Snak\PropertyNoValueSnak;

/**
 * @covers Wikibase\DataModel\HashArray
 *
 * @group Wikibase
 * @group WikibaseDataModel
 * @group HashArray
 *
 * @license GPL-2.0+
 * @author Jeroen De Dauw < jeroendedauw@gmail.com >
 */
class HashArrayWithoutDuplicatesTest extends HashArrayTest {

	public function constructorProvider() {
		$argLists = [];

		$argLists[] = [ HashArrayElement::getInstances() ];
		$argLists[] = [ array_merge( HashArrayElement::getInstances(), HashArrayElement::getInstances() ) ];

		return $argLists;
	}

	public function getInstanceClass() {
		return 'Wikibase\DataModel\Fixtures\HashArrayWithoutDuplicates';
	}

	public function elementInstancesProvider() {
		return $this->arrayWrap( array_merge(
			$this->arrayWrap( HashArrayElement::getInstances() ),
			[ HashArrayElement::getInstances() ]
		) );
	}

	/**
	 * @dataProvider instanceProvider
	 * @param HashArray $array
	 */
	public function testAddElement( HashArray $array ) {
		$elementCount = $array->count();

		$elements = $this->elementInstancesProvider();
		$element = array_shift( $elements );
		$element = $element[0][0];

		if ( !$array->hasElement( $element ) ) {
			++$elementCount;
		}

		$this->assertEquals(
			!$array->hasElement( $element ),
			$array->addElement( $element ),
			'Adding an element should only work if its not already there'
		);

		$this->assertEquals(
			$elementCount,
			$array->count(),
			'Element count should only increase if the element was not there yet'
		);

		$this->assertFalse(
			$array->addElement( $element ),
			'Adding an already present element should not work'
		);

		$this->assertEquals(
			$elementCount,
			$array->count(),
			'Element count should not increase if the element is already there'
		);
	}

	/**
	 * @dataProvider instanceProvider
	 * @param HashArray $array
	 */
	public function testHasElement( HashArray $array ) {
		/**
		 * @var Hashable $hashable
		 */
		foreach ( iterator_to_array( $array ) as $hashable ) {
			$this->assertTrue( $array->hasElement( $hashable ) );
			$this->assertTrue( $array->hasElementHash( $hashable->getHash() ) );
			$array->removeElement( $hashable );
			$this->assertFalse( $array->hasElement( $hashable ) );
			$this->assertFalse( $array->hasElementHash( $hashable->getHash() ) );
		}

		$this->assertTrue( true );
	}

	/**
	 * @dataProvider instanceProvider
	 * @param HashArray $array
	 */
	public function testRemoveElement( HashArray $array ) {
		$elementCount = $array->count();

		/**
		 * @var Hashable $element
		 */
		foreach ( iterator_to_array( $array ) as $element ) {
			$this->assertTrue( $array->hasElement( $element ) );

			if ( $elementCount % 2 === 0 ) {
				$array->removeElement( $element );
			}
			else {
				$array->removeByElementHash( $element->getHash() );
			}

			$this->assertFalse( $array->hasElement( $element ) );
			$this->assertEquals( --$elementCount, $array->count() );
		}

		$element = new PropertyNoValueSnak( 42 );

		$array->removeElement( $element );
		$array->removeByElementHash( $element->getHash() );

		$this->assertTrue( true );
	}

	/**
	 * @dataProvider instanceProvider
	 * @param HashArray $array
	 */
	public function testGetHash( HashArray $array ) {
		$hash = $array->getHash();

		$this->assertSame( $hash, $array->getHash() );

		$elements = $this->elementInstancesProvider();
		$element = array_shift( $elements );
		$element = $element[0][0];

		$array->addElement( $element );

		if ( $array->hasElement( $element ) ) {
			$this->assertSame( $hash, $array->getHash() );
		} else {
			$this->assertNotSame( $hash, $array->getHash() );
		}
	}

	/**
	 * @dataProvider instanceProvider
	 * @param HashArray $array
	 */
	public function testIndicesAreUpToDate( HashArray $array ) {
		$this->assertInternalType( 'boolean', $array->indicesAreUpToDate() );

		$mutable = new MutableHashable();

		$array->addElement( $mutable );

		$mutable->text = '~[,,_,,]:3';

		$this->assertFalse( $array->indicesAreUpToDate() );

		$array->rebuildIndices();

		$this->assertTrue( $array->indicesAreUpToDate() );
	}

}