PropertyTest::getNewEmpty() - Code Metrics - Inspection of "Refactor EntityTest" - wmde/WikibaseDataModel - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#630)

by Bene

created 2016-03-08 09:56 UTC

PropertyTest::getNewEmpty() A

↳ Parent: PropertyTest::testConstructorWithAllParameters()

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Metric	Value
dl	0
loc	3
rs	10
cc	1
eloc	2
nc	1
nop	0

<?php

namespace Wikibase\DataModel\Tests\Entity;

use InvalidArgumentException;
use Wikibase\DataModel\Entity\Property;
use Wikibase\DataModel\Entity\PropertyId;
use Wikibase\DataModel\Snak\PropertyNoValueSnak;
use Wikibase\DataModel\Snak\PropertySomeValueSnak;
use Wikibase\DataModel\Statement\Statement;
use Wikibase\DataModel\Statement\StatementList;
use Wikibase\DataModel\Term\AliasGroup;
use Wikibase\DataModel\Term\AliasGroupList;
use Wikibase\DataModel\Term\Fingerprint;
use Wikibase\DataModel\Term\Term;
use Wikibase\DataModel\Term\TermList;

/**
 * @covers Wikibase\DataModel\Entity\Property
 *
 * @group Wikibase
 * @group WikibaseProperty
 * @group WikibaseDataModel
 * @group PropertyTest
 *
 * @licence GNU GPL v2+
 * @author Jeroen De Dauw < [email protected] >
 * @author Bene* < [email protected] >
 */
class PropertyTest extends \PHPUnit_Framework_TestCase {

	public function testConstructorWithAllParameters() {
		$property = new Property(
			new PropertyId( 'P42' ),
			new Fingerprint(),
			'string',
			new StatementList()
		);
		$this->assertInstanceOf( 'Wikibase\DataModel\Entity\Property', $property );
		$this->assertEquals( new PropertyId( 'P42' ), $property->getId() );
		$this->assertEquals( new Fingerprint(), $property->getFingerprint() );
		$this->assertEquals( 'string', $property->getDataTypeId() );
		$this->assertEquals( new StatementList(), $property->getStatements() );
	}

	public function testConstructorWithMinimalParameters() {
		$property = new Property( null, null, '' );
		$this->assertInstanceOf( 'Wikibase\DataModel\Entity\Property', $property );
		$this->assertNull( $property->getId() );
		$this->assertEquals( new Fingerprint(), $property->getFingerprint() );
		$this->assertEquals( '', $property->getDataTypeId() );
		$this->assertEquals( new StatementList(), $property->getStatements() );
	}

	/**
	 * @expectedException InvalidArgumentException
	 */
	public function testGivenInvalidType_ConstructorThrowsException() {
		new Property( null, null, null );
	}

	public function testNewFromType() {
		$property = Property::newFromType( 'string' );
		$this->assertInstanceOf( 'Wikibase\DataModel\Entity\Property', $property );
		$this->assertEquals( 'string', $property->getDataTypeId() );
	}

	public function testSetAndGetDataTypeId() {
		$property = Property::newFromType( 'string' );

		foreach ( array( 'string', 'foobar', 'nyan', 'string' ) as $typeId ) {
			$property->setDataTypeId( $typeId );
			$this->assertEquals( $typeId, $property->getDataTypeId() );
		}
	}

	public function testWhenIdSetWithNumber_GetIdReturnsPropertyId() {
		$property = Property::newFromType( 'string' );
		$property->setId( 42 );

		$this->assertHasCorrectIdType( $property );
	}

	protected function assertHasCorrectIdType( Property $property ) {
		$this->assertInstanceOf( 'Wikibase\DataModel\Entity\PropertyId', $property->getId() );
	}

	public function testWhenIdSetWithPropertyId_GetIdReturnsPropertyId() {
		$property = Property::newFromType( 'string' );
		$property->setId( new PropertyId( 'P42' ) );

		$this->assertHasCorrectIdType( $property );
	}

	public function testGetFingerprint_emptyFingerprint() {
		$property = Property::newFromType( 'string' );

		$this->assertEquals(
			new Fingerprint(),
			$property->getFingerprint()
		);
	}

