ReferenceListTest::testSerializationStability() - Code Metrics - Inspection of "Merge pull request #637 from wmde/assertTrueTrue" - wmde/WikibaseDataModel - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Push — refHashBehavior ( 70e111...ce2ac7 )

by no

created 2016-02-18 17:28 UTC

ReferenceListTest::testSerializationStability() A

↳ Parent: ReferenceListTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	1

Metric	Value
c	1
b	0
f	1
dl	0
loc	4
rs	10
cc	1
eloc	3
nc	1
nop	0

<?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
 *
 * @licence GNU GPL v2+
 * @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() ) );
	}

	/**
	 * @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 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 testRemoveReferenceHashRemovesCopies() {
		$reference = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
		$references = new ReferenceList( array( $reference, clone $reference ) );

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

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

	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 testGivenNoneSnak_addNewReferenceThrowsException() {
		$references = new ReferenceList();

		$this->setExpectedException( 'InvalidArgumentException' );

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

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

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

		$references->addReference( new Reference() );

		$references->addReference( new Reference( array(
			new PropertyNoValueSnak( 2 ),
			new PropertyNoValueSnak( 3 ),
		) ) );

		$serialized = serialize( $references );
		$this->assertTrue( $references->equals( unserialize( $serialized ) ) );
	}

	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			* @licence GNU GPL v2+
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			/**
48			* @dataProvider invalidConstructorArgumentsProvider
49			* @expectedException InvalidArgumentException
50			*/
51			public function testGivenInvalidConstructorArguments_constructorThrowsException( $input ) {
52			new ReferenceList( $input );
53			}
54
55			public function invalidConstructorArgumentsProvider() {
56			$id1 = new PropertyId( 'P1' );
57
58			return array(
59			array( null ),
60			array( false ),
61			array( 1 ),
62			array( 0.1 ),
63			array( 'string' ),
64			array( $id1 ),
65			array( new PropertyNoValueSnak( $id1 ) ),
66			array( new Reference() ),
67			array( new SnakList( array( new PropertyNoValueSnak( $id1 ) ) ) ),
68			array( array( new PropertyNoValueSnak( $id1 ) ) ),
69			array( array( new ReferenceList() ) ),
70			array( array( new SnakList() ) ),
71			);
72			}
73
74			public function testGetIterator_isTraversable() {
75			$references = new ReferenceList();
76			$references->addNewReference( new PropertyNoValueSnak( 1 ) );
77			$iterator = $references->getIterator();
78
79			$this->assertInstanceOf( 'Traversable', $iterator );
80			$this->assertCount( 1, $iterator );
81			foreach ( $references as $reference ) {
82			$this->assertInstanceOf( 'Wikibase\DataModel\Reference', $reference );
83			}
84			}
85
86			/**
87			* @dataProvider instanceProvider
88			*/
89			public function testHasReferenceBeforeRemoveButNotAfter( ReferenceList $array ) {
90			if ( $array->count() === 0 ) {
91			$this->assertTrue( true );
92			return;
93			}
94
95			/**
96			* @var Reference $hashable
97			*/
98			foreach ( iterator_to_array( $array ) as $hashable ) {
99			$this->assertTrue( $array->hasReference( $hashable ) );
100			$array->removeReference( $hashable );
101			$this->assertFalse( $array->hasReference( $hashable ) );
102			}
103			}
104
105			public function testGivenCloneOfReferenceInList_hasReferenceReturnsTrue() {
106			$list = new ReferenceList();
107
108			$reference = new Reference( array( new PropertyNoValueSnak( 42 ) ) );
109			$sameReference = unserialize( serialize( $reference ) );
110
111			$list->addReference( $reference );
112
113			$this->assertTrue(
114			$list->hasReference( $sameReference ),
115			'hasReference should return true when a reference with the same value is present, even when its another instance'
116			);
117			}
118
119			/**
120			* @dataProvider instanceProvider
121			*/
122			public function testRemoveReference( ReferenceList $array ) {
123			$elementCount = count( $array );
124
125			/**
126			* @var Reference $element
127			*/
128			foreach ( iterator_to_array( $array ) as $element ) {
129			$this->assertTrue( $array->hasReference( $element ) );
130
131			$array->removeReference( $element );
132
133			$this->assertFalse( $array->hasReference( $element ) );
134			$this->assertEquals( --$elementCount, count( $array ) );
135			}
136			}
137
138			public function testRemoveReferenceRemovesIdenticalObjects() {
139			$reference = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
140			$references = new ReferenceList( array( $reference, $reference ) );
141
142			$references->removeReference( $reference );
143
144			$this->assertTrue( $references->isEmpty() );
145			}
146
147			public function testRemoveReferenceDoesNotRemoveCopies() {
148			$reference = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
149			$references = new ReferenceList( array( $reference, clone $reference ) );
150
151			$references->removeReference( $reference );
152
153			$this->assertFalse( $references->isEmpty() );
154			$this->assertTrue( $references->hasReference( $reference ) );
155			$this->assertNotSame( $reference, $references->getReference( $reference->getHash() ) );
156			}
157
158			public function testAddReferenceOnEmptyList() {
159			$reference = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
160
161			$references = new ReferenceList();
162			$references->addReference( $reference );
163
164			$this->assertCount( 1, $references );
165
166			$expectedList = new ReferenceList( array( $reference ) );
167			$this->assertSameReferenceOrder( $expectedList, $references );
168			}
169
170			private function assertSameReferenceOrder( ReferenceList $expectedList, ReferenceList $references ) {
171			$this->assertEquals(
172			iterator_to_array( $expectedList ),
173			iterator_to_array( $references )
174			);
175			}
176
177			public function testAddReferenceOnNonEmptyList() {
178			$reference1 = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
179			$reference2 = new Reference( array( new PropertyNoValueSnak( 2 ) ) );
180			$reference3 = new Reference( array( new PropertyNoValueSnak( 3 ) ) );
181
182			$references = new ReferenceList( array( $reference1, $reference2 ) );
183			$references->addReference( $reference3 );
184
185			$this->assertCount( 3, $references );
186
187			$expectedList = new ReferenceList( array( $reference1, $reference2, $reference3 ) );
188			$this->assertSameReferenceOrder( $expectedList, $references );
189			}
190
191			public function testAddReferenceAtIndexZero() {
192			$reference1 = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
193			$reference2 = new Reference( array( new PropertyNoValueSnak( 2 ) ) );
194			$reference3 = new Reference( array( new PropertyNoValueSnak( 3 ) ) );
195
196			$references = new ReferenceList( array( $reference1, $reference2 ) );
197			$references->addReference( $reference3, 0 );
198
199			$expectedList = new ReferenceList( array( $reference3, $reference1, $reference2 ) );
200			$this->assertSameReferenceOrder( $expectedList, $references );
201			}
202
203			public function testAddReferenceAtNegativeIndex() {
204			$reference = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
205			$referenceList = new ReferenceList();
206
207			$this->setExpectedException( 'InvalidArgumentException' );
			0 ignored issues – show Deprecated Code introduced 2016-02-07 08:37 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...
208			$referenceList->addReference( $reference, -1 );
209			}
210
211			public function testGivenEmptyReference_addReferenceDoesNotAdd() {
212			$reference1 = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
213			$reference2 = new Reference( array( new PropertyNoValueSnak( 2 ) ) );
214			$emptyReference = new Reference( array() );
215
216			$references = new ReferenceList( array( $reference1, $reference2 ) );
217			$references->addReference( $emptyReference );
218
219			$expectedList = new ReferenceList( array( $reference1, $reference2 ) );
220			$this->assertSameReferenceOrder( $expectedList, $references );
221			}
222
223			public function testGivenEmptyReferenceAndIndex_addReferenceDoesNotAdd() {
224			$reference1 = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
225			$reference2 = new Reference( array( new PropertyNoValueSnak( 2 ) ) );
226			$emptyReference = new Reference( array() );
227
228			$references = new ReferenceList( array( $reference1, $reference2 ) );
229			$references->addReference( $emptyReference, 0 );
230
231			$expectedList = new ReferenceList( array( $reference1, $reference2 ) );
232			$this->assertSameReferenceOrder( $expectedList, $references );
233			}
234
235			/**
236			* @dataProvider instanceProvider
237			*/
238			public function testIndexOf( ReferenceList $array ) {
239			$this->assertFalse( $array->indexOf( new Reference() ) );
240
241			$i = 0;
242			foreach ( $array as $reference ) {
243			$this->assertEquals( $i++, $array->indexOf( $reference ) );
244			}
245			}
246
247			public function testIndexOf_checksForIdentity() {
248			$reference1 = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
249			$reference2 = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
250			$referenceList = new ReferenceList( array( $reference1 ) );
251
252			$this->assertNotSame( $reference1, $reference2, 'post condition' );
253			$this->assertTrue( $reference1->equals( $reference2 ), 'post condition' );
254			$this->assertSame( 0, $referenceList->indexOf( $reference1 ), 'identity' );
255			$this->assertFalse( $referenceList->indexOf( $reference2 ), 'not equality' );
256			}
257
258			/**
259			* @dataProvider instanceProvider
260			*/
261			public function testEquals( ReferenceList $array ) {
262			$this->assertTrue( $array->equals( $array ) );
263			$this->assertFalse( $array->equals( 42 ) );
264			}
265
266			/**
267			* @dataProvider instanceProvider
268			*/
269			public function testGetValueHashReturnsString( ReferenceList $array ) {
270			$this->assertInternalType( 'string', $array->getValueHash() );
271			}
272
273			/**
274			* @dataProvider instanceProvider
275			*/
276			public function testGetValueHashIsTheSameForClone( ReferenceList $array ) {
277			$copy = unserialize( serialize( $array ) );
278			$this->assertEquals( $array->getValueHash(), $copy->getValueHash() );
279			}
280
281			/**
282			* @dataProvider instanceProvider
283			*/
284			public function testHasReferenceHash( ReferenceList $references ) {
285			$this->assertFalse( $references->hasReferenceHash( '~=[,,_,,]:3' ) );
286
287			/**
288			* @var Hashable $reference
289			*/
290			foreach ( $references as $reference ) {
291			$this->assertTrue( $references->hasReferenceHash( $reference->getHash() ) );
292			}
293			}
294
295			/**
296			* @dataProvider instanceProvider
297			*/
298			public function testGetReference( ReferenceList $references ) {
299			$this->assertNull( $references->getReference( '~=[,,_,,]:3' ) );
300
301			/**
302			* @var Reference $reference
303			*/
304			foreach ( $references as $reference ) {
305			$this->assertTrue( $reference->equals( $references->getReference( $reference->getHash() ) ) );
306			}
307			}
308
309			/**
310			* @dataProvider instanceProvider
311			*/
312			public function testRemoveReferenceHash( ReferenceList $references ) {
313			$references->removeReferenceHash( '~=[,,_,,]:3' );
314
315			$hashes = array();
316
317			/**
318			* @var Reference $reference
319			*/
320			foreach ( $references as $reference ) {
321			$hashes[] = $reference->getHash();
322			}
323
324			foreach ( $hashes as $hash ) {
325			$references->removeReferenceHash( $hash );
326			}
327
328			$this->assertEquals( 0, count( $references ) );
329			}
330
331			public function testRemoveReferenceHashRemovesIdenticalObjects() {
332			$reference = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
333			$references = new ReferenceList( array( $reference, $reference ) );
334
335			$references->removeReferenceHash( $reference->getHash() );
336
337			$this->assertTrue( $references->isEmpty() );
338			}
339
340			public function testRemoveReferenceHashRemovesCopies() {
341			$reference = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
342			$references = new ReferenceList( array( $reference, clone $reference ) );
343
344			$references->removeReferenceHash( $reference->getHash() );
345
346			$this->assertTrue( $references->isEmpty() );
347			}
348
349			public function testRemoveReferenceHashUpdatesIndexes() {
350			$reference1 = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
351			$reference2 = new Reference( array( new PropertyNoValueSnak( 2 ) ) );
352			$references = new ReferenceList( array( $reference1, $reference2 ) );
353
354			$references->removeReferenceHash( $reference1->getHash() );
355
356			$this->assertSame( 0, $references->indexOf( $reference2 ) );
357			}
358
359			public function testGivenOneSnak_addNewReferenceAddsSnak() {
360			$references = new ReferenceList();
361			$snak = new PropertyNoValueSnak( 1 );
362
363			$references->addNewReference( $snak );
364			$this->assertTrue( $references->hasReference( new Reference( array( $snak ) ) ) );
365			}
366
367			public function testGivenMultipleSnaks_addNewReferenceAddsThem() {
368			$references = new ReferenceList();
369			$snak1 = new PropertyNoValueSnak( 1 );
370			$snak2 = new PropertyNoValueSnak( 3 );
371			$snak3 = new PropertyNoValueSnak( 2 );
372
373			$references->addNewReference( $snak1, $snak2, $snak3 );
374
375			$expectedSnaks = array( $snak1, $snak2, $snak3 );
376			$this->assertTrue( $references->hasReference( new Reference( $expectedSnaks ) ) );
377			}
378
379			public function testGivenAnArrayOfSnaks_addNewReferenceAddsThem() {
380			$references = new ReferenceList();
381			$snaks = array(
382			new PropertyNoValueSnak( 1 ),
383			new PropertyNoValueSnak( 3 ),
384			new PropertyNoValueSnak( 2 )
385			);
386
387			$references->addNewReference( $snaks );
388			$this->assertTrue( $references->hasReference( new Reference( $snaks ) ) );
389			}
390
391			public function testGivenNoneSnak_addNewReferenceThrowsException() {
392			$references = new ReferenceList();
393
394			$this->setExpectedException( 'InvalidArgumentException' );
			0 ignored issues – show Deprecated Code introduced 2016-02-18 16:34 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...
395			$references->addNewReference( new PropertyNoValueSnak( 1 ), null );
396			}
397
398			public function testSerializationStability() {
399			$references = new ReferenceList();
400			$this->assertSame( 'a:0:{}', $references->serialize() );
401			}
402
403			public function testSerializeRoundtrip() {
404			$references = new ReferenceList();
405
406			$references->addReference( new Reference() );
407
408			$references->addReference( new Reference( array(
409			new PropertyNoValueSnak( 2 ),
410			new PropertyNoValueSnak( 3 ),
411			) ) );
412
413			$serialized = serialize( $references );
414			$this->assertTrue( $references->equals( unserialize( $serialized ) ) );
415			}
416
417			public function testGivenEmptyList_isEmpty() {
418			$references = new ReferenceList();
419			$this->assertTrue( $references->isEmpty() );
420			}
421
422			public function testGivenNonEmptyList_isNotEmpty() {
423			$references = new ReferenceList();
424			$references->addNewReference( new PropertyNoValueSnak( 1 ) );
425
426			$this->assertFalse( $references->isEmpty() );
427			}
428
429			}
430

wmde / WikibaseDataModel

Push — refHashBehavior ( 70e111...ce2ac7 )

ReferenceListTest::testSerializationStability() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like