StatementTest::testHashesOfEqualStatementsAreTheSame() - Code Metrics - Inspection of "Add a StatementRank class" - wmde/WikibaseDataModel - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — rankClass ( 1b9cf4...7f76c7 )

by no

created 2018-09-17 13:59 UTC

testHashesOfEqualStatementsAreTheSame() A

↳ Parent: StatementTest

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	6
rs	10
c	0
b	0
f	0
cc	1
nc	1
nop	0

<?php

namespace Wikibase\DataModel\Tests\Statement;

use DataValues\StringValue;
use InvalidArgumentException;
use Wikibase\DataModel\Entity\PropertyId;
use Wikibase\DataModel\Reference;
use Wikibase\DataModel\ReferenceList;
use Wikibase\DataModel\Snak\PropertyNoValueSnak;
use Wikibase\DataModel\Snak\PropertySomeValueSnak;
use Wikibase\DataModel\Snak\PropertyValueSnak;
use Wikibase\DataModel\Snak\Snak;
use Wikibase\DataModel\Snak\SnakList;
use Wikibase\DataModel\Statement\StatementRank;
use Wikibase\DataModel\Statement\Statement;

/**
 * @covers \Wikibase\DataModel\Statement\Statement
 *
 * @group Wikibase
 * @group WikibaseDataModel
 *
 * @license GPL-2.0+
 * @author Jeroen De Dauw < [email protected] >
 */
class StatementTest extends \PHPUnit_Framework_TestCase {

	public function testMinimalConstructor() {
		$mainSnak = new PropertyNoValueSnak( 1 );
		$statement = new Statement( $mainSnak );
		$this->assertTrue( $mainSnak->equals( $statement->getMainSnak() ) );
	}

	/**
	 * @dataProvider validConstructorArgumentsProvider
	 */
	public function testConstructorWithValidArguments(
		Snak $mainSnak,
		SnakList $qualifiers = null,
		ReferenceList $references = null,
		$guid
	) {
		$statement = new Statement( $mainSnak, $qualifiers, $references, $guid );
		$this->assertTrue( $statement->getMainSnak()->equals( $mainSnak ) );
		$this->assertTrue( $statement->getQualifiers()->equals( $qualifiers ?: new SnakList() ) );
		$this->assertTrue( $statement->getReferences()->equals( $references ?: new ReferenceList() ) );
		$this->assertSame( $guid, $statement->getGuid() );
	}

	public function validConstructorArgumentsProvider() {
		$snak = new PropertyNoValueSnak( 1 );
		$qualifiers = new SnakList( [ $snak ] );
		$references = new ReferenceList( [ new Reference( [ $snak ] ) ] );

		return [
			[ $snak, null, null, null ],
			[ $snak, null, null, 'guid' ],
			[ $snak, $qualifiers, $references, 'guid' ],
		];
	}

	/**
	 * @dataProvider instanceProvider
	 */
	public function testSetGuid( Statement $statement ) {
		$statement->setGuid( 'foo-bar-baz' );
		$this->assertEquals( 'foo-bar-baz', $statement->getGuid() );
	}

	/**
	 * @dataProvider instanceProvider
	 */
	public function testGetGuid( Statement $statement ) {
		$guid = $statement->getGuid();
		$this->assertTrue( $guid === null || is_string( $guid ) );
		$this->assertEquals( $guid, $statement->getGuid() );

		$statement->setGuid( 'foobar' );
		$this->assertEquals( 'foobar', $statement->getGuid() );
	}

	public function testSetAndGetMainSnak() {
		$mainSnak = new PropertyNoValueSnak( new PropertyId( 'P42' ) );
		$statement = new Statement( $mainSnak );
		$this->assertSame( $mainSnak, $statement->getMainSnak() );
	}

	public function testSetAndGetQualifiers() {
		$qualifiers = new SnakList( [
			new PropertyValueSnak( new PropertyId( 'P42' ), new StringValue( 'a' ) )
		] );

		$statement = new Statement(
			new PropertyNoValueSnak( new PropertyId( 'P42' ) ),
			$qualifiers
		);

		$this->assertSame( $qualifiers, $statement->getQualifiers() );
	}

	/**
	 * @dataProvider instanceProvider
	 */
	public function testSerialize( Statement $statement ) {
		$copy = unserialize( serialize( $statement ) );

		$this->assertEquals( $statement->getHash(), $copy->getHash(), 'Serialization roundtrip should not affect hash' );
	}