	public function testGetFingerprint_termsAreSet() {
		$property = Property::newFromType( 'string' );

		$property->setLabel( 'en', 'foo' );
		$property->setDescription( 'en', 'foo bar' );
		$property->setAliases( 'en', array( 'foo', 'bar' ) );

		$this->assertEquals(
			new Fingerprint(
				new TermList( array(
					new Term( 'en', 'foo' ),
				) ),
				new TermList( array(
					new Term( 'en', 'foo bar' )
				) ),
				new AliasGroupList( array(
					new AliasGroup( 'en', array( 'foo', 'bar' ) )
				) )
			),
			$property->getFingerprint()
		);
	}

	public function testSetFingerprint_getFingerprintReturnsIt() {
		$property = Property::newFromType( 'string' );
		$fingerprint = new Fingerprint();

		$property->setFingerprint( $fingerprint );
		$this->assertSame( $fingerprint, $property->getFingerprint() );
	}

	public function testPropertyWithTypeIsEmpty() {
		$this->assertTrue( Property::newFromType( 'string' )->isEmpty() );
	}

	public function testPropertyWithIdIsEmpty() {
		$property = Property::newFromType( 'string' );
		$property->setId( 1337 );
		$this->assertTrue( $property->isEmpty() );
	}

	public function testPropertyWithFingerprintIsNotEmpty() {
		$property = Property::newFromType( 'string' );
		$property->getFingerprint()->setAliasGroup( 'en', array( 'foo' ) );
		$this->assertFalse( $property->isEmpty() );
	}

	public function testClearRemovesAllButId() {
		$property = Property::newFromType( 'string' );
		$property->setId( 42 );
		$property->getFingerprint()->setLabel( 'en', 'foo' );
		$property->getStatements()->addNewStatement( new PropertyNoValueSnak( 1 ) );

		$property->clear();

		$this->assertEquals( new PropertyId( 'P42' ), $property->getId() );
		$this->assertTrue( $property->isEmpty() );
	}

	public function testGetStatementsReturnsEmptyListForEmptyProperty() {
		$property = Property::newFromType( 'string' );

		$this->assertEquals( new StatementList(), $property->getStatements() );
	}

	public function testSetAndGetStatements() {
		$property = Property::newFromType( 'string' );

		$statementList = $this->newNonEmptyStatementList();
		$property->setStatements( $statementList );

		$this->assertEquals( $statementList, $property->getStatements() );
	}

	private function newNonEmptyStatementList() {
		$statementList = new StatementList();
		$statementList->addNewStatement( new PropertyNoValueSnak( 42 ) );
		$statementList->addNewStatement( new PropertyNoValueSnak( 1337 ) );

		return $statementList;
	}

	public function equalsProvider() {
		$firstProperty = Property::newFromType( 'string' );
		$firstProperty->setStatements( $this->newNonEmptyStatementList() );

		$secondProperty = Property::newFromType( 'string' );
		$secondProperty->setStatements( $this->newNonEmptyStatementList() );

		$secondPropertyWithId = $secondProperty->copy();
		$secondPropertyWithId->setId( 42 );

		$differentId = $secondPropertyWithId->copy();
		$differentId->setId( 43 );

		return array(
			array( Property::newFromType( 'string' ), Property::newFromType( 'string' ) ),
			array( $firstProperty, $secondProperty ),
			array( $secondProperty, $secondPropertyWithId ),
			array( $secondPropertyWithId, $differentId ),
		);
	}

	/**
	 * @dataProvider equalsProvider
	 */
	public function testEquals( Property $firstProperty, Property $secondProperty ) {
		$this->assertTrue( $firstProperty->equals( $secondProperty ) );
		$this->assertTrue( $secondProperty->equals( $firstProperty ) );
	}

	private function getBaseProperty() {
		$property = Property::newFromType( 'string' );

		$property->setId( 42 );
		$property->getFingerprint()->setLabel( 'en', 'Same' );
		$property->getFingerprint()->setDescription( 'en', 'Same' );
		$property->getFingerprint()->setAliasGroup( 'en', array( 'Same' ) );
		$property->setStatements( $this->newNonEmptyStatementList() );

		return $property;
	}

