ReferenceListTest::testRemoveReference() - Code Metrics - Inspection of "Add DeprecatedNumericEntityIdProvider" - wmde/WikibaseDataModel - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#667)

by no

created 2016-05-11 10:13 UTC

ReferenceListTest::testRemoveReference() A

↳ Parent: ReferenceListTest

Complexity

Conditions	2
Paths	2

Size

Total Lines	15
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Metric	Value
dl	0
loc	15
rs	9.4285
cc	2
eloc	7
nc	2
nop	1

<?php

namespace Wikibase\DataModel\Tests;

use Hashable;
use InvalidArgumentException;
use PHPUnit_Framework_TestCase;
use Wikibase\DataModel\Entity\PropertyId;
use Wikibase\DataModel\Reference;
use Wikibase\DataModel\ReferenceList;
use Wikibase\DataModel\Snak\PropertyNoValueSnak;
use Wikibase\DataModel\Snak\SnakList;

/**
 * @covers Wikibase\DataModel\ReferenceList
 *
 * @group Wikibase
 * @group WikibaseDataModel
 * @group WikibaseReference
 *
 * @license GPL-2.0+
 * @author Jeroen De Dauw < [email protected] >
 * @author Thiemo Mättig
 */
class ReferenceListTest extends PHPUnit_Framework_TestCase {

	public function instanceProvider() {
		return array(
			array( new ReferenceList( array() ) ),
			array( new ReferenceList( array(
				new Reference(),
				new Reference( array( new PropertyNoValueSnak( 2 ) ) ),
				new Reference( array( new PropertyNoValueSnak( 3 ) ) ),
			) ) ),
		);
	}

	public function testCanConstructWithReferenceListObject() {
		$reference = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
		$original = new ReferenceList( array( $reference ) );
		$copy = new ReferenceList( $original );

		$this->assertSame( 1, $copy->count() );
		$this->assertNotNull( $copy->getReference( $reference->getHash() ) );
	}

	public function testConstructorIgnoresIdenticalObjects() {
		$reference = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
		$list = new ReferenceList( array( $reference, $reference ) );
		$this->assertCount( 1, $list );
	}

	public function testConstructorDoesNotIgnoreCopies() {
		$reference = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
		$list = new ReferenceList( array( $reference, clone $reference ) );
		$this->assertCount( 2, $list );
	}

	/**
	 * @dataProvider invalidConstructorArgumentsProvider
	 * @expectedException InvalidArgumentException
	 */
	public function testGivenInvalidConstructorArguments_constructorThrowsException( $input ) {
		new ReferenceList( $input );
	}

	public function invalidConstructorArgumentsProvider() {
		$id1 = new PropertyId( 'P1' );

		return array(
			array( null ),
			array( false ),
			array( 1 ),
			array( 0.1 ),
			array( 'string' ),
			array( $id1 ),
			array( new PropertyNoValueSnak( $id1 ) ),
			array( new Reference() ),
			array( new SnakList( array( new PropertyNoValueSnak( $id1 ) ) ) ),
			array( array( new PropertyNoValueSnak( $id1 ) ) ),
			array( array( new ReferenceList() ) ),
			array( array( new SnakList() ) ),
		);
	}

	public function testGetIterator_isTraversable() {
		$references = new ReferenceList();
		$references->addNewReference( new PropertyNoValueSnak( 1 ) );
		$iterator = $references->getIterator();

		$this->assertInstanceOf( 'Traversable', $iterator );
		$this->assertCount( 1, $iterator );
		foreach ( $references as $reference ) {
			$this->assertInstanceOf( 'Wikibase\DataModel\Reference', $reference );
		}
	}

	/**
	 * @dataProvider instanceProvider
	 */
	public function testHasReferenceBeforeRemoveButNotAfter( ReferenceList $array ) {
		if ( $array->count() === 0 ) {
			$this->assertTrue( true );
			return;
		}

		/**
		 * @var Reference $hashable
		 */
		foreach ( iterator_to_array( $array ) as $hashable ) {
			$this->assertTrue( $array->hasReference( $hashable ) );
			$array->removeReference( $hashable );
			$this->assertFalse( $array->hasReference( $hashable ) );
		}
	}

	public function testGivenCloneOfReferenceInList_hasReferenceReturnsTrue() {
		$list = new ReferenceList();

		$reference = new Reference( array( new PropertyNoValueSnak( 42 ) ) );
		$sameReference = unserialize( serialize( $reference ) );

		$list->addReference( $reference );

		$this->assertTrue(
			$list->hasReference( $sameReference ),
			'hasReference should return true when a reference with the same value is present, even when its another instance'
		);
	}