	public function testGuidDoesNotAffectHash() {
		$statement0 = new Statement( new PropertyNoValueSnak( 42 ) );
		$statement0->setGuid( 'statement0' );

		$statement1 = new Statement( new PropertyNoValueSnak( 42 ) );
		$statement1->setGuid( 'statement1' );

		$this->assertEquals( $statement0->getHash(), $statement1->getHash() );
	}

	/**
	 * @dataProvider invalidGuidProvider
	 * @expectedException InvalidArgumentException
	 */
	public function testGivenInvalidGuid_constructorThrowsException( $guid ) {
		new Statement( new PropertyNoValueSnak( 1 ), null, null, $guid );
	}

	/**
	 * @dataProvider invalidGuidProvider
	 * @expectedException InvalidArgumentException
	 */
	public function testGivenInvalidGuid_setGuidThrowsException( $guid ) {
		$statement = new Statement( new PropertyNoValueSnak( 42 ) );
		$statement->setGuid( $guid );
	}

	public function invalidGuidProvider() {
		$snak = new PropertyNoValueSnak( 1 );

		return [
			[ false ],
			[ 1 ],
			[ $snak ],
			[ new Statement( $snak ) ],
		];
	}

	public function instanceProvider() {
		$instances = [];

		$propertyId = new PropertyId( 'P42' );
		$baseInstance = new Statement( new PropertyNoValueSnak( $propertyId ) );

		$instances[] = $baseInstance;

		$instance = clone $baseInstance;
		$instance->setRank( StatementRank::PREFERRED );

		$instances[] = $instance;

		$newInstance = clone $instance;

		$instances[] = $newInstance;

		$instance = clone $baseInstance;

		$instance->setReferences( new ReferenceList( [
			new Reference( [
				new PropertyValueSnak( new PropertyId( 'P1' ), new StringValue( 'a' ) )
			] )
		] ) );

		$instances[] = $instance;

		$argLists = [];

		foreach ( $instances as $instance ) {
			$argLists[] = [ $instance ];
		}

		return $argLists;
	}

	/**
	 * @dataProvider instanceProvider
	 */
	public function testGetReferences( Statement $statement ) {
		$this->assertInstanceOf( ReferenceList::class, $statement->getReferences() );
	}

	/**
	 * @dataProvider instanceProvider
	 */
	public function testSetReferences( Statement $statement ) {
		$references = new ReferenceList( [
			new Reference( [
				new PropertyValueSnak( new PropertyId( 'P1' ), new StringValue( 'a' ) ),
			] )
		] );

		$statement->setReferences( $references );

		$this->assertEquals( $references, $statement->getReferences() );
	}

	/**
	 * @dataProvider instanceProvider
	 */
	public function testAddNewReferenceWithVariableArgumentsSyntax( Statement $statement ) {
		$snak1 = new PropertyNoValueSnak( 256 );
		$snak2 = new PropertySomeValueSnak( 42 );
		$statement->addNewReference( $snak1, $snak2 );

		$expectedSnaks = [ $snak1, $snak2 ];
		$this->assertTrue( $statement->getReferences()->hasReference( new Reference( $expectedSnaks ) ) );
	}

	/**
	 * @dataProvider instanceProvider
	 */
	public function testAddNewReferenceWithAnArrayOfSnaks( Statement $statement ) {
		$snaks = [
			new PropertyNoValueSnak( 256 ),
			new PropertySomeValueSnak( 42 ),
		];
		$statement->addNewReference( $snaks );

		$this->assertTrue( $statement->getReferences()->hasReference( new Reference( $snaks ) ) );
	}

	/**
	 * @dataProvider instanceProvider
	 */
	public function testGetRank( Statement $statement ) {
		$this->assertTrue( StatementRank::isValid( $statement->getRank() ) );
	}

	/**
	 * @dataProvider instanceProvider
	 */
	public function testSetRank( Statement $statement ) {
		$statement->setRank( StatementRank::DEPRECATED );
		$this->assertEquals( StatementRank::DEPRECATED, $statement->getRank() );
	}

	/**
	 * @dataProvider instanceProvider
	 */
	public function testSetInvalidRank( Statement $statement ) {
		$this->expectException( InvalidArgumentException::class );
		$statement->setRank( 9001 );
	}

