StatementTest::validConstructorArgumentsProvider() - Code Metrics - Inspection of "Add Int32EntityId" - wmde/WikibaseDataModel - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — int32EntityId ( fa80fb )

by no

created 2016-05-20 14:35 UTC

StatementTest::validConstructorArgumentsProvider() A

↳ Parent: StatementTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	11
Code Lines	8

Duplication

Lines	0
Ratio	0 %

Metric	Value
dl	0
loc	11
rs	9.4285
cc	1
eloc	8
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
 * @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( 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 testStatementClaimWithDifferentQualifiers_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 testStatementClaimWithDifferentReferences_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			* @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( array( $snak ) );
54			$references = new ReferenceList( array( new Reference( array( $snak ) ) ) );
55
56			return array(
57			array( $snak, null, null, null ),
58			array( $snak, null, null, 'guid' ),
59			array( $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( array(
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 array(
142			array( false ),
143			array( 1 ),
144			array( $snak ),
145			array( new Statement( $snak ) ),
146			);
147			}
148
149			public function instanceProvider() {
150			$instances = array();
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( array(
169			new Reference( array(
170			new PropertyValueSnak( new PropertyId( 'P1' ), new StringValue( 'a' ) )
171			) )
172			) ) );
173
174			$instances[] = $instance;
175
176			$argLists = array();
177
178			foreach ( $instances as $instance ) {
179			$argLists[] = array( $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( array(
197			new Reference( array(
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 = array( $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 = array(
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 = array( 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' );
			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...
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( array(
297			new PropertyNoValueSnak( 1337 ),
298			) ),
299			new ReferenceList( array(
300			new Reference( array( 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( array(
324			new PropertyNoValueSnak( 1337 ),
325			) )
326			);
327
328			$differentStatement = new Statement(
329			new PropertyNoValueSnak( 42 ),
330			new SnakList( array(
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( array(
352			new Reference( array( new PropertyNoValueSnak( 1337 ) ) ),
353			) )
354			);
355
356			$differentStatement = new Statement(
357			new PropertyNoValueSnak( 42 ),
358			new SnakList(),
359			new ReferenceList( array(
360			new Reference( array( 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 array(
397			array( $statement, $statementWithoutQualifiers, 'qualifiers not equal' ),
398			array( $statement, $statementWithoutReferences, 'references not equal' ),
399			array( $statement, $statementWithPreferredRank, 'rank not equal' ),
400			array( $statement, $statementMainSnakNotEqual, 'main snak not equal' )
401			);
402			}
403
404			private function newStatement() {
405			$qualifiers = new SnakList( array( new PropertyNoValueSnak( 23 ) ) );
406
407			$statement = new Statement(
408			new PropertyNoValueSnak( 42 ),
409			$qualifiers,
410			new ReferenceList( array(
411			new Reference( array( new PropertyNoValueSnak( 1337 ) ) ),
412			) )
413			);
414
415			$statement->setRank( Statement::RANK_NORMAL );
416
417			return $statement;
418			}
419
420			}
421

wmde / WikibaseDataModel

Push — int32EntityId ( fa80fb )

StatementTest::validConstructorArgumentsProvider() A

Complexity

Size

Duplication

Duplication Side-by-Side

Filter issues like