StatementTest::testConstructorWithValidArguments() - Code Metrics - Inspection of "Added missing Statement::getHash tests" - wmde/WikibaseDataModel - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — add-hash-test ( f116cd )

by Jeroen De

created 2017-01-05 21:57 UTC

StatementTest::testConstructorWithValidArguments() A

↳ Parent: StatementTest

Complexity

Conditions	3
Paths	1

Size

Total Lines	12
Code Lines	10

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

<?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
 * @group WikibaseStatement
 *
 * @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 testStatementClaimWithDifferentQualifiers_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 testStatementClaimWithDifferentReferences_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;
	}

	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\Statement;
16
17			/**
18			* @covers Wikibase\DataModel\Statement\Statement
19			*
20			* @group Wikibase
21			* @group WikibaseDataModel
22			* @group WikibaseStatement
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( Statement::RANK_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( 'Wikibase\DataModel\ReferenceList', $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			$rank = $statement->getRank();
237			$this->assertInternalType( 'integer', $rank );
238
239			$ranks = [ Statement::RANK_DEPRECATED, Statement::RANK_NORMAL, Statement::RANK_PREFERRED ];
240			$this->assertTrue( in_array( $rank, $ranks ), true );
241			}
242
243			/**
244			* @dataProvider instanceProvider
245			*/
246			public function testSetRank( Statement $statement ) {
247			$statement->setRank( Statement::RANK_DEPRECATED );
248			$this->assertEquals( Statement::RANK_DEPRECATED, $statement->getRank() );
249			}
250
251			/**
252			* @dataProvider instanceProvider
253			*/
254			public function testSetInvalidRank( Statement $statement ) {
255			$this->setExpectedException( 'InvalidArgumentException' );
256			$statement->setRank( 9001 );
257			}
258
259			/**
260			* @dataProvider instanceProvider
261			*/
262			public function testGetPropertyId( Statement $statement ) {
263			$this->assertEquals(
264			$statement->getMainSnak()->getPropertyId(),
265			$statement->getPropertyId()
266			);
267			}
268
269			/**
270			* @dataProvider instanceProvider
271			*/
272			public function testGetAllSnaks( Statement $statement ) {
273			$snaks = $statement->getAllSnaks();
274
275			$c = count( $statement->getQualifiers() ) + 1;
276
277			/* @var Reference $reference */
278			foreach ( $statement->getReferences() as $reference ) {
279			$c += count( $reference->getSnaks() );
280			}
281
282			$this->assertGreaterThanOrEqual( $c, count( $snaks ), 'At least one snak per Qualifier and Reference' );
283			}
284
285			public function testGivenNonStatement_equalsReturnsFalse() {
286			$statement = new Statement( new PropertyNoValueSnak( 42 ) );
287
288			$this->assertFalse( $statement->equals( null ) );
289			$this->assertFalse( $statement->equals( 42 ) );
290			$this->assertFalse( $statement->equals( new \stdClass() ) );
291			}
292
293			public function testGivenSameStatement_equalsReturnsTrue() {
294			$statement = new Statement(
295			new PropertyNoValueSnak( 42 ),
296			new SnakList( [
297			new PropertyNoValueSnak( 1337 ),
298			] ),
299			new ReferenceList( [
300			new Reference( [ new PropertyNoValueSnak( 1337 ) ] ),
301			] )
302			);
303
304			$statement->setGuid( 'kittens' );
305
306			$this->assertTrue( $statement->equals( $statement ) );
307			$this->assertTrue( $statement->equals( clone $statement ) );
308			}
309
310			public function testGivenStatementWithDifferentProperty_equalsReturnsFalse() {
311			$statement = new Statement( new PropertyNoValueSnak( 42 ) );
312			$this->assertFalse( $statement->equals( new Statement( new PropertyNoValueSnak( 43 ) ) ) );
313			}
314
315			public function testGivenStatementWithDifferentSnakType_equalsReturnsFalse() {
316			$statement = new Statement( new PropertyNoValueSnak( 42 ) );
317			$this->assertFalse( $statement->equals( new Statement( new PropertySomeValueSnak( 42 ) ) ) );
318			}
319
320			public function testStatementClaimWithDifferentQualifiers_equalsReturnsFalse() {
321			$statement = new Statement(
322			new PropertyNoValueSnak( 42 ),
323			new SnakList( [
324			new PropertyNoValueSnak( 1337 ),
325			] )
326			);
327
328			$differentStatement = new Statement(
329			new PropertyNoValueSnak( 42 ),
330			new SnakList( [
331			new PropertyNoValueSnak( 32202 ),
332			] )
333			);
334
335			$this->assertFalse( $statement->equals( $differentStatement ) );
336			}
337
338			public function testGivenStatementWithDifferentGuids_equalsReturnsFalse() {
339			$statement = new Statement( new PropertyNoValueSnak( 42 ) );
340
341			$differentStatement = new Statement( new PropertyNoValueSnak( 42 ) );
342			$differentStatement->setGuid( 'kittens' );
343
344			$this->assertFalse( $statement->equals( $differentStatement ) );
345			}
346
347			public function testStatementClaimWithDifferentReferences_equalsReturnsFalse() {
348			$statement = new Statement(
349			new PropertyNoValueSnak( 42 ),
350			new SnakList(),
351			new ReferenceList( [
352			new Reference( [ new PropertyNoValueSnak( 1337 ) ] ),
353			] )
354			);
355
356			$differentStatement = new Statement(
357			new PropertyNoValueSnak( 42 ),
358			new SnakList(),
359			new ReferenceList( [
360			new Reference( [ new PropertyNoValueSnak( 32202 ) ] ),
361			] )
362			);
363
364			$this->assertFalse( $statement->equals( $differentStatement ) );
365			}
366
367			public function testEquals() {
368			$statement = $this->newStatement();
369			$target = $this->newStatement();
370
371			$this->assertTrue( $statement->equals( $target ) );
372			}
373
374			/**
375			* @dataProvider notEqualsProvider
376			*/
377			public function testNotEquals( Statement $statement, Statement $target, $message ) {
378			$this->assertFalse( $statement->equals( $target ), $message );
379			}
380
381			public function notEqualsProvider() {
382			$statement = $this->newStatement();
383
384			$statementWithoutQualifiers = $this->newStatement();
385			$statementWithoutQualifiers->setQualifiers( new SnakList() );
386
387			$statementWithoutReferences = $this->newStatement();
388			$statementWithoutReferences->setReferences( new ReferenceList() );
389
390			$statementWithPreferredRank = $this->newStatement();
391			$statementWithPreferredRank->setRank( Statement::RANK_PREFERRED );
392
393			$statementMainSnakNotEqual = $this->newStatement();
394			$statementMainSnakNotEqual->setMainSnak( new PropertyNoValueSnak( 9000 ) );
395
396			return [
397			[ $statement, $statementWithoutQualifiers, 'qualifiers not equal' ],
398			[ $statement, $statementWithoutReferences, 'references not equal' ],
399			[ $statement, $statementWithPreferredRank, 'rank not equal' ],
400			[ $statement, $statementMainSnakNotEqual, 'main snak not equal' ]
401			];
402			}
403
404			private function newStatement() {
405			$qualifiers = new SnakList( [ new PropertyNoValueSnak( 23 ) ] );
406
407			$statement = new Statement(
408			new PropertyNoValueSnak( 42 ),
409			$qualifiers,
410			new ReferenceList( [
411			new Reference( [ new PropertyNoValueSnak( 1337 ) ] ),
412			] )
413			);
414
415			$statement->setRank( Statement::RANK_NORMAL );
416
417			return $statement;
418			}
419
420			public function testHashesOfDifferentStatementsAreNotTheSame() {
421			$this->assertNotSame(
422			( new Statement( new PropertyNoValueSnak( 1 ) ) )->getHash(),
423			( new Statement( new PropertyNoValueSnak( 2 ) ) )->getHash()
424			);
425			}
426
427			public function testHashesOfEqualStatementsAreTheSame() {
428			$this->assertSame(
429			( new Statement( new PropertyNoValueSnak( 1 ) ) )->getHash(),
430			( new Statement( new PropertyNoValueSnak( 1 ) ) )->getHash()
431			);
432			}
433
434			}
435

wmde / WikibaseDataModel

Push — add-hash-test ( f116cd )

StatementTest::testConstructorWithValidArguments() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like