	/**
	 * @dataProvider instanceProvider
	 */
	public function testGetPropertyId( Statement $statement ) {
		$this->assertEquals(
			$statement->getMainSnak()->getPropertyId(),
			$statement->getPropertyId()
		);
	}

	/**
	 * @dataProvider instanceProvider
	 */
	public function testGetAllSnaks( Statement $statement ) {
		$snaks = $statement->getAllSnaks();

		$c = count( $statement->getQualifiers() ) + 1;

		/* @var Reference $reference */
		foreach ( $statement->getReferences() as $reference ) {
			$c += count( $reference->getSnaks() );
		}

		$this->assertGreaterThanOrEqual( $c, count( $snaks ), 'At least one snak per Qualifier and Reference' );
	}

	public function testGivenNonStatement_equalsReturnsFalse() {
		$statement = new Statement( new PropertyNoValueSnak( 42 ) );

		$this->assertFalse( $statement->equals( null ) );
		$this->assertFalse( $statement->equals( 42 ) );
		$this->assertFalse( $statement->equals( new \stdClass() ) );
	}

	public function testGivenSameStatement_equalsReturnsTrue() {
		$statement = new Statement(
			new PropertyNoValueSnak( 42 ),
			new SnakList( [
				new PropertyNoValueSnak( 1337 ),
			] ),
			new ReferenceList( [
				new Reference( [ new PropertyNoValueSnak( 1337 ) ] ),
			] )
		);

		$statement->setGuid( 'kittens' );

		$this->assertTrue( $statement->equals( $statement ) );
		$this->assertTrue( $statement->equals( clone $statement ) );
	}

	public function testGivenStatementWithDifferentProperty_equalsReturnsFalse() {
		$statement = new Statement( new PropertyNoValueSnak( 42 ) );
		$this->assertFalse( $statement->equals( new Statement( new PropertyNoValueSnak( 43 ) ) ) );
	}

	public function testGivenStatementWithDifferentSnakType_equalsReturnsFalse() {
		$statement = new Statement( new PropertyNoValueSnak( 42 ) );
		$this->assertFalse( $statement->equals( new Statement( new PropertySomeValueSnak( 42 ) ) ) );
	}

	public function testStatementWithDifferentQualifiers_equalsReturnsFalse() {
		$statement = new Statement(
			new PropertyNoValueSnak( 42 ),
			new SnakList( [
				new PropertyNoValueSnak( 1337 ),
			] )
		);

		$differentStatement = new Statement(
			new PropertyNoValueSnak( 42 ),
			new SnakList( [
				new PropertyNoValueSnak( 32202 ),
			] )
		);

		$this->assertFalse( $statement->equals( $differentStatement ) );
	}

	public function testGivenStatementWithDifferentGuids_equalsReturnsFalse() {
		$statement = new Statement( new PropertyNoValueSnak( 42 ) );

		$differentStatement = new Statement( new PropertyNoValueSnak( 42 ) );
		$differentStatement->setGuid( 'kittens' );

		$this->assertFalse( $statement->equals( $differentStatement ) );
	}

	public function testStatementWithDifferentReferences_equalsReturnsFalse() {
		$statement = new Statement(
			new PropertyNoValueSnak( 42 ),
			new SnakList(),
			new ReferenceList( [
				new Reference( [ new PropertyNoValueSnak( 1337 ) ] ),
			] )
		);

		$differentStatement = new Statement(
			new PropertyNoValueSnak( 42 ),
			new SnakList(),
			new ReferenceList( [
				new Reference( [ new PropertyNoValueSnak( 32202 ) ] ),
			] )
		);

		$this->assertFalse( $statement->equals( $differentStatement ) );
	}

	public function testEquals() {
		$statement = $this->newStatement();
		$target = $this->newStatement();

		$this->assertTrue( $statement->equals( $target ) );
	}

	/**
	 * @dataProvider notEqualsProvider
	 */
	public function testNotEquals( Statement $statement, Statement $target, $message ) {
		$this->assertFalse( $statement->equals( $target ), $message );
	}

