StatementTest::testStatementWithDifferentQualifiers_equalsReturnsFalse() - Code Metrics - Inspection of "Remove all deprecated class aliases (#657)" - wmde/WikibaseDataModel - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 92ad77...5a1e08 )

by Jeroen De

created 2017-01-05 21:39 UTC

testStatementWithDifferentQualifiers_equalsReturnsFalse() A

↳ Parent: StatementTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	17
Code Lines	10

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
c	0
b	0
f	0
dl	0
loc	17
rs	9.4285
cc	1
eloc	10
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\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( Statement::RANK_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( 'Wikibase\DataModel\ReferenceList', $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 ) {
		$rank = $statement->getRank();
		$this->assertInternalType( 'integer', $rank );

		$ranks = [ Statement::RANK_DEPRECATED, Statement::RANK_NORMAL, Statement::RANK_PREFERRED ];
		$this->assertTrue( in_array( $rank, $ranks ), true );
	}

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

	/**
	 * @dataProvider instanceProvider
	 */
	public function testSetInvalidRank( Statement $statement ) {
		$this->setExpectedException( 'InvalidArgumentException' );
		$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( Statement::RANK_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( Statement::RANK_NORMAL );

		return $statement;
	}

}


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

wmde / WikibaseDataModel

Push — master ( 92ad77...5a1e08 )

testStatementWithDifferentQualifiers_equalsReturnsFalse() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like