	public function notEqualsProvider() {
		$differentLabel = $this->getBaseProperty();
		$differentLabel->getFingerprint()->setLabel( 'en', 'Different' );

		$differentDescription = $this->getBaseProperty();
		$differentDescription->getFingerprint()->setDescription( 'en', 'Different' );

		$differentAlias = $this->getBaseProperty();
		$differentAlias->getFingerprint()->setAliasGroup( 'en', array( 'Different' ) );

		$differentStatement = $this->getBaseProperty();
		$differentStatement->setStatements( new StatementList() );

		$property = $this->getBaseProperty();

		return array(
			'empty' => array( $property, Property::newFromType( 'string' ) ),
			'label' => array( $property, $differentLabel ),
			'description' => array( $property, $differentDescription ),
			'alias' => array( $property, $differentAlias ),
			'dataType' => array( Property::newFromType( 'string' ), Property::newFromType( 'foo' ) ),
			'statement' => array( $property, $differentStatement ),
		);
	}

	/**
	 * @dataProvider notEqualsProvider
	 */
	public function testNotEquals( Property $firstProperty, Property $secondProperty ) {
		$this->assertFalse( $firstProperty->equals( $secondProperty ) );
		$this->assertFalse( $secondProperty->equals( $firstProperty ) );
	}

	public function testPropertyWithStatementsIsNotEmpty() {
		$property = Property::newFromType( 'string' );
		$property->setStatements( $this->newNonEmptyStatementList() );

		$this->assertFalse( $property->isEmpty() );
	}

	public function cloneProvider() {
		$property = new Property( new PropertyId( 'P1' ), null, 'string' );
		$property->setLabel( 'en', 'original' );
		$property->getStatements()->addNewStatement( new PropertyNoValueSnak( 1 ) );

		return array(
			'copy' => array( $property, $property->copy() ),
			'native clone' => array( $property, clone $property ),
		);
	}

	/**
	 * @dataProvider cloneProvider
	 */
	public function testCloneIsEqualButNotIdentical( Property $original, Property $clone ) {
		$this->assertNotSame( $original, $clone );
		$this->assertTrue( $original->equals( $clone ) );
		$this->assertSame(
			$original->getId(),
			$clone->getId(),
			'id is immutable and must not be cloned'
		);

		// The clone must not reference the same mutable objects
		$this->assertNotSame( $original->getFingerprint(), $clone->getFingerprint() );
		$this->assertNotSame( $original->getStatements(), $clone->getStatements() );
		$this->assertNotSame(
			$original->getStatements()->getFirstStatementWithGuid( null ),
			$clone->getStatements()->getFirstStatementWithGuid( null )
		);
	}

	/**
	 * @dataProvider cloneProvider
	 */
	public function testOriginalDoesNotChangeWithClone( Property $original, Property $clone ) {
		$originalStatement = $original->getStatements()->getFirstStatementWithGuid( null );
		$clonedStatement = $clone->getStatements()->getFirstStatementWithGuid( null );

		$clone->setLabel( 'en', 'clone' );
		$clone->setDescription( 'en', 'clone' );
		$clone->setAliases( 'en', array( 'clone' ) );
		$clonedStatement->setGuid( 'clone' );
		$clonedStatement->setMainSnak( new PropertySomeValueSnak( 666 ) );
		$clonedStatement->setRank( Statement::RANK_DEPRECATED );
		$clonedStatement->getQualifiers()->addSnak( new PropertyNoValueSnak( 1 ) );
		$clonedStatement->getReferences()->addNewReference( new PropertyNoValueSnak( 1 ) );

		$this->assertSame( 'original', $original->getFingerprint()->getLabel( 'en' )->getText() );
		$this->assertFalse( $original->getFingerprint()->hasDescription( 'en' ) );
		$this->assertFalse( $original->getFingerprint()->hasAliasGroup( 'en' ) );
		$this->assertNull( $originalStatement->getGuid() );
		$this->assertSame( 'novalue', $originalStatement->getMainSnak()->getType() );
		$this->assertSame( Statement::RANK_NORMAL, $originalStatement->getRank() );
		$this->assertTrue( $originalStatement->getQualifiers()->isEmpty() );
		$this->assertTrue( $originalStatement->getReferences()->isEmpty() );
	}

}