	public function notEqualsProvider() {
		$statement = $this->newStatement();

		$statementWithoutQualifiers = $this->newStatement();
		$statementWithoutQualifiers->setQualifiers( new SnakList() );

		$statementWithoutReferences = $this->newStatement();
		$statementWithoutReferences->setReferences( new ReferenceList() );

		$statementWithPreferredRank = $this->newStatement();
		$statementWithPreferredRank->setRank( StatementRank::PREFERRED );

		$statementMainSnakNotEqual = $this->newStatement();
		$statementMainSnakNotEqual->setMainSnak( new PropertyNoValueSnak( 9000 ) );

		return [
			[ $statement, $statementWithoutQualifiers, 'qualifiers not equal' ],
			[ $statement, $statementWithoutReferences, 'references not equal' ],
			[ $statement, $statementWithPreferredRank, 'rank not equal' ],
			[ $statement, $statementMainSnakNotEqual, 'main snak not equal' ]
		];
	}

	private function newStatement() {
		$qualifiers = new SnakList( [ new PropertyNoValueSnak( 23 ) ] );

		$statement = new Statement(
			new PropertyNoValueSnak( 42 ),
			$qualifiers,
			new ReferenceList( [
				new Reference( [ new PropertyNoValueSnak( 1337 ) ] ),
			] )
		);

		$statement->setRank( StatementRank::NORMAL );

		return $statement;
	}

	public function testHashesOfDifferentStatementsAreNotTheSame() {
		$this->assertNotSame(
			( new Statement( new PropertyNoValueSnak( 1 ) ) )->getHash(),
			( new Statement( new PropertyNoValueSnak( 2 ) ) )->getHash()
		);
	}

	public function testHashesOfEqualStatementsAreTheSame() {
		$this->assertSame(
			( new Statement( new PropertyNoValueSnak( 1 ) ) )->getHash(),
			( new Statement( new PropertyNoValueSnak( 1 ) ) )->getHash()
		);
	}

}


