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

Test Failed

Push — claimAliases ( 71499b )

by no

created 2016-03-10 15:57 UTC

testStatementWithDifferentQualifiers_equalsReturnsFalse() A

↳ Parent: StatementTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	17
Code Lines	10

Duplication

Lines	0
Ratio	0 %

Metric	Value
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
 *
 * @licence GNU GPL v2+
 * @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( array( $snak ) );
		$references = new ReferenceList( array( new Reference( array( $snak ) ) ) );

		return array(
			array( $snak, null, null, null ),
			array( $snak, null, null, 'guid' ),
			array( $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( array(
			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 array(
			array( false ),
			array( 1 ),
			array( $snak ),
			array( new Statement( $snak ) ),
		);
	}

	public function instanceProvider() {
		$instances = array();

		$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( array(
			new Reference( array(
				new PropertyValueSnak( new PropertyId( 'P1' ), new StringValue( 'a' ) )
			) )
		) ) );

		$instances[] = $instance;

		$argLists = array();

		foreach ( $instances as $instance ) {
			$argLists[] = array( $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( array(
			new Reference( array(
				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 = array( $snak1, $snak2 );
		$this->assertTrue( $statement->getReferences()->hasReference( new Reference( $expectedSnaks ) ) );
	}

	/**
	 * @dataProvider instanceProvider
	 */
	public function testAddNewReferenceWithAnArrayOfSnaks( Statement $statement ) {
		$snaks = array(
			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 = array( 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( array(
				new PropertyNoValueSnak( 1337 ),
			) ),
			new ReferenceList( array(
				new Reference( array( 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( array(
				new PropertyNoValueSnak( 1337 ),
			) )
		);

		$differentStatement = new Statement(
			new PropertyNoValueSnak( 42 ),
			new SnakList( array(
				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( array(
				new Reference( array( new PropertyNoValueSnak( 1337 ) ) ),
			) )
		);

		$differentStatement = new Statement(
			new PropertyNoValueSnak( 42 ),
			new SnakList(),
			new ReferenceList( array(
				new Reference( array( 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 array(
			array( $statement, $statementWithoutQualifiers, 'qualifiers not equal' ),
			array( $statement, $statementWithoutReferences, 'references not equal' ),
			array( $statement, $statementWithPreferredRank, 'rank not equal' ),
			array( $statement, $statementMainSnakNotEqual, 'main snak not equal' )
		);
	}

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

		$statement = new Statement(
			new PropertyNoValueSnak( 42 ),
			$qualifiers,
			new ReferenceList( array(
				new Reference( array( 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			* @licence GNU GPL v2+
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( array( $snak ) );
53			$references = new ReferenceList( array( new Reference( array( $snak ) ) ) );
54
55			return array(
56			array( $snak, null, null, null ),
57			array( $snak, null, null, 'guid' ),
58			array( $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( array(
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 array(
141			array( false ),
142			array( 1 ),
143			array( $snak ),
144			array( new Statement( $snak ) ),
145			);
146			}
147
148			public function instanceProvider() {
149			$instances = array();
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( array(
168			new Reference( array(
169			new PropertyValueSnak( new PropertyId( 'P1' ), new StringValue( 'a' ) )
170			) )
171			) ) );
172
173			$instances[] = $instance;
174
175			$argLists = array();
176
177			foreach ( $instances as $instance ) {
178			$argLists[] = array( $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( array(
196			new Reference( array(
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 = array( $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 = array(
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 = array( 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' );
			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...
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( array(
296			new PropertyNoValueSnak( 1337 ),
297			) ),
298			new ReferenceList( array(
299			new Reference( array( 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( array(
323			new PropertyNoValueSnak( 1337 ),
324			) )
325			);
326
327			$differentStatement = new Statement(
328			new PropertyNoValueSnak( 42 ),
329			new SnakList( array(
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( array(
351			new Reference( array( new PropertyNoValueSnak( 1337 ) ) ),
352			) )
353			);
354
355			$differentStatement = new Statement(
356			new PropertyNoValueSnak( 42 ),
357			new SnakList(),
358			new ReferenceList( array(
359			new Reference( array( 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 array(
396			array( $statement, $statementWithoutQualifiers, 'qualifiers not equal' ),
397			array( $statement, $statementWithoutReferences, 'references not equal' ),
398			array( $statement, $statementWithPreferredRank, 'rank not equal' ),
399			array( $statement, $statementMainSnakNotEqual, 'main snak not equal' )
400			);
401			}
402
403			private function newStatement() {
404			$qualifiers = new SnakList( array( new PropertyNoValueSnak( 23 ) ) );
405
406			$statement = new Statement(
407			new PropertyNoValueSnak( 42 ),
408			$qualifiers,
409			new ReferenceList( array(
410			new Reference( array( new PropertyNoValueSnak( 1337 ) ) ),
411			) )
412			);
413
414			$statement->setRank( Statement::RANK_NORMAL );
415
416			return $statement;
417			}
418
419			}
420

wmde / WikibaseDataModel

Push — claimAliases ( 71499b )

testStatementWithDifferentQualifiers_equalsReturnsFalse() A

Complexity

Size

Duplication

Duplication Side-by-Side

Filter issues like