1			<?php
2
3			namespace Wikibase\DataModel\Tests\Entity;
4
5			use InvalidArgumentException;
6			use Wikibase\DataModel\Entity\Property;
7			use Wikibase\DataModel\Entity\PropertyId;
8			use Wikibase\DataModel\Snak\PropertyNoValueSnak;
9			use Wikibase\DataModel\Snak\PropertySomeValueSnak;
10			use Wikibase\DataModel\Statement\Statement;
11			use Wikibase\DataModel\Statement\StatementList;
12			use Wikibase\DataModel\Term\AliasGroup;
13			use Wikibase\DataModel\Term\AliasGroupList;
14			use Wikibase\DataModel\Term\Fingerprint;
15			use Wikibase\DataModel\Term\Term;
16			use Wikibase\DataModel\Term\TermList;
17
18			/**
19			* @covers Wikibase\DataModel\Entity\Property
20			*
21			* @group Wikibase
22			* @group WikibaseProperty
23			* @group WikibaseDataModel
24			* @group PropertyTest
25			*
26			* @licence GNU GPL v2+
27			* @author Jeroen De Dauw < [email protected] >
28			* @author Bene* < [email protected] >
29			*/
30			class PropertyTest extends \PHPUnit_Framework_TestCase {
31
32			public function testConstructorWithAllParameters() {
33			$property = new Property(
34			new PropertyId( 'P42' ),
35			new Fingerprint(),
36			'string',
37			new StatementList()
38			);
39			$this->assertInstanceOf( 'Wikibase\DataModel\Entity\Property', $property );
40			$this->assertEquals( new PropertyId( 'P42' ), $property->getId() );
41			$this->assertEquals( new Fingerprint(), $property->getFingerprint() );
42			$this->assertEquals( 'string', $property->getDataTypeId() );
43			$this->assertEquals( new StatementList(), $property->getStatements() );
44			}
45
46			public function testConstructorWithMinimalParameters() {
47			$property = new Property( null, null, '' );
48			$this->assertInstanceOf( 'Wikibase\DataModel\Entity\Property', $property );
49			$this->assertNull( $property->getId() );
50			$this->assertEquals( new Fingerprint(), $property->getFingerprint() );
51			$this->assertEquals( '', $property->getDataTypeId() );
52			$this->assertEquals( new StatementList(), $property->getStatements() );
53			}
54
55			/**
56			* @expectedException InvalidArgumentException
57			*/
58			public function testGivenInvalidType_ConstructorThrowsException() {
59			new Property( null, null, null );
60			}
61
62			public function testNewFromType() {
63			$property = Property::newFromType( 'string' );
64			$this->assertInstanceOf( 'Wikibase\DataModel\Entity\Property', $property );
65			$this->assertEquals( 'string', $property->getDataTypeId() );
66			}
67
68			public function testSetAndGetDataTypeId() {
69			$property = Property::newFromType( 'string' );
70
71			foreach ( array( 'string', 'foobar', 'nyan', 'string' ) as $typeId ) {
72			$property->setDataTypeId( $typeId );
73			$this->assertEquals( $typeId, $property->getDataTypeId() );
74			}
75			}
76
77			public function testWhenIdSetWithNumber_GetIdReturnsPropertyId() {
78			$property = Property::newFromType( 'string' );
79			$property->setId( 42 );
80
81			$this->assertHasCorrectIdType( $property );
82			}
83
84			protected function assertHasCorrectIdType( Property $property ) {
85			$this->assertInstanceOf( 'Wikibase\DataModel\Entity\PropertyId', $property->getId() );
86			}
87
88			public function testWhenIdSetWithPropertyId_GetIdReturnsPropertyId() {
89			$property = Property::newFromType( 'string' );
90			$property->setId( new PropertyId( 'P42' ) );
91
92			$this->assertHasCorrectIdType( $property );
93			}
94
95			public function testGetFingerprint_emptyFingerprint() {
96			$property = Property::newFromType( 'string' );
97
98			$this->assertEquals(
99			new Fingerprint(),
100			$property->getFingerprint()
101			);
102			}
103
104			public function testGetFingerprint_termsAreSet() {
105			$property = Property::newFromType( 'string' );
106
107			$property->setLabel( 'en', 'foo' );
108			$property->setDescription( 'en', 'foo bar' );
109			$property->setAliases( 'en', array( 'foo', 'bar' ) );
110
111			$this->assertEquals(
112			new Fingerprint(
113			new TermList( array(
114			new Term( 'en', 'foo' ),
115			) ),
116			new TermList( array(
117			new Term( 'en', 'foo bar' )
118			) ),
119			new AliasGroupList( array(
120			new AliasGroup( 'en', array( 'foo', 'bar' ) )
121			) )
122			),
123			$property->getFingerprint()
124			);
125			}
126
127			public function testSetFingerprint_getFingerprintReturnsIt() {
128			$property = Property::newFromType( 'string' );
129			$fingerprint = new Fingerprint();
130
131			$property->setFingerprint( $fingerprint );
132			$this->assertSame( $fingerprint, $property->getFingerprint() );
133			}
134
135			public function testPropertyWithTypeIsEmpty() {
136			$this->assertTrue( Property::newFromType( 'string' )->isEmpty() );
137			}
138
139			public function testPropertyWithIdIsEmpty() {
140			$property = Property::newFromType( 'string' );
141			$property->setId( 1337 );
142			$this->assertTrue( $property->isEmpty() );
143			}
144
145			public function testPropertyWithFingerprintIsNotEmpty() {
146			$property = Property::newFromType( 'string' );
147			$property->getFingerprint()->setAliasGroup( 'en', array( 'foo' ) );
148			$this->assertFalse( $property->isEmpty() );
149			}
150
151			public function testClearRemovesAllButId() {
152			$property = Property::newFromType( 'string' );
153			$property->setId( 42 );
154			$property->getFingerprint()->setLabel( 'en', 'foo' );
155			$property->getStatements()->addNewStatement( new PropertyNoValueSnak( 1 ) );
156
157			$property->clear();
158
159			$this->assertEquals( new PropertyId( 'P42' ), $property->getId() );
160			$this->assertTrue( $property->isEmpty() );
161			}
162
163			public function testGetStatementsReturnsEmptyListForEmptyProperty() {
164			$property = Property::newFromType( 'string' );
165
166			$this->assertEquals( new StatementList(), $property->getStatements() );
167			}
168
169			public function testSetAndGetStatements() {
170			$property = Property::newFromType( 'string' );
171
172			$statementList = $this->newNonEmptyStatementList();
173			$property->setStatements( $statementList );
174
175			$this->assertEquals( $statementList, $property->getStatements() );
176			}
177
178			private function newNonEmptyStatementList() {
179			$statementList = new StatementList();
180			$statementList->addNewStatement( new PropertyNoValueSnak( 42 ) );
181			$statementList->addNewStatement( new PropertyNoValueSnak( 1337 ) );
182
183			return $statementList;
184			}
185
186			public function equalsProvider() {
187			$firstProperty = Property::newFromType( 'string' );
188			$firstProperty->setStatements( $this->newNonEmptyStatementList() );
189
190			$secondProperty = Property::newFromType( 'string' );
191			$secondProperty->setStatements( $this->newNonEmptyStatementList() );
192
193			$secondPropertyWithId = $secondProperty->copy();
194			$secondPropertyWithId->setId( 42 );
195
196			$differentId = $secondPropertyWithId->copy();
197			$differentId->setId( 43 );
198
199			return array(
200			array( Property::newFromType( 'string' ), Property::newFromType( 'string' ) ),
201			array( $firstProperty, $secondProperty ),
202			array( $secondProperty, $secondPropertyWithId ),
203			array( $secondPropertyWithId, $differentId ),
204			);
205			}
206
207			/**
208			* @dataProvider equalsProvider
209			*/
210			public function testEquals( Property $firstProperty, Property $secondProperty ) {
211			$this->assertTrue( $firstProperty->equals( $secondProperty ) );
212			$this->assertTrue( $secondProperty->equals( $firstProperty ) );
213			}
214
215			private function getBaseProperty() {
216			$property = Property::newFromType( 'string' );
217
218			$property->setId( 42 );
219			$property->getFingerprint()->setLabel( 'en', 'Same' );
220			$property->getFingerprint()->setDescription( 'en', 'Same' );
221			$property->getFingerprint()->setAliasGroup( 'en', array( 'Same' ) );
222			$property->setStatements( $this->newNonEmptyStatementList() );
223
224			return $property;
225			}
226
227			public function notEqualsProvider() {
228			$differentLabel = $this->getBaseProperty();
229			$differentLabel->getFingerprint()->setLabel( 'en', 'Different' );
230
231			$differentDescription = $this->getBaseProperty();
232			$differentDescription->getFingerprint()->setDescription( 'en', 'Different' );
233
234			$differentAlias = $this->getBaseProperty();
235			$differentAlias->getFingerprint()->setAliasGroup( 'en', array( 'Different' ) );
236
237			$differentStatement = $this->getBaseProperty();
238			$differentStatement->setStatements( new StatementList() );
239
240			$property = $this->getBaseProperty();
241
242			return array(
243			'empty' => array( $property, Property::newFromType( 'string' ) ),
244			'label' => array( $property, $differentLabel ),
245			'description' => array( $property, $differentDescription ),
246			'alias' => array( $property, $differentAlias ),
247			'dataType' => array( Property::newFromType( 'string' ), Property::newFromType( 'foo' ) ),
248			'statement' => array( $property, $differentStatement ),
249			);
250			}
251
252			/**
253			* @dataProvider notEqualsProvider
254			*/
255			public function testNotEquals( Property $firstProperty, Property $secondProperty ) {
256			$this->assertFalse( $firstProperty->equals( $secondProperty ) );
257			$this->assertFalse( $secondProperty->equals( $firstProperty ) );
258			}
259
260			public function testPropertyWithStatementsIsNotEmpty() {
261			$property = Property::newFromType( 'string' );
262			$property->setStatements( $this->newNonEmptyStatementList() );
263
264			$this->assertFalse( $property->isEmpty() );
265			}
266
267			public function cloneProvider() {
268			$property = new Property( new PropertyId( 'P1' ), null, 'string' );
269			$property->setLabel( 'en', 'original' );
270			$property->getStatements()->addNewStatement( new PropertyNoValueSnak( 1 ) );
271
272			return array(
273			'copy' => array( $property, $property->copy() ),
274			'native clone' => array( $property, clone $property ),
275			);
276			}
277
278			/**
279			* @dataProvider cloneProvider
280			*/
281			public function testCloneIsEqualButNotIdentical( Property $original, Property $clone ) {
282			$this->assertNotSame( $original, $clone );
283			$this->assertTrue( $original->equals( $clone ) );
284			$this->assertSame(
285			$original->getId(),
286			$clone->getId(),
287			'id is immutable and must not be cloned'
288			);
289
290			// The clone must not reference the same mutable objects
291			$this->assertNotSame( $original->getFingerprint(), $clone->getFingerprint() );
292			$this->assertNotSame( $original->getStatements(), $clone->getStatements() );
293			$this->assertNotSame(
294			$original->getStatements()->getFirstStatementWithGuid( null ),
295			$clone->getStatements()->getFirstStatementWithGuid( null )
296			);
297			}
298
299			/**
300			* @dataProvider cloneProvider
301			*/
302			public function testOriginalDoesNotChangeWithClone( Property $original, Property $clone ) {
303			$originalStatement = $original->getStatements()->getFirstStatementWithGuid( null );
304			$clonedStatement = $clone->getStatements()->getFirstStatementWithGuid( null );
305
306			$clone->setLabel( 'en', 'clone' );
307			$clone->setDescription( 'en', 'clone' );
308			$clone->setAliases( 'en', array( 'clone' ) );
309			$clonedStatement->setGuid( 'clone' );
310			$clonedStatement->setMainSnak( new PropertySomeValueSnak( 666 ) );
311			$clonedStatement->setRank( Statement::RANK_DEPRECATED );
312			$clonedStatement->getQualifiers()->addSnak( new PropertyNoValueSnak( 1 ) );
313			$clonedStatement->getReferences()->addNewReference( new PropertyNoValueSnak( 1 ) );
314
315			$this->assertSame( 'original', $original->getFingerprint()->getLabel( 'en' )->getText() );
316			$this->assertFalse( $original->getFingerprint()->hasDescription( 'en' ) );
317			$this->assertFalse( $original->getFingerprint()->hasAliasGroup( 'en' ) );
318			$this->assertNull( $originalStatement->getGuid() );
319			$this->assertSame( 'novalue', $originalStatement->getMainSnak()->getType() );
320			$this->assertSame( Statement::RANK_NORMAL, $originalStatement->getRank() );
321			$this->assertTrue( $originalStatement->getQualifiers()->isEmpty() );
322			$this->assertTrue( $originalStatement->getReferences()->isEmpty() );
323			}
324
325			}
326

wmde / WikibaseDataModel

Pull Request — master (#630)

PropertyTest::getNewEmpty() A

Complexity

Size

Duplication

Duplication Side-by-Side

Filter issues like