1			<?php
2
3			namespace Wikibase\DataModel\Tests\Statement;
4
5			use DataValues\StringValue;
6			use InvalidArgumentException;
7			use Wikibase\DataModel\Entity\PropertyId;
8			use Wikibase\DataModel\Reference;
9			use Wikibase\DataModel\ReferenceList;
10			use Wikibase\DataModel\Snak\PropertyNoValueSnak;
11			use Wikibase\DataModel\Snak\PropertySomeValueSnak;
12			use Wikibase\DataModel\Snak\PropertyValueSnak;
13			use Wikibase\DataModel\Snak\Snak;
14			use Wikibase\DataModel\Snak\SnakList;
15			use Wikibase\DataModel\Statement\StatementRank;
16			use Wikibase\DataModel\Statement\Statement;
17
18			/**
19			* @covers \Wikibase\DataModel\Statement\Statement
20			*
21			* @group Wikibase
22			* @group WikibaseDataModel
23			*
24			* @license GPL-2.0+
25			* @author Jeroen De Dauw < [email protected] >
26			*/
27			class StatementTest extends \PHPUnit_Framework_TestCase {
28
29			public function testMinimalConstructor() {
30			$mainSnak = new PropertyNoValueSnak( 1 );
31			$statement = new Statement( $mainSnak );
32			$this->assertTrue( $mainSnak->equals( $statement->getMainSnak() ) );
33			}
34
35			/**
36			* @dataProvider validConstructorArgumentsProvider
37			*/
38			public function testConstructorWithValidArguments(
39			Snak $mainSnak,
40			SnakList $qualifiers = null,
41			ReferenceList $references = null,
42			$guid
43			) {
44			$statement = new Statement( $mainSnak, $qualifiers, $references, $guid );
45			$this->assertTrue( $statement->getMainSnak()->equals( $mainSnak ) );
46			$this->assertTrue( $statement->getQualifiers()->equals( $qualifiers ?: new SnakList() ) );
47			$this->assertTrue( $statement->getReferences()->equals( $references ?: new ReferenceList() ) );
48			$this->assertSame( $guid, $statement->getGuid() );
49			}
50
51			public function validConstructorArgumentsProvider() {
52			$snak = new PropertyNoValueSnak( 1 );
53			$qualifiers = new SnakList( [ $snak ] );
54			$references = new ReferenceList( [ new Reference( [ $snak ] ) ] );
55
56			return [
57			[ $snak, null, null, null ],
58			[ $snak, null, null, 'guid' ],
59			[ $snak, $qualifiers, $references, 'guid' ],
60			];
61			}
62
63			/**
64			* @dataProvider instanceProvider
65			*/
66			public function testSetGuid( Statement $statement ) {
67			$statement->setGuid( 'foo-bar-baz' );
68			$this->assertEquals( 'foo-bar-baz', $statement->getGuid() );
69			}
70
71			/**
72			* @dataProvider instanceProvider
73			*/
74			public function testGetGuid( Statement $statement ) {
75			$guid = $statement->getGuid();
76			$this->assertTrue( $guid === null \|\| is_string( $guid ) );
77			$this->assertEquals( $guid, $statement->getGuid() );
78
79			$statement->setGuid( 'foobar' );
80			$this->assertEquals( 'foobar', $statement->getGuid() );
81			}
82
83			public function testSetAndGetMainSnak() {
84			$mainSnak = new PropertyNoValueSnak( new PropertyId( 'P42' ) );
85			$statement = new Statement( $mainSnak );
86			$this->assertSame( $mainSnak, $statement->getMainSnak() );
87			}
88
89			public function testSetAndGetQualifiers() {
90			$qualifiers = new SnakList( [
91			new PropertyValueSnak( new PropertyId( 'P42' ), new StringValue( 'a' ) )
92			] );
93
94			$statement = new Statement(
95			new PropertyNoValueSnak( new PropertyId( 'P42' ) ),
96			$qualifiers
97			);
98
99			$this->assertSame( $qualifiers, $statement->getQualifiers() );
100			}
101
102			/**
103			* @dataProvider instanceProvider
104			*/
105			public function testSerialize( Statement $statement ) {
106			$copy = unserialize( serialize( $statement ) );
107
108			$this->assertEquals( $statement->getHash(), $copy->getHash(), 'Serialization roundtrip should not affect hash' );
109			}
110
111			public function testGuidDoesNotAffectHash() {
112			$statement0 = new Statement( new PropertyNoValueSnak( 42 ) );
113			$statement0->setGuid( 'statement0' );
114
115			$statement1 = new Statement( new PropertyNoValueSnak( 42 ) );
116			$statement1->setGuid( 'statement1' );
117
118			$this->assertEquals( $statement0->getHash(), $statement1->getHash() );
119			}
120
121			/**
122			* @dataProvider invalidGuidProvider
123			* @expectedException InvalidArgumentException
124			*/
125			public function testGivenInvalidGuid_constructorThrowsException( $guid ) {
126			new Statement( new PropertyNoValueSnak( 1 ), null, null, $guid );
127			}
128
129			/**
130			* @dataProvider invalidGuidProvider
131			* @expectedException InvalidArgumentException
132			*/
133			public function testGivenInvalidGuid_setGuidThrowsException( $guid ) {
134			$statement = new Statement( new PropertyNoValueSnak( 42 ) );
135			$statement->setGuid( $guid );
136			}
137
138			public function invalidGuidProvider() {
139			$snak = new PropertyNoValueSnak( 1 );
140
141			return [
142			[ false ],
143			[ 1 ],
144			[ $snak ],
145			[ new Statement( $snak ) ],
146			];
147			}
148
149			public function instanceProvider() {
150			$instances = [];
151
152			$propertyId = new PropertyId( 'P42' );
153			$baseInstance = new Statement( new PropertyNoValueSnak( $propertyId ) );
154
155			$instances[] = $baseInstance;
156
157			$instance = clone $baseInstance;
158			$instance->setRank( StatementRank::PREFERRED );
159
160			$instances[] = $instance;
161
162			$newInstance = clone $instance;
163
164			$instances[] = $newInstance;
165
166			$instance = clone $baseInstance;
167
168			$instance->setReferences( new ReferenceList( [
169			new Reference( [
170			new PropertyValueSnak( new PropertyId( 'P1' ), new StringValue( 'a' ) )
171			] )
172			] ) );
173
174			$instances[] = $instance;
175
176			$argLists = [];
177
178			foreach ( $instances as $instance ) {
179			$argLists[] = [ $instance ];
180			}
181
182			return $argLists;
183			}
184
185			/**
186			* @dataProvider instanceProvider
187			*/
188			public function testGetReferences( Statement $statement ) {
189			$this->assertInstanceOf( ReferenceList::class, $statement->getReferences() );
190			}
191
192			/**
193			* @dataProvider instanceProvider
194			*/
195			public function testSetReferences( Statement $statement ) {
196			$references = new ReferenceList( [
197			new Reference( [
198			new PropertyValueSnak( new PropertyId( 'P1' ), new StringValue( 'a' ) ),
199			] )
200			] );
201
202			$statement->setReferences( $references );
203
204			$this->assertEquals( $references, $statement->getReferences() );
205			}
206
207			/**
208			* @dataProvider instanceProvider
209			*/
210			public function testAddNewReferenceWithVariableArgumentsSyntax( Statement $statement ) {
211			$snak1 = new PropertyNoValueSnak( 256 );
212			$snak2 = new PropertySomeValueSnak( 42 );
213			$statement->addNewReference( $snak1, $snak2 );
214
215			$expectedSnaks = [ $snak1, $snak2 ];
216			$this->assertTrue( $statement->getReferences()->hasReference( new Reference( $expectedSnaks ) ) );
217			}
218
219			/**
220			* @dataProvider instanceProvider
221			*/
222			public function testAddNewReferenceWithAnArrayOfSnaks( Statement $statement ) {
223			$snaks = [
224			new PropertyNoValueSnak( 256 ),
225			new PropertySomeValueSnak( 42 ),
226			];
227			$statement->addNewReference( $snaks );
228
229			$this->assertTrue( $statement->getReferences()->hasReference( new Reference( $snaks ) ) );
230			}
231
232			/**
233			* @dataProvider instanceProvider
234			*/
235			public function testGetRank( Statement $statement ) {
236			$this->assertTrue( StatementRank::isValid( $statement->getRank() ) );
237			}
238
239			/**
240			* @dataProvider instanceProvider
241			*/
242			public function testSetRank( Statement $statement ) {
243			$statement->setRank( StatementRank::DEPRECATED );
244			$this->assertEquals( StatementRank::DEPRECATED, $statement->getRank() );
245			}
246
247			/**
248			* @dataProvider instanceProvider
249			*/
250			public function testSetInvalidRank( Statement $statement ) {
251			$this->expectException( InvalidArgumentException::class );
252			$statement->setRank( 9001 );
253			}
254
255			/**
256			* @dataProvider instanceProvider
257			*/
258			public function testGetPropertyId( Statement $statement ) {
259			$this->assertEquals(
260			$statement->getMainSnak()->getPropertyId(),
261			$statement->getPropertyId()
262			);
263			}
264
265			/**
266			* @dataProvider instanceProvider
267			*/
268			public function testGetAllSnaks( Statement $statement ) {
269			$snaks = $statement->getAllSnaks();
270
271			$c = count( $statement->getQualifiers() ) + 1;
272
273			/* @var Reference $reference */
274			foreach ( $statement->getReferences() as $reference ) {
275			$c += count( $reference->getSnaks() );
276			}
277
278			$this->assertGreaterThanOrEqual( $c, count( $snaks ), 'At least one snak per Qualifier and Reference' );
279			}
280
281			public function testGivenNonStatement_equalsReturnsFalse() {
282			$statement = new Statement( new PropertyNoValueSnak( 42 ) );
283
284			$this->assertFalse( $statement->equals( null ) );
285			$this->assertFalse( $statement->equals( 42 ) );
286			$this->assertFalse( $statement->equals( new \stdClass() ) );
287			}
288
289			public function testGivenSameStatement_equalsReturnsTrue() {
290			$statement = new Statement(
291			new PropertyNoValueSnak( 42 ),
292			new SnakList( [
293			new PropertyNoValueSnak( 1337 ),
294			] ),
295			new ReferenceList( [
296			new Reference( [ new PropertyNoValueSnak( 1337 ) ] ),
297			] )
298			);
299
300			$statement->setGuid( 'kittens' );
301
302			$this->assertTrue( $statement->equals( $statement ) );
303			$this->assertTrue( $statement->equals( clone $statement ) );
304			}
305
306			public function testGivenStatementWithDifferentProperty_equalsReturnsFalse() {
307			$statement = new Statement( new PropertyNoValueSnak( 42 ) );
308			$this->assertFalse( $statement->equals( new Statement( new PropertyNoValueSnak( 43 ) ) ) );
309			}
310
311			public function testGivenStatementWithDifferentSnakType_equalsReturnsFalse() {
312			$statement = new Statement( new PropertyNoValueSnak( 42 ) );
313			$this->assertFalse( $statement->equals( new Statement( new PropertySomeValueSnak( 42 ) ) ) );
314			}
315
316			public function testStatementWithDifferentQualifiers_equalsReturnsFalse() {
317			$statement = new Statement(
318			new PropertyNoValueSnak( 42 ),
319			new SnakList( [
320			new PropertyNoValueSnak( 1337 ),
321			] )
322			);
323
324			$differentStatement = new Statement(
325			new PropertyNoValueSnak( 42 ),
326			new SnakList( [
327			new PropertyNoValueSnak( 32202 ),
328			] )
329			);
330
331			$this->assertFalse( $statement->equals( $differentStatement ) );
332			}
333
334			public function testGivenStatementWithDifferentGuids_equalsReturnsFalse() {
335			$statement = new Statement( new PropertyNoValueSnak( 42 ) );
336
337			$differentStatement = new Statement( new PropertyNoValueSnak( 42 ) );
338			$differentStatement->setGuid( 'kittens' );
339
340			$this->assertFalse( $statement->equals( $differentStatement ) );
341			}
342
343			public function testStatementWithDifferentReferences_equalsReturnsFalse() {
344			$statement = new Statement(
345			new PropertyNoValueSnak( 42 ),
346			new SnakList(),
347			new ReferenceList( [
348			new Reference( [ new PropertyNoValueSnak( 1337 ) ] ),
349			] )
350			);
351
352			$differentStatement = new Statement(
353			new PropertyNoValueSnak( 42 ),
354			new SnakList(),
355			new ReferenceList( [
356			new Reference( [ new PropertyNoValueSnak( 32202 ) ] ),
357			] )
358			);
359
360			$this->assertFalse( $statement->equals( $differentStatement ) );
361			}
362
363			public function testEquals() {
364			$statement = $this->newStatement();
365			$target = $this->newStatement();
366
367			$this->assertTrue( $statement->equals( $target ) );
368			}
369
370			/**
371			* @dataProvider notEqualsProvider
372			*/
373			public function testNotEquals( Statement $statement, Statement $target, $message ) {
374			$this->assertFalse( $statement->equals( $target ), $message );
375			}
376
377			public function notEqualsProvider() {
378			$statement = $this->newStatement();
379
380			$statementWithoutQualifiers = $this->newStatement();
381			$statementWithoutQualifiers->setQualifiers( new SnakList() );
382
383			$statementWithoutReferences = $this->newStatement();
384			$statementWithoutReferences->setReferences( new ReferenceList() );
385
386			$statementWithPreferredRank = $this->newStatement();
387			$statementWithPreferredRank->setRank( StatementRank::PREFERRED );
388
389			$statementMainSnakNotEqual = $this->newStatement();
390			$statementMainSnakNotEqual->setMainSnak( new PropertyNoValueSnak( 9000 ) );
391
392			return [
393			[ $statement, $statementWithoutQualifiers, 'qualifiers not equal' ],
394			[ $statement, $statementWithoutReferences, 'references not equal' ],
395			[ $statement, $statementWithPreferredRank, 'rank not equal' ],
396			[ $statement, $statementMainSnakNotEqual, 'main snak not equal' ]
397			];
398			}
399
400			private function newStatement() {
401			$qualifiers = new SnakList( [ new PropertyNoValueSnak( 23 ) ] );
402
403			$statement = new Statement(
404			new PropertyNoValueSnak( 42 ),
405			$qualifiers,
406			new ReferenceList( [
407			new Reference( [ new PropertyNoValueSnak( 1337 ) ] ),
408			] )
409			);
410
411			$statement->setRank( StatementRank::NORMAL );
412
413			return $statement;
414			}
415
416			public function testHashesOfDifferentStatementsAreNotTheSame() {
417			$this->assertNotSame(
418			( new Statement( new PropertyNoValueSnak( 1 ) ) )->getHash(),
419			( new Statement( new PropertyNoValueSnak( 2 ) ) )->getHash()
420			);
421			}
422
423			public function testHashesOfEqualStatementsAreTheSame() {
424			$this->assertSame(
425			( new Statement( new PropertyNoValueSnak( 1 ) ) )->getHash(),
426			( new Statement( new PropertyNoValueSnak( 1 ) ) )->getHash()
427			);
428			}
429
430			}
431

wmde / WikibaseDataModel

Push — rankClass ( 1b9cf4...7f76c7 )

testHashesOfEqualStatementsAreTheSame() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like