	/**
	 * @dataProvider instanceProvider
	 */
	public function testRemoveReference( ReferenceList $array ) {
		$elementCount = count( $array );

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

			$array->removeReference( $element );

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

	public function testRemoveReferenceRemovesIdenticalObjects() {
		$reference = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
		$references = new ReferenceList( array( $reference, $reference ) );

		$references->removeReference( $reference );

		$this->assertTrue( $references->isEmpty() );
	}

	public function testRemoveReferenceDoesNotRemoveCopies() {
		$reference = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
		$references = new ReferenceList( array( $reference, clone $reference ) );

		$references->removeReference( $reference );

		$this->assertFalse( $references->isEmpty() );
		$this->assertTrue( $references->hasReference( $reference ) );
		$this->assertNotSame( $reference, $references->getReference( $reference->getHash() ) );
	}

	public function testAddReferenceOnEmptyList() {
		$reference = new Reference( array( new PropertyNoValueSnak( 1 ) ) );

		$references = new ReferenceList();
		$references->addReference( $reference );

		$this->assertCount( 1, $references );

		$expectedList = new ReferenceList( array( $reference ) );
		$this->assertSameReferenceOrder( $expectedList, $references );
	}

	private function assertSameReferenceOrder( ReferenceList $expectedList, ReferenceList $references ) {
		$this->assertEquals(
			iterator_to_array( $expectedList ),
			iterator_to_array( $references )
		);
	}

	public function testAddReferenceOnNonEmptyList() {
		$reference1 = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
		$reference2 = new Reference( array( new PropertyNoValueSnak( 2 ) ) );
		$reference3 = new Reference( array( new PropertyNoValueSnak( 3 ) ) );

		$references = new ReferenceList( array( $reference1, $reference2 ) );
		$references->addReference( $reference3 );

		$this->assertCount( 3, $references );

		$expectedList = new ReferenceList( array( $reference1, $reference2, $reference3 ) );
		$this->assertSameReferenceOrder( $expectedList, $references );
	}

	public function testAddReferenceIgnoresIdenticalObjects() {
		$list = new ReferenceList();
		$reference = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
		$list->addReference( $reference );
		$list->addReference( $reference );
		$this->assertCount( 1, $list );
	}

	public function testAddReferenceDoesNotIgnoreCopies() {
		$list = new ReferenceList();
		$reference = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
		$list->addReference( $reference );
		$list->addReference( clone $reference );
		$this->assertCount( 2, $list );
	}

	public function testAddReferenceAtIndexIgnoresIdenticalObjects() {
		$list = new ReferenceList();
		$reference = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
		$list->addReference( $reference, 0 );
		$list->addReference( $reference, 0 );
		$this->assertCount( 1, $list );
	}

	public function testAddReferenceAtIndexMovesIdenticalObjects() {
		$list = new ReferenceList();
		$list->addNewReference( new PropertyNoValueSnak( 1 ) );
		$reference = new Reference( array( new PropertyNoValueSnak( 2 ) ) );
		$list->addReference( $reference );
		$this->assertSame( 1, $list->indexOf( $reference ), 'pre condition' );

		$list->addReference( $reference, 0 );

		$this->assertCount( 2, $list, 'not added' );
		$this->assertSame( 0, $list->indexOf( $reference ), 'can decrease index' );

		$list->addReference( $reference, 2 );

		$this->assertCount( 2, $list, 'not added' );
		$this->assertSame( 0, $list->indexOf( $reference ), 'can not increase index' );
	}

	public function testAddReferenceAtIndexZero() {
		$reference1 = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
		$reference2 = new Reference( array( new PropertyNoValueSnak( 2 ) ) );
		$reference3 = new Reference( array( new PropertyNoValueSnak( 3 ) ) );

		$references = new ReferenceList( array( $reference1, $reference2 ) );
		$references->addReference( $reference3, 0 );

		$expectedList = new ReferenceList( array( $reference3, $reference1, $reference2 ) );
		$this->assertSameReferenceOrder( $expectedList, $references );
	}

	public function testAddReferenceAtNegativeIndex() {
		$reference = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
		$referenceList = new ReferenceList();

		$this->setExpectedException( 'InvalidArgumentException' );

		$referenceList->addReference( $reference, -1 );
	}

	public function testGivenEmptyReference_addReferenceDoesNotAdd() {
		$reference1 = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
		$reference2 = new Reference( array( new PropertyNoValueSnak( 2 ) ) );
		$emptyReference = new Reference( array() );

		$references = new ReferenceList( array( $reference1, $reference2 ) );
		$references->addReference( $emptyReference );

		$expectedList = new ReferenceList( array( $reference1, $reference2 ) );
		$this->assertSameReferenceOrder( $expectedList, $references );
	}

	public function testGivenEmptyReferenceAndIndex_addReferenceDoesNotAdd() {
		$reference1 = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
		$reference2 = new Reference( array( new PropertyNoValueSnak( 2 ) ) );
		$emptyReference = new Reference( array() );

		$references = new ReferenceList( array( $reference1, $reference2 ) );
		$references->addReference( $emptyReference, 0 );

		$expectedList = new ReferenceList( array( $reference1, $reference2 ) );
		$this->assertSameReferenceOrder( $expectedList, $references );
	}

	/**
	 * @dataProvider instanceProvider
	 */
	public function testIndexOf( ReferenceList $array ) {
		$this->assertFalse( $array->indexOf( new Reference() ) );

		$i = 0;
		foreach ( $array as $reference ) {
			$this->assertEquals( $i++, $array->indexOf( $reference ) );
		}
	}

	public function testIndexOf_checksForIdentity() {
		$reference1 = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
		$reference2 = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
		$referenceList = new ReferenceList( array( $reference1 ) );

		$this->assertNotSame( $reference1, $reference2, 'post condition' );
		$this->assertTrue( $reference1->equals( $reference2 ), 'post condition' );
		$this->assertSame( 0, $referenceList->indexOf( $reference1 ), 'identity' );
		$this->assertFalse( $referenceList->indexOf( $reference2 ), 'not equality' );
	}

	/**
	 * @dataProvider instanceProvider
	 */
	public function testEquals( ReferenceList $array ) {
		$this->assertTrue( $array->equals( $array ) );
		$this->assertFalse( $array->equals( 42 ) );
	}

	/**
	 * @dataProvider instanceProvider
	 */
	public function testGetValueHashReturnsString( ReferenceList $array ) {
		$this->assertInternalType( 'string', $array->getValueHash() );
	}

	/**
	 * @dataProvider instanceProvider
	 */
	public function testGetValueHashIsTheSameForClone( ReferenceList $array ) {
		$copy = unserialize( serialize( $array ) );
		$this->assertEquals( $array->getValueHash(), $copy->getValueHash() );
	}

	/**
	 * @dataProvider instanceProvider
	 */
	public function testHasReferenceHash( ReferenceList $references ) {
		$this->assertFalse( $references->hasReferenceHash( '~=[,,_,,]:3' ) );

		/**
		 * @var Hashable $reference
		 */
		foreach ( $references as $reference ) {
			$this->assertTrue( $references->hasReferenceHash( $reference->getHash() ) );
		}
	}

	/**
	 * @dataProvider instanceProvider
	 */
	public function testGetReference( ReferenceList $references ) {
		$this->assertNull( $references->getReference( '~=[,,_,,]:3' ) );

		/**
		 * @var Reference $reference
		 */
		foreach ( $references as $reference ) {
			$this->assertTrue( $reference->equals( $references->getReference( $reference->getHash() ) ) );
		}
	}

	/**
	 * @dataProvider instanceProvider
	 */
	public function testRemoveReferenceHash( ReferenceList $references ) {
		$references->removeReferenceHash( '~=[,,_,,]:3' );

		$hashes = array();

		/**
		 * @var Reference $reference
		 */
		foreach ( $references as $reference ) {
			$hashes[] = $reference->getHash();
		}

		foreach ( $hashes as $hash ) {
			$references->removeReferenceHash( $hash );
		}

		$this->assertEquals( 0, count( $references ) );
	}

	public function testRemoveReferenceHashRemovesIdenticalObjects() {
		$reference = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
		$references = new ReferenceList( array( $reference, $reference ) );

		$references->removeReferenceHash( $reference->getHash() );

		$this->assertTrue( $references->isEmpty() );
	}

	public function testRemoveReferenceHashDoesNotRemoveCopies() {
		$reference = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
		$references = new ReferenceList( array( $reference, clone $reference ) );

		$references->removeReferenceHash( $reference->getHash() );

		$this->assertFalse( $references->isEmpty() );
		$this->assertTrue( $references->hasReference( $reference ) );
		$this->assertNotSame( $reference, $references->getReference( $reference->getHash() ) );
	}

	public function testRemoveReferenceHashUpdatesIndexes() {
		$reference1 = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
		$reference2 = new Reference( array( new PropertyNoValueSnak( 2 ) ) );
		$references = new ReferenceList( array( $reference1, $reference2 ) );

		$references->removeReferenceHash( $reference1->getHash() );

		$this->assertSame( 0, $references->indexOf( $reference2 ) );
	}

	public function testGivenOneSnak_addNewReferenceAddsSnak() {
		$references = new ReferenceList();
		$snak = new PropertyNoValueSnak( 1 );

		$references->addNewReference( $snak );
		$this->assertTrue( $references->hasReference( new Reference( array( $snak ) ) ) );
	}

	public function testGivenMultipleSnaks_addNewReferenceAddsThem() {
		$references = new ReferenceList();
		$snak1 = new PropertyNoValueSnak( 1 );
		$snak2 = new PropertyNoValueSnak( 3 );
		$snak3 = new PropertyNoValueSnak( 2 );

		$references->addNewReference( $snak1, $snak2, $snak3 );

		$expectedSnaks = array( $snak1, $snak2, $snak3 );
		$this->assertTrue( $references->hasReference( new Reference( $expectedSnaks ) ) );
	}

	public function testGivenAnArrayOfSnaks_addNewReferenceAddsThem() {
		$references = new ReferenceList();
		$snaks = array(
			new PropertyNoValueSnak( 1 ),
			new PropertyNoValueSnak( 3 ),
			new PropertyNoValueSnak( 2 )
		);

		$references->addNewReference( $snaks );
		$this->assertTrue( $references->hasReference( new Reference( $snaks ) ) );
	}

	public function testAddNewReferenceDoesNotIgnoreIdenticalObjects() {
		$list = new ReferenceList();
		$snak = new PropertyNoValueSnak( 1 );
		$list->addNewReference( $snak );
		$list->addNewReference( $snak );
		$this->assertCount( 2, $list );
	}

	public function testAddNewReferenceDoesNotIgnoreCopies() {
		$list = new ReferenceList();
		$snak = new PropertyNoValueSnak( 1 );
		$list->addNewReference( $snak );
		$list->addNewReference( clone $snak );
		$this->assertCount( 2, $list );
	}

	public function testGivenNoneSnak_addNewReferenceThrowsException() {
		$references = new ReferenceList();

		$this->setExpectedException( 'InvalidArgumentException' );

		$references->addNewReference( new PropertyNoValueSnak( 1 ), null );
	}

	public function testEmptySerializationStability() {
		$list = new ReferenceList();
		$this->assertSame( 'a:0:{}', $list->serialize() );
	}

	public function testSerializationStability() {
		$list = new ReferenceList();
		$list->addNewReference( new PropertyNoValueSnak( 1 ) );
		$this->assertSame(
			"a:1:{i:0;O:28:\"Wikibase\\DataModel\\Reference\":1:{s:35:\"\x00Wikibase\\DataModel\\"
			. "Reference\x00snaks\";C:32:\"Wikibase\\DataModel\\Snak\\SnakList\":102:{a:2:{s:4:\""
			. 'data";a:1:{i:0;C:43:"Wikibase\\DataModel\\Snak\\PropertyNoValueSnak":4:{i:1;}}s:5'
			. ':"index";i:0;}}}}',
			$list->serialize()
		);
	}

	public function testSerializeUnserializeRoundtrip() {
		$original = new ReferenceList();
		$original->addNewReference( new PropertyNoValueSnak( 1 ) );

		/** @var ReferenceList $clone */
		$clone = unserialize( serialize( $original ) );

		$this->assertTrue( $original->equals( $clone ) );
		$this->assertSame( $original->getValueHash(), $clone->getValueHash() );
		$this->assertSame( $original->serialize(), $clone->serialize() );
	}

	public function testUnserializeCreatesNonIdenticalClones() {
		$original = new ReferenceList();
		$reference = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
		$original->addReference( $reference );

		/** @var ReferenceList $clone */
		$clone = unserialize( serialize( $original ) );
		$clone->addReference( $reference );

		$this->assertCount( 2, $clone );
	}

	public function testGivenEmptyList_isEmpty() {
		$references = new ReferenceList();
		$this->assertTrue( $references->isEmpty() );
	}

	public function testGivenNonEmptyList_isNotEmpty() {
		$references = new ReferenceList();
		$references->addNewReference( new PropertyNoValueSnak( 1 ) );

		$this->assertFalse( $references->isEmpty() );
	}

}


1			<?php
2
3			namespace Wikibase\DataModel\Tests;
4
5			use Hashable;
6			use InvalidArgumentException;
7			use PHPUnit_Framework_TestCase;
8			use Wikibase\DataModel\Entity\PropertyId;
9			use Wikibase\DataModel\Reference;
10			use Wikibase\DataModel\ReferenceList;
11			use Wikibase\DataModel\Snak\PropertyNoValueSnak;
12			use Wikibase\DataModel\Snak\SnakList;
13
14			/**
15			* @covers Wikibase\DataModel\ReferenceList
16			*
17			* @group Wikibase
18			* @group WikibaseDataModel
19			* @group WikibaseReference
20			*
21			* @license GPL-2.0+
22			* @author Jeroen De Dauw < [email protected] >
23			* @author Thiemo Mättig
24			*/
25			class ReferenceListTest extends PHPUnit_Framework_TestCase {
26
27			public function instanceProvider() {
28			return array(
29			array( new ReferenceList( array() ) ),
30			array( new ReferenceList( array(
31			new Reference(),
32			new Reference( array( new PropertyNoValueSnak( 2 ) ) ),
33			new Reference( array( new PropertyNoValueSnak( 3 ) ) ),
34			) ) ),
35			);
36			}
37
38			public function testCanConstructWithReferenceListObject() {
39			$reference = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
40			$original = new ReferenceList( array( $reference ) );
41			$copy = new ReferenceList( $original );
42
43			$this->assertSame( 1, $copy->count() );
44			$this->assertNotNull( $copy->getReference( $reference->getHash() ) );
45			}
46
47			public function testConstructorIgnoresIdenticalObjects() {
48			$reference = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
49			$list = new ReferenceList( array( $reference, $reference ) );
50			$this->assertCount( 1, $list );
51			}
52
53			public function testConstructorDoesNotIgnoreCopies() {
54			$reference = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
55			$list = new ReferenceList( array( $reference, clone $reference ) );
56			$this->assertCount( 2, $list );
57			}
58
59			/**
60			* @dataProvider invalidConstructorArgumentsProvider
61			* @expectedException InvalidArgumentException
62			*/
63			public function testGivenInvalidConstructorArguments_constructorThrowsException( $input ) {
64			new ReferenceList( $input );
65			}
66
67			public function invalidConstructorArgumentsProvider() {
68			$id1 = new PropertyId( 'P1' );
69
70			return array(
71			array( null ),
72			array( false ),
73			array( 1 ),
74			array( 0.1 ),
75			array( 'string' ),
76			array( $id1 ),
77			array( new PropertyNoValueSnak( $id1 ) ),
78			array( new Reference() ),
79			array( new SnakList( array( new PropertyNoValueSnak( $id1 ) ) ) ),
80			array( array( new PropertyNoValueSnak( $id1 ) ) ),
81			array( array( new ReferenceList() ) ),
82			array( array( new SnakList() ) ),
83			);
84			}
85
86			public function testGetIterator_isTraversable() {
87			$references = new ReferenceList();
88			$references->addNewReference( new PropertyNoValueSnak( 1 ) );
89			$iterator = $references->getIterator();
90
91			$this->assertInstanceOf( 'Traversable', $iterator );
92			$this->assertCount( 1, $iterator );
93			foreach ( $references as $reference ) {
94			$this->assertInstanceOf( 'Wikibase\DataModel\Reference', $reference );
95			}
96			}
97
98			/**
99			* @dataProvider instanceProvider
100			*/
101			public function testHasReferenceBeforeRemoveButNotAfter( ReferenceList $array ) {
102			if ( $array->count() === 0 ) {
103			$this->assertTrue( true );
104			return;
105			}
106
107			/**
108			* @var Reference $hashable
109			*/
110			foreach ( iterator_to_array( $array ) as $hashable ) {
111			$this->assertTrue( $array->hasReference( $hashable ) );
112			$array->removeReference( $hashable );
113			$this->assertFalse( $array->hasReference( $hashable ) );
114			}
115			}
116
117			public function testGivenCloneOfReferenceInList_hasReferenceReturnsTrue() {
118			$list = new ReferenceList();
119
120			$reference = new Reference( array( new PropertyNoValueSnak( 42 ) ) );
121			$sameReference = unserialize( serialize( $reference ) );
122
123			$list->addReference( $reference );
124
125			$this->assertTrue(
126			$list->hasReference( $sameReference ),
127			'hasReference should return true when a reference with the same value is present, even when its another instance'
128			);
129			}
130
131			/**
132			* @dataProvider instanceProvider
133			*/
134			public function testRemoveReference( ReferenceList $array ) {
135			$elementCount = count( $array );
136
137			/**
138			* @var Reference $element
139			*/
140			foreach ( iterator_to_array( $array ) as $element ) {
141			$this->assertTrue( $array->hasReference( $element ) );
142
143			$array->removeReference( $element );
144
145			$this->assertFalse( $array->hasReference( $element ) );
146			$this->assertEquals( --$elementCount, count( $array ) );
147			}
148			}
149
150			public function testRemoveReferenceRemovesIdenticalObjects() {
151			$reference = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
152			$references = new ReferenceList( array( $reference, $reference ) );
153
154			$references->removeReference( $reference );
155
156			$this->assertTrue( $references->isEmpty() );
157			}
158
159			public function testRemoveReferenceDoesNotRemoveCopies() {
160			$reference = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
161			$references = new ReferenceList( array( $reference, clone $reference ) );
162
163			$references->removeReference( $reference );
164
165			$this->assertFalse( $references->isEmpty() );
166			$this->assertTrue( $references->hasReference( $reference ) );
167			$this->assertNotSame( $reference, $references->getReference( $reference->getHash() ) );
168			}
169
170			public function testAddReferenceOnEmptyList() {
171			$reference = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
172
173			$references = new ReferenceList();
174			$references->addReference( $reference );
175
176			$this->assertCount( 1, $references );
177
178			$expectedList = new ReferenceList( array( $reference ) );
179			$this->assertSameReferenceOrder( $expectedList, $references );
180			}
181
182			private function assertSameReferenceOrder( ReferenceList $expectedList, ReferenceList $references ) {
183			$this->assertEquals(
184			iterator_to_array( $expectedList ),
185			iterator_to_array( $references )
186			);
187			}
188
189			public function testAddReferenceOnNonEmptyList() {
190			$reference1 = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
191			$reference2 = new Reference( array( new PropertyNoValueSnak( 2 ) ) );
192			$reference3 = new Reference( array( new PropertyNoValueSnak( 3 ) ) );
193
194			$references = new ReferenceList( array( $reference1, $reference2 ) );
195			$references->addReference( $reference3 );
196
197			$this->assertCount( 3, $references );
198
199			$expectedList = new ReferenceList( array( $reference1, $reference2, $reference3 ) );
200			$this->assertSameReferenceOrder( $expectedList, $references );
201			}
202
203			public function testAddReferenceIgnoresIdenticalObjects() {
204			$list = new ReferenceList();
205			$reference = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
206			$list->addReference( $reference );
207			$list->addReference( $reference );
208			$this->assertCount( 1, $list );
209			}
210
211			public function testAddReferenceDoesNotIgnoreCopies() {
212			$list = new ReferenceList();
213			$reference = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
214			$list->addReference( $reference );
215			$list->addReference( clone $reference );
216			$this->assertCount( 2, $list );
217			}
218
219			public function testAddReferenceAtIndexIgnoresIdenticalObjects() {
220			$list = new ReferenceList();
221			$reference = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
222			$list->addReference( $reference, 0 );
223			$list->addReference( $reference, 0 );
224			$this->assertCount( 1, $list );
225			}
226
227			public function testAddReferenceAtIndexMovesIdenticalObjects() {
228			$list = new ReferenceList();
229			$list->addNewReference( new PropertyNoValueSnak( 1 ) );
230			$reference = new Reference( array( new PropertyNoValueSnak( 2 ) ) );
231			$list->addReference( $reference );
232			$this->assertSame( 1, $list->indexOf( $reference ), 'pre condition' );
233
234			$list->addReference( $reference, 0 );
235
236			$this->assertCount( 2, $list, 'not added' );
237			$this->assertSame( 0, $list->indexOf( $reference ), 'can decrease index' );
238
239			$list->addReference( $reference, 2 );
240
241			$this->assertCount( 2, $list, 'not added' );
242			$this->assertSame( 0, $list->indexOf( $reference ), 'can not increase index' );
243			}
244
245			public function testAddReferenceAtIndexZero() {
246			$reference1 = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
247			$reference2 = new Reference( array( new PropertyNoValueSnak( 2 ) ) );
248			$reference3 = new Reference( array( new PropertyNoValueSnak( 3 ) ) );
249
250			$references = new ReferenceList( array( $reference1, $reference2 ) );
251			$references->addReference( $reference3, 0 );
252
253			$expectedList = new ReferenceList( array( $reference3, $reference1, $reference2 ) );
254			$this->assertSameReferenceOrder( $expectedList, $references );
255			}
256
257			public function testAddReferenceAtNegativeIndex() {
258			$reference = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
259			$referenceList = new ReferenceList();
260
261			$this->setExpectedException( 'InvalidArgumentException' );
			0 ignored issues – show Deprecated Code introduced 2016-03-07 13:35 UTC by Report Bug Copy Issue Report The method `PHPUnit_Framework_TestCase::setExpectedException()` has been deprecated with message: Method deprecated since Release 5.2.0 This method has been deprecated. The supplier of the class has supplied an explanatory message. The explanatory message should give you some clue as to whether and when the method will be removed from the class and what other method or class to use instead. Loading history...
262			$referenceList->addReference( $reference, -1 );
263			}
264
265			public function testGivenEmptyReference_addReferenceDoesNotAdd() {
266			$reference1 = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
267			$reference2 = new Reference( array( new PropertyNoValueSnak( 2 ) ) );
268			$emptyReference = new Reference( array() );
269
270			$references = new ReferenceList( array( $reference1, $reference2 ) );
271			$references->addReference( $emptyReference );
272
273			$expectedList = new ReferenceList( array( $reference1, $reference2 ) );
274			$this->assertSameReferenceOrder( $expectedList, $references );
275			}
276
277			public function testGivenEmptyReferenceAndIndex_addReferenceDoesNotAdd() {
278			$reference1 = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
279			$reference2 = new Reference( array( new PropertyNoValueSnak( 2 ) ) );
280			$emptyReference = new Reference( array() );
281
282			$references = new ReferenceList( array( $reference1, $reference2 ) );
283			$references->addReference( $emptyReference, 0 );
284
285			$expectedList = new ReferenceList( array( $reference1, $reference2 ) );
286			$this->assertSameReferenceOrder( $expectedList, $references );
287			}
288
289			/**
290			* @dataProvider instanceProvider
291			*/
292			public function testIndexOf( ReferenceList $array ) {
293			$this->assertFalse( $array->indexOf( new Reference() ) );
294
295			$i = 0;
296			foreach ( $array as $reference ) {
297			$this->assertEquals( $i++, $array->indexOf( $reference ) );
298			}
299			}
300
301			public function testIndexOf_checksForIdentity() {
302			$reference1 = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
303			$reference2 = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
304			$referenceList = new ReferenceList( array( $reference1 ) );
305
306			$this->assertNotSame( $reference1, $reference2, 'post condition' );
307			$this->assertTrue( $reference1->equals( $reference2 ), 'post condition' );
308			$this->assertSame( 0, $referenceList->indexOf( $reference1 ), 'identity' );
309			$this->assertFalse( $referenceList->indexOf( $reference2 ), 'not equality' );
310			}
311
312			/**
313			* @dataProvider instanceProvider
314			*/
315			public function testEquals( ReferenceList $array ) {
316			$this->assertTrue( $array->equals( $array ) );
317			$this->assertFalse( $array->equals( 42 ) );
318			}
319
320			/**
321			* @dataProvider instanceProvider
322			*/
323			public function testGetValueHashReturnsString( ReferenceList $array ) {
324			$this->assertInternalType( 'string', $array->getValueHash() );
325			}
326
327			/**
328			* @dataProvider instanceProvider
329			*/
330			public function testGetValueHashIsTheSameForClone( ReferenceList $array ) {
331			$copy = unserialize( serialize( $array ) );
332			$this->assertEquals( $array->getValueHash(), $copy->getValueHash() );
333			}
334
335			/**
336			* @dataProvider instanceProvider
337			*/
338			public function testHasReferenceHash( ReferenceList $references ) {
339			$this->assertFalse( $references->hasReferenceHash( '~=[,,_,,]:3' ) );
340
341			/**
342			* @var Hashable $reference
343			*/
344			foreach ( $references as $reference ) {
345			$this->assertTrue( $references->hasReferenceHash( $reference->getHash() ) );
346			}
347			}
348
349			/**
350			* @dataProvider instanceProvider
351			*/
352			public function testGetReference( ReferenceList $references ) {
353			$this->assertNull( $references->getReference( '~=[,,_,,]:3' ) );
354
355			/**
356			* @var Reference $reference
357			*/
358			foreach ( $references as $reference ) {
359			$this->assertTrue( $reference->equals( $references->getReference( $reference->getHash() ) ) );
360			}
361			}
362
363			/**
364			* @dataProvider instanceProvider
365			*/
366			public function testRemoveReferenceHash( ReferenceList $references ) {
367			$references->removeReferenceHash( '~=[,,_,,]:3' );
368
369			$hashes = array();
370
371			/**
372			* @var Reference $reference
373			*/
374			foreach ( $references as $reference ) {
375			$hashes[] = $reference->getHash();
376			}
377
378			foreach ( $hashes as $hash ) {
379			$references->removeReferenceHash( $hash );
380			}
381
382			$this->assertEquals( 0, count( $references ) );
383			}
384
385			public function testRemoveReferenceHashRemovesIdenticalObjects() {
386			$reference = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
387			$references = new ReferenceList( array( $reference, $reference ) );
388
389			$references->removeReferenceHash( $reference->getHash() );
390
391			$this->assertTrue( $references->isEmpty() );
392			}
393
394			public function testRemoveReferenceHashDoesNotRemoveCopies() {
395			$reference = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
396			$references = new ReferenceList( array( $reference, clone $reference ) );
397
398			$references->removeReferenceHash( $reference->getHash() );
399
400			$this->assertFalse( $references->isEmpty() );
401			$this->assertTrue( $references->hasReference( $reference ) );
402			$this->assertNotSame( $reference, $references->getReference( $reference->getHash() ) );
403			}
404
405			public function testRemoveReferenceHashUpdatesIndexes() {
406			$reference1 = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
407			$reference2 = new Reference( array( new PropertyNoValueSnak( 2 ) ) );
408			$references = new ReferenceList( array( $reference1, $reference2 ) );
409
410			$references->removeReferenceHash( $reference1->getHash() );
411
412			$this->assertSame( 0, $references->indexOf( $reference2 ) );
413			}
414
415			public function testGivenOneSnak_addNewReferenceAddsSnak() {
416			$references = new ReferenceList();
417			$snak = new PropertyNoValueSnak( 1 );
418
419			$references->addNewReference( $snak );
420			$this->assertTrue( $references->hasReference( new Reference( array( $snak ) ) ) );
421			}
422
423			public function testGivenMultipleSnaks_addNewReferenceAddsThem() {
424			$references = new ReferenceList();
425			$snak1 = new PropertyNoValueSnak( 1 );
426			$snak2 = new PropertyNoValueSnak( 3 );
427			$snak3 = new PropertyNoValueSnak( 2 );
428
429			$references->addNewReference( $snak1, $snak2, $snak3 );
430
431			$expectedSnaks = array( $snak1, $snak2, $snak3 );
432			$this->assertTrue( $references->hasReference( new Reference( $expectedSnaks ) ) );
433			}
434
435			public function testGivenAnArrayOfSnaks_addNewReferenceAddsThem() {
436			$references = new ReferenceList();
437			$snaks = array(
438			new PropertyNoValueSnak( 1 ),
439			new PropertyNoValueSnak( 3 ),
440			new PropertyNoValueSnak( 2 )
441			);
442
443			$references->addNewReference( $snaks );
444			$this->assertTrue( $references->hasReference( new Reference( $snaks ) ) );
445			}
446
447			public function testAddNewReferenceDoesNotIgnoreIdenticalObjects() {
448			$list = new ReferenceList();
449			$snak = new PropertyNoValueSnak( 1 );
450			$list->addNewReference( $snak );
451			$list->addNewReference( $snak );
452			$this->assertCount( 2, $list );
453			}
454
455			public function testAddNewReferenceDoesNotIgnoreCopies() {
456			$list = new ReferenceList();
457			$snak = new PropertyNoValueSnak( 1 );
458			$list->addNewReference( $snak );
459			$list->addNewReference( clone $snak );
460			$this->assertCount( 2, $list );
461			}
462
463			public function testGivenNoneSnak_addNewReferenceThrowsException() {
464			$references = new ReferenceList();
465
466			$this->setExpectedException( 'InvalidArgumentException' );
			0 ignored issues – show Deprecated Code introduced 2016-03-07 13:35 UTC by Report Bug Copy Issue Report The method `PHPUnit_Framework_TestCase::setExpectedException()` has been deprecated with message: Method deprecated since Release 5.2.0 This method has been deprecated. The supplier of the class has supplied an explanatory message. The explanatory message should give you some clue as to whether and when the method will be removed from the class and what other method or class to use instead. Loading history...
467			$references->addNewReference( new PropertyNoValueSnak( 1 ), null );
468			}
469
470			public function testEmptySerializationStability() {
471			$list = new ReferenceList();
472			$this->assertSame( 'a:0:{}', $list->serialize() );
473			}
474
475			public function testSerializationStability() {
476			$list = new ReferenceList();
477			$list->addNewReference( new PropertyNoValueSnak( 1 ) );
478			$this->assertSame(
479			"a:1:{i:0;O:28:\"Wikibase\\DataModel\\Reference\":1:{s:35:\"\x00Wikibase\\DataModel\\"
480			. "Reference\x00snaks\";C:32:\"Wikibase\\DataModel\\Snak\\SnakList\":102:{a:2:{s:4:\""
481			. 'data";a:1:{i:0;C:43:"Wikibase\\DataModel\\Snak\\PropertyNoValueSnak":4:{i:1;}}s:5'
482			. ':"index";i:0;}}}}',
483			$list->serialize()
484			);
485			}
486
487			public function testSerializeUnserializeRoundtrip() {
488			$original = new ReferenceList();
489			$original->addNewReference( new PropertyNoValueSnak( 1 ) );
490
491			/** @var ReferenceList $clone */
492			$clone = unserialize( serialize( $original ) );
493
494			$this->assertTrue( $original->equals( $clone ) );
495			$this->assertSame( $original->getValueHash(), $clone->getValueHash() );
496			$this->assertSame( $original->serialize(), $clone->serialize() );
497			}
498
499			public function testUnserializeCreatesNonIdenticalClones() {
500			$original = new ReferenceList();
501			$reference = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
502			$original->addReference( $reference );
503
504			/** @var ReferenceList $clone */
505			$clone = unserialize( serialize( $original ) );
506			$clone->addReference( $reference );
507
508			$this->assertCount( 2, $clone );
509			}
510
511			public function testGivenEmptyList_isEmpty() {
512			$references = new ReferenceList();
513			$this->assertTrue( $references->isEmpty() );
514			}
515
516			public function testGivenNonEmptyList_isNotEmpty() {
517			$references = new ReferenceList();
518			$references->addNewReference( new PropertyNoValueSnak( 1 ) );
519
520			$this->assertFalse( $references->isEmpty() );
521			}
522
523			}
524

wmde / WikibaseDataModel

Pull Request — master (#667)

ReferenceListTest::testRemoveReference() A

Complexity

Size

Duplication

Duplication Side-by-Side

Filter issues like