ReferenceListTest::testConstructorIgnoresCopies() - Code Metrics - Inspection of "ReferenceList should never contain any duplicates" - wmde/WikibaseDataModel - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Push — refDuplicates ( 2ea7b8 )

by no

created 2016-02-18 17:17 UTC

ReferenceListTest::testConstructorIgnoresCopies() A

↳ Parent: ReferenceListTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	5
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

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

<?php

namespace Wikibase\DataModel\Tests;

use Hashable;
use InvalidArgumentException;
use PHPUnit_Framework_TestCase;
use Wikibase\DataModel\Entity\PropertyId;
use Wikibase\DataModel\Reference;
use Wikibase\DataModel\ReferenceList;
use Wikibase\DataModel\Snak\PropertyNoValueSnak;
use Wikibase\DataModel\Snak\SnakList;

/**
 * @covers Wikibase\DataModel\ReferenceList
 *
 * @group Wikibase
 * @group WikibaseDataModel
 * @group WikibaseReference
 *
 * @licence GNU GPL v2+
 * @author Jeroen De Dauw < [email protected] >
 * @author Thiemo Mättig
 */
class ReferenceListTest extends PHPUnit_Framework_TestCase {

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

		foreach ( $this->getConstructorArg() as $arg ) {
			$instances[] = array( new ReferenceList( $arg ) );
		}

		return $instances;
	}

	public function getElementInstances() {
		return array(
			new Reference(),
			new Reference( array( new PropertyNoValueSnak( 2 ) ) ),
			new Reference( array( new PropertyNoValueSnak( 3 ) ) ),
		);
	}

	public function getConstructorArg() {
		return array(
			array(),
			$this->getElementInstances(),
		);
	}

	public function testCanConstructWithReferenceListObject() {
		$reference = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
		$original = new ReferenceList( array( $reference ) );
		$copy = new ReferenceList( $original );

		$this->assertSame( 1, $copy->count() );
		$this->assertNotNull( $copy->getReference( $reference->getHash() ) );
	}

	public function testConstructorIgnoresIdenticalObjects() {
		$reference = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
		$original = new ReferenceList( array( $reference, $reference ) );
		$this->assertCount( 1, $original );
	}

	public function testConstructorIgnoresCopies() {
		$reference = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
		$original = new ReferenceList( array( $reference, clone $reference ) );
		$this->assertCount( 1, $original );
	}

	/**
	 * @dataProvider invalidConstructorArgumentsProvider
	 * @expectedException InvalidArgumentException
	 */
	public function testGivenInvalidConstructorArguments_constructorThrowsException( $input ) {
		new ReferenceList( $input );
	}

	public function invalidConstructorArgumentsProvider() {
		$id1 = new PropertyId( 'P1' );

		return array(
			array( null ),
			array( false ),
			array( 1 ),
			array( 0.1 ),
			array( 'string' ),
			array( $id1 ),
			array( new PropertyNoValueSnak( $id1 ) ),
			array( new Reference() ),
			array( new SnakList( array( new PropertyNoValueSnak( $id1 ) ) ) ),
			array( array( new PropertyNoValueSnak( $id1 ) ) ),
			array( array( new ReferenceList() ) ),
			array( array( new SnakList() ) ),
		);
	}

	public function testGetIterator_isTraversable() {
		$references = new ReferenceList();
		$references->addNewReference( new PropertyNoValueSnak( 1 ) );
		$iterator = $references->getIterator();

		$this->assertInstanceOf( 'Traversable', $iterator );
		$this->assertCount( 1, $iterator );
		foreach ( $references as $reference ) {
			$this->assertInstanceOf( 'Wikibase\DataModel\Reference', $reference );
		}
	}

	/**
	 * @dataProvider instanceProvider
	 */
	public function testHasReferenceBeforeRemoveButNotAfter( ReferenceList $array ) {
		if ( $array->count() === 0 ) {
			$this->assertTrue( true );
			return;
		}

		/**
		 * @var Reference $hashable
		 */
		foreach ( iterator_to_array( $array ) as $hashable ) {
			$this->assertTrue( $array->hasReference( $hashable ) );
			$array->removeReference( $hashable );
			$this->assertFalse( $array->hasReference( $hashable ) );
		}
	}

	public function testGivenCloneOfReferenceInList_hasReferenceReturnsTrue() {
		$list = new ReferenceList();

		$reference = new Reference( array( new PropertyNoValueSnak( 42 ) ) );
		$sameReference = unserialize( serialize( $reference ) );

		$list->addReference( $reference );

		$this->assertTrue(
			$list->hasReference( $sameReference ),
			'hasReference should return true when a reference with the same value is present, even when its another instance'
		);
	}

	/**
	 * @dataProvider instanceProvider
	 */
	public function testRemoveReference( ReferenceList $array ) {
		$elementCount = count( $array );

		/**
		 * @var Reference $element
		 */
		foreach ( iterator_to_array( $array ) as $element ) {
			$this->assertTrue( $array->hasReference( $element ) );

			$array->removeReference( $element );

			$this->assertFalse( $array->hasReference( $element ) );
			$this->assertEquals( --$elementCount, count( $array ) );
		}

		$elements = $this->getElementInstances();
		$element = array_shift( $elements );

		$array->removeReference( $element );
/** @return stdClass|null */
function mayReturnNull() { }

function doesNotAcceptNull(stdClass $x) { }

// With potential error.
function withoutCheck() {
    $x = mayReturnNull();
    doesNotAcceptNull($x); // Potential error here.
}

// Safe - Alternative 1
function withCheck1() {
    $x = mayReturnNull();
    if ( ! $x instanceof stdClass) {
        throw new \LogicException('$x must be defined.');
    }
    doesNotAcceptNull($x);
}

// Safe - Alternative 2
function withCheck2() {
    $x = mayReturnNull();
    if ($x instanceof stdClass) {
        doesNotAcceptNull($x);
    }
}
		$array->removeReference( $element );
/** @return stdClass|null */
function mayReturnNull() { }

function doesNotAcceptNull(stdClass $x) { }

// With potential error.
function withoutCheck() {
    $x = mayReturnNull();
    doesNotAcceptNull($x); // Potential error here.
}

// Safe - Alternative 1
function withCheck1() {
    $x = mayReturnNull();
    if ( ! $x instanceof stdClass) {
        throw new \LogicException('$x must be defined.');
    }
    doesNotAcceptNull($x);
}

// Safe - Alternative 2
function withCheck2() {
    $x = mayReturnNull();
    if ($x instanceof stdClass) {
        doesNotAcceptNull($x);
    }
}

		$this->assertTrue( true );
	}

	public function testRemoveReferenceRemovesIdenticalObjects() {
		$reference = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
		$references = new ReferenceList( array( $reference, $reference ) );

		$references->removeReference( $reference );

		$this->assertTrue( $references->isEmpty() );
	}

	public function testRemoveReferenceDoesNotRemoveCopies() {
		$reference = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
		$references = new ReferenceList( array( $reference, clone $reference ) );

		$references->removeReference( $reference );

		$this->assertFalse( $references->isEmpty() );
		$this->assertTrue( $references->hasReference( $reference ) );
		$this->assertNotSame( $reference, $references->getReference( $reference->getHash() ) );
	}

	public function testAddReferenceOnEmptyList() {
		$reference = new Reference( array( new PropertyNoValueSnak( 1 ) ) );

		$references = new ReferenceList();
		$references->addReference( $reference );

		$this->assertCount( 1, $references );

		$expectedList = new ReferenceList( array( $reference ) );
		$this->assertSameReferenceOrder( $expectedList, $references );
	}

	private function assertSameReferenceOrder( ReferenceList $expectedList, ReferenceList $references ) {
		$this->assertEquals(
			iterator_to_array( $expectedList ),
			iterator_to_array( $references )
		);
	}

	public function testAddReferenceOnNonEmptyList() {
		$reference1 = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
		$reference2 = new Reference( array( new PropertyNoValueSnak( 2 ) ) );
		$reference3 = new Reference( array( new PropertyNoValueSnak( 3 ) ) );

		$references = new ReferenceList( array( $reference1, $reference2 ) );
		$references->addReference( $reference3 );

		$this->assertCount( 3, $references );

		$expectedList = new ReferenceList( array( $reference1, $reference2, $reference3 ) );
		$this->assertSameReferenceOrder( $expectedList, $references );
	}

	public function testAddReferenceAtIndexZero() {
		$reference1 = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
		$reference2 = new Reference( array( new PropertyNoValueSnak( 2 ) ) );
		$reference3 = new Reference( array( new PropertyNoValueSnak( 3 ) ) );

		$references = new ReferenceList( array( $reference1, $reference2 ) );
		$references->addReference( $reference3, 0 );

		$expectedList = new ReferenceList( array( $reference3, $reference1, $reference2 ) );
		$this->assertSameReferenceOrder( $expectedList, $references );
	}

	public function testAddReferenceAtNegativeIndex() {
		$reference = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
		$referenceList = new ReferenceList();

		$this->setExpectedException( 'InvalidArgumentException' );

		$referenceList->addReference( $reference, -1 );
	}

	public function testGivenEmptyReference_addReferenceDoesNotAdd() {
		$reference1 = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
		$reference2 = new Reference( array( new PropertyNoValueSnak( 2 ) ) );
		$emptyReference = new Reference( array() );

		$references = new ReferenceList( array( $reference1, $reference2 ) );
		$references->addReference( $emptyReference );

		$expectedList = new ReferenceList( array( $reference1, $reference2 ) );
		$this->assertSameReferenceOrder( $expectedList, $references );
	}

	public function testGivenEmptyReferenceAndIndex_addReferenceDoesNotAdd() {
		$reference1 = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
		$reference2 = new Reference( array( new PropertyNoValueSnak( 2 ) ) );
		$emptyReference = new Reference( array() );

		$references = new ReferenceList( array( $reference1, $reference2 ) );
		$references->addReference( $emptyReference, 0 );

		$expectedList = new ReferenceList( array( $reference1, $reference2 ) );
		$this->assertSameReferenceOrder( $expectedList, $references );
	}

	/**
	 * @dataProvider instanceProvider
	 */
	public function testIndexOf( ReferenceList $array ) {
		$this->assertFalse( $array->indexOf( new Reference() ) );

		$i = 0;
		foreach ( $array as $reference ) {
			$this->assertEquals( $i++, $array->indexOf( $reference ) );
		}
	}

	public function testIndexOf_checksForIdentity() {
		$reference1 = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
		$reference2 = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
		$referenceList = new ReferenceList( array( $reference1 ) );

		$this->assertNotSame( $reference1, $reference2, 'post condition' );
		$this->assertTrue( $reference1->equals( $reference2 ), 'post condition' );
		$this->assertSame( 0, $referenceList->indexOf( $reference1 ), 'identity' );
		$this->assertFalse( $referenceList->indexOf( $reference2 ), 'not equality' );
	}

	/**
	 * @dataProvider instanceProvider
	 */
	public function testEquals( ReferenceList $array ) {
		$this->assertTrue( $array->equals( $array ) );
		$this->assertFalse( $array->equals( 42 ) );
	}

	/**
	 * @dataProvider instanceProvider
	 */
	public function testGetValueHashReturnsString( ReferenceList $array ) {
		$this->assertInternalType( 'string', $array->getValueHash() );
	}

	/**
	 * @dataProvider instanceProvider
	 */
	public function testGetValueHashIsTheSameForClone( ReferenceList $array ) {
		$copy = unserialize( serialize( $array ) );
		$this->assertEquals( $array->getValueHash(), $copy->getValueHash() );
	}

	/**
	 * @dataProvider instanceProvider
	 */
	public function testHasReferenceHash( ReferenceList $references ) {
		$this->assertFalse( $references->hasReferenceHash( '~=[,,_,,]:3' ) );

		/**
		 * @var Hashable $reference
		 */
		foreach ( $references as $reference ) {
			$this->assertTrue( $references->hasReferenceHash( $reference->getHash() ) );
		}
	}

	/**
	 * @dataProvider instanceProvider
	 */
	public function testGetReference( ReferenceList $references ) {
		$this->assertNull( $references->getReference( '~=[,,_,,]:3' ) );

		/**
		 * @var Reference $reference
		 */
		foreach ( $references as $reference ) {
			$this->assertTrue( $reference->equals( $references->getReference( $reference->getHash() ) ) );
		}
	}

	/**
	 * @dataProvider instanceProvider
	 */
	public function testRemoveReferenceHash( ReferenceList $references ) {
		$references->removeReferenceHash( '~=[,,_,,]:3' );

		$hashes = array();

		/**
		 * @var Reference $reference
		 */
		foreach ( $references as $reference ) {
			$hashes[] = $reference->getHash();
		}

		foreach ( $hashes as $hash ) {
			$references->removeReferenceHash( $hash );
		}

		$this->assertEquals( 0, count( $references ) );
	}

	public function testRemoveReferenceHashRemovesIdenticalObjects() {
		$reference = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
		$references = new ReferenceList( array( $reference, $reference ) );

		$references->removeReferenceHash( $reference->getHash() );

		$this->assertTrue( $references->isEmpty() );
	}

	public function testRemoveReferenceHashDoesNotRemoveCopies() {
		$reference = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
		$references = new ReferenceList( array( $reference, clone $reference ) );

		$references->removeReferenceHash( $reference->getHash() );

		$this->assertFalse( $references->isEmpty() );
		$this->assertTrue( $references->hasReference( $reference ) );
		$this->assertNotSame( $reference, $references->getReference( $reference->getHash() ) );
	}

	public function testRemoveReferenceHashUpdatesIndexes() {
		$reference1 = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
		$reference2 = new Reference( array( new PropertyNoValueSnak( 2 ) ) );
		$references = new ReferenceList( array( $reference1, $reference2 ) );

		$references->removeReferenceHash( $reference1->getHash() );

		$this->assertSame( 0, $references->indexOf( $reference2 ) );
	}

	public function testGivenOneSnak_addNewReferenceAddsSnak() {
		$references = new ReferenceList();
		$snak = new PropertyNoValueSnak( 1 );

		$references->addNewReference( $snak );
		$this->assertTrue( $references->hasReference( new Reference( array( $snak ) ) ) );
	}

	public function testGivenMultipleSnaks_addNewReferenceAddsThem() {
		$references = new ReferenceList();
		$snak1 = new PropertyNoValueSnak( 1 );
		$snak2 = new PropertyNoValueSnak( 3 );
		$snak3 = new PropertyNoValueSnak( 2 );

		$references->addNewReference( $snak1, $snak2, $snak3 );

		$expectedSnaks = array( $snak1, $snak2, $snak3 );
		$this->assertTrue( $references->hasReference( new Reference( $expectedSnaks ) ) );
	}

	public function testGivenAnArrayOfSnaks_addNewReferenceAddsThem() {
		$references = new ReferenceList();
		$snaks = array(
			new PropertyNoValueSnak( 1 ),
			new PropertyNoValueSnak( 3 ),
			new PropertyNoValueSnak( 2 )
		);

		$references->addNewReference( $snaks );
		$this->assertTrue( $references->hasReference( new Reference( $snaks ) ) );
	}

	public function testGivenNoneSnak_addNewReferenceThrowsException() {
		$references = new ReferenceList();

		$this->setExpectedException( 'InvalidArgumentException' );

		$references->addNewReference( new PropertyNoValueSnak( 1 ), null );
	}

	public function testSerializationStability() {
		$references = new ReferenceList();
		$this->assertSame( 'a:0:{}', $references->serialize() );
	}

	public function testSerializeRoundtrip() {
		$references = new ReferenceList();

		$references->addReference( new Reference() );

		$references->addReference( new Reference( array(
			new PropertyNoValueSnak( 2 ),
			new PropertyNoValueSnak( 3 ),
		) ) );

		$serialized = serialize( $references );
		$this->assertTrue( $references->equals( unserialize( $serialized ) ) );
	}

	public function testGivenEmptyList_isEmpty() {
		$references = new ReferenceList();
		$this->assertTrue( $references->isEmpty() );
	}

	public function testGivenNonEmptyList_isNotEmpty() {
		$references = new ReferenceList();
		$references->addNewReference( new PropertyNoValueSnak( 1 ) );

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

}


1			<?php
2
3			namespace Wikibase\DataModel\Tests;
4
5			use Hashable;
6			use InvalidArgumentException;
7			use PHPUnit_Framework_TestCase;
8			use Wikibase\DataModel\Entity\PropertyId;
9			use Wikibase\DataModel\Reference;
10			use Wikibase\DataModel\ReferenceList;
11			use Wikibase\DataModel\Snak\PropertyNoValueSnak;
12			use Wikibase\DataModel\Snak\SnakList;
13
14			/**
15			* @covers Wikibase\DataModel\ReferenceList
16			*
17			* @group Wikibase
18			* @group WikibaseDataModel
19			* @group WikibaseReference
20			*
21			* @licence GNU GPL v2+
22			* @author Jeroen De Dauw < [email protected] >
23			* @author Thiemo Mättig
24			*/
25			class ReferenceListTest extends PHPUnit_Framework_TestCase {
26
27			public function instanceProvider() {
28			$instances = array();
29
30			foreach ( $this->getConstructorArg() as $arg ) {
31			$instances[] = array( new ReferenceList( $arg ) );
32			}
33
34			return $instances;
35			}
36
37			public function getElementInstances() {
38			return array(
39			new Reference(),
40			new Reference( array( new PropertyNoValueSnak( 2 ) ) ),
41			new Reference( array( new PropertyNoValueSnak( 3 ) ) ),
42			);
43			}
44
45			public function getConstructorArg() {
46			return array(
47			array(),
48			$this->getElementInstances(),
49			);
50			}
51
52			public function testCanConstructWithReferenceListObject() {
53			$reference = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
54			$original = new ReferenceList( array( $reference ) );
55			$copy = new ReferenceList( $original );
56
57			$this->assertSame( 1, $copy->count() );
58			$this->assertNotNull( $copy->getReference( $reference->getHash() ) );
59			}
60
61			public function testConstructorIgnoresIdenticalObjects() {
62			$reference = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
63			$original = new ReferenceList( array( $reference, $reference ) );
64			$this->assertCount( 1, $original );
65			}
66
67			public function testConstructorIgnoresCopies() {
68			$reference = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
69			$original = new ReferenceList( array( $reference, clone $reference ) );
70			$this->assertCount( 1, $original );
71			}
72
73			/**
74			* @dataProvider invalidConstructorArgumentsProvider
75			* @expectedException InvalidArgumentException
76			*/
77			public function testGivenInvalidConstructorArguments_constructorThrowsException( $input ) {
78			new ReferenceList( $input );
79			}
80
81			public function invalidConstructorArgumentsProvider() {
82			$id1 = new PropertyId( 'P1' );
83
84			return array(
85			array( null ),
86			array( false ),
87			array( 1 ),
88			array( 0.1 ),
89			array( 'string' ),
90			array( $id1 ),
91			array( new PropertyNoValueSnak( $id1 ) ),
92			array( new Reference() ),
93			array( new SnakList( array( new PropertyNoValueSnak( $id1 ) ) ) ),
94			array( array( new PropertyNoValueSnak( $id1 ) ) ),
95			array( array( new ReferenceList() ) ),
96			array( array( new SnakList() ) ),
97			);
98			}
99
100			public function testGetIterator_isTraversable() {
101			$references = new ReferenceList();
102			$references->addNewReference( new PropertyNoValueSnak( 1 ) );
103			$iterator = $references->getIterator();
104
105			$this->assertInstanceOf( 'Traversable', $iterator );
106			$this->assertCount( 1, $iterator );
107			foreach ( $references as $reference ) {
108			$this->assertInstanceOf( 'Wikibase\DataModel\Reference', $reference );
109			}
110			}
111
112			/**
113			* @dataProvider instanceProvider
114			*/
115			public function testHasReferenceBeforeRemoveButNotAfter( ReferenceList $array ) {
116			if ( $array->count() === 0 ) {
117			$this->assertTrue( true );
118			return;
119			}
120
121			/**
122			* @var Reference $hashable
123			*/
124			foreach ( iterator_to_array( $array ) as $hashable ) {
125			$this->assertTrue( $array->hasReference( $hashable ) );
126			$array->removeReference( $hashable );
127			$this->assertFalse( $array->hasReference( $hashable ) );
128			}
129			}
130
131			public function testGivenCloneOfReferenceInList_hasReferenceReturnsTrue() {
132			$list = new ReferenceList();
133
134			$reference = new Reference( array( new PropertyNoValueSnak( 42 ) ) );
135			$sameReference = unserialize( serialize( $reference ) );
136
137			$list->addReference( $reference );
138
139			$this->assertTrue(
140			$list->hasReference( $sameReference ),
141			'hasReference should return true when a reference with the same value is present, even when its another instance'
142			);
143			}
144
145			/**
146			* @dataProvider instanceProvider
147			*/
148			public function testRemoveReference( ReferenceList $array ) {
149			$elementCount = count( $array );
150
151			/**
152			* @var Reference $element
153			*/
154			foreach ( iterator_to_array( $array ) as $element ) {
155			$this->assertTrue( $array->hasReference( $element ) );
156
157			$array->removeReference( $element );
158
159			$this->assertFalse( $array->hasReference( $element ) );
160			$this->assertEquals( --$elementCount, count( $array ) );
161			}
162
163			$elements = $this->getElementInstances();
164			$element = array_shift( $elements );
165
166			$array->removeReference( $element );
			0 ignored issues – show Bug introduced 2016-02-04 18:26 UTC by Report Bug Copy Issue Report It seems like `$element` defined by `array_shift($elements)` on line `164` can be `null`; however, `Wikibase\DataModel\Refer...List::removeReference()` does not accept `null`, maybe add an additional type check? Unless you are absolutely sure that the expression can never be null because of other conditions, we strongly recommend to add an additional type check to your code: /** @return stdClass\|null */ function mayReturnNull() { } function doesNotAcceptNull(stdClass $x) { } // With potential error. function withoutCheck() { $x = mayReturnNull(); doesNotAcceptNull($x); // Potential error here. } // Safe - Alternative 1 function withCheck1() { $x = mayReturnNull(); if ( ! $x instanceof stdClass) { throw new \LogicException('$x must be defined.'); } doesNotAcceptNull($x); } // Safe - Alternative 2 function withCheck2() { $x = mayReturnNull(); if ($x instanceof stdClass) { doesNotAcceptNull($x); } } Loading history...
167			$array->removeReference( $element );
			0 ignored issues – show Bug introduced 2016-02-04 18:26 UTC by Report Bug Copy Issue Report It seems like `$element` defined by `array_shift($elements)` on line `164` can be `null`; however, `Wikibase\DataModel\Refer...List::removeReference()` does not accept `null`, maybe add an additional type check? Unless you are absolutely sure that the expression can never be null because of other conditions, we strongly recommend to add an additional type check to your code: /** @return stdClass\|null */ function mayReturnNull() { } function doesNotAcceptNull(stdClass $x) { } // With potential error. function withoutCheck() { $x = mayReturnNull(); doesNotAcceptNull($x); // Potential error here. } // Safe - Alternative 1 function withCheck1() { $x = mayReturnNull(); if ( ! $x instanceof stdClass) { throw new \LogicException('$x must be defined.'); } doesNotAcceptNull($x); } // Safe - Alternative 2 function withCheck2() { $x = mayReturnNull(); if ($x instanceof stdClass) { doesNotAcceptNull($x); } } Loading history...
168
169			$this->assertTrue( true );
170			}
171
172			public function testRemoveReferenceRemovesIdenticalObjects() {
173			$reference = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
174			$references = new ReferenceList( array( $reference, $reference ) );
175
176			$references->removeReference( $reference );
177
178			$this->assertTrue( $references->isEmpty() );
179			}
180
181			public function testRemoveReferenceDoesNotRemoveCopies() {
182			$reference = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
183			$references = new ReferenceList( array( $reference, clone $reference ) );
184
185			$references->removeReference( $reference );
186
187			$this->assertFalse( $references->isEmpty() );
188			$this->assertTrue( $references->hasReference( $reference ) );
189			$this->assertNotSame( $reference, $references->getReference( $reference->getHash() ) );
190			}
191
192			public function testAddReferenceOnEmptyList() {
193			$reference = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
194
195			$references = new ReferenceList();
196			$references->addReference( $reference );
197
198			$this->assertCount( 1, $references );
199
200			$expectedList = new ReferenceList( array( $reference ) );
201			$this->assertSameReferenceOrder( $expectedList, $references );
202			}
203
204			private function assertSameReferenceOrder( ReferenceList $expectedList, ReferenceList $references ) {
205			$this->assertEquals(
206			iterator_to_array( $expectedList ),
207			iterator_to_array( $references )
208			);
209			}
210
211			public function testAddReferenceOnNonEmptyList() {
212			$reference1 = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
213			$reference2 = new Reference( array( new PropertyNoValueSnak( 2 ) ) );
214			$reference3 = new Reference( array( new PropertyNoValueSnak( 3 ) ) );
215
216			$references = new ReferenceList( array( $reference1, $reference2 ) );
217			$references->addReference( $reference3 );
218
219			$this->assertCount( 3, $references );
220
221			$expectedList = new ReferenceList( array( $reference1, $reference2, $reference3 ) );
222			$this->assertSameReferenceOrder( $expectedList, $references );
223			}
224
225			public function testAddReferenceAtIndexZero() {
226			$reference1 = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
227			$reference2 = new Reference( array( new PropertyNoValueSnak( 2 ) ) );
228			$reference3 = new Reference( array( new PropertyNoValueSnak( 3 ) ) );
229
230			$references = new ReferenceList( array( $reference1, $reference2 ) );
231			$references->addReference( $reference3, 0 );
232
233			$expectedList = new ReferenceList( array( $reference3, $reference1, $reference2 ) );
234			$this->assertSameReferenceOrder( $expectedList, $references );
235			}
236
237			public function testAddReferenceAtNegativeIndex() {
238			$reference = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
239			$referenceList = new ReferenceList();
240
241			$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...
242			$referenceList->addReference( $reference, -1 );
243			}
244
245			public function testGivenEmptyReference_addReferenceDoesNotAdd() {
246			$reference1 = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
247			$reference2 = new Reference( array( new PropertyNoValueSnak( 2 ) ) );
248			$emptyReference = new Reference( array() );
249
250			$references = new ReferenceList( array( $reference1, $reference2 ) );
251			$references->addReference( $emptyReference );
252
253			$expectedList = new ReferenceList( array( $reference1, $reference2 ) );
254			$this->assertSameReferenceOrder( $expectedList, $references );
255			}
256
257			public function testGivenEmptyReferenceAndIndex_addReferenceDoesNotAdd() {
258			$reference1 = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
259			$reference2 = new Reference( array( new PropertyNoValueSnak( 2 ) ) );
260			$emptyReference = new Reference( array() );
261
262			$references = new ReferenceList( array( $reference1, $reference2 ) );
263			$references->addReference( $emptyReference, 0 );
264
265			$expectedList = new ReferenceList( array( $reference1, $reference2 ) );
266			$this->assertSameReferenceOrder( $expectedList, $references );
267			}
268
269			/**
270			* @dataProvider instanceProvider
271			*/
272			public function testIndexOf( ReferenceList $array ) {
273			$this->assertFalse( $array->indexOf( new Reference() ) );
274
275			$i = 0;
276			foreach ( $array as $reference ) {
277			$this->assertEquals( $i++, $array->indexOf( $reference ) );
278			}
279			}
280
281			public function testIndexOf_checksForIdentity() {
282			$reference1 = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
283			$reference2 = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
284			$referenceList = new ReferenceList( array( $reference1 ) );
285
286			$this->assertNotSame( $reference1, $reference2, 'post condition' );
287			$this->assertTrue( $reference1->equals( $reference2 ), 'post condition' );
288			$this->assertSame( 0, $referenceList->indexOf( $reference1 ), 'identity' );
289			$this->assertFalse( $referenceList->indexOf( $reference2 ), 'not equality' );
290			}
291
292			/**
293			* @dataProvider instanceProvider
294			*/
295			public function testEquals( ReferenceList $array ) {
296			$this->assertTrue( $array->equals( $array ) );
297			$this->assertFalse( $array->equals( 42 ) );
298			}
299
300			/**
301			* @dataProvider instanceProvider
302			*/
303			public function testGetValueHashReturnsString( ReferenceList $array ) {
304			$this->assertInternalType( 'string', $array->getValueHash() );
305			}
306
307			/**
308			* @dataProvider instanceProvider
309			*/
310			public function testGetValueHashIsTheSameForClone( ReferenceList $array ) {
311			$copy = unserialize( serialize( $array ) );
312			$this->assertEquals( $array->getValueHash(), $copy->getValueHash() );
313			}
314
315			/**
316			* @dataProvider instanceProvider
317			*/
318			public function testHasReferenceHash( ReferenceList $references ) {
319			$this->assertFalse( $references->hasReferenceHash( '~=[,,_,,]:3' ) );
320
321			/**
322			* @var Hashable $reference
323			*/
324			foreach ( $references as $reference ) {
325			$this->assertTrue( $references->hasReferenceHash( $reference->getHash() ) );
326			}
327			}
328
329			/**
330			* @dataProvider instanceProvider
331			*/
332			public function testGetReference( ReferenceList $references ) {
333			$this->assertNull( $references->getReference( '~=[,,_,,]:3' ) );
334
335			/**
336			* @var Reference $reference
337			*/
338			foreach ( $references as $reference ) {
339			$this->assertTrue( $reference->equals( $references->getReference( $reference->getHash() ) ) );
340			}
341			}
342
343			/**
344			* @dataProvider instanceProvider
345			*/
346			public function testRemoveReferenceHash( ReferenceList $references ) {
347			$references->removeReferenceHash( '~=[,,_,,]:3' );
348
349			$hashes = array();
350
351			/**
352			* @var Reference $reference
353			*/
354			foreach ( $references as $reference ) {
355			$hashes[] = $reference->getHash();
356			}
357
358			foreach ( $hashes as $hash ) {
359			$references->removeReferenceHash( $hash );
360			}
361
362			$this->assertEquals( 0, count( $references ) );
363			}
364
365			public function testRemoveReferenceHashRemovesIdenticalObjects() {
366			$reference = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
367			$references = new ReferenceList( array( $reference, $reference ) );
368
369			$references->removeReferenceHash( $reference->getHash() );
370
371			$this->assertTrue( $references->isEmpty() );
372			}
373
374			public function testRemoveReferenceHashDoesNotRemoveCopies() {
375			$reference = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
376			$references = new ReferenceList( array( $reference, clone $reference ) );
377
378			$references->removeReferenceHash( $reference->getHash() );
379
380			$this->assertFalse( $references->isEmpty() );
381			$this->assertTrue( $references->hasReference( $reference ) );
382			$this->assertNotSame( $reference, $references->getReference( $reference->getHash() ) );
383			}
384
385			public function testRemoveReferenceHashUpdatesIndexes() {
386			$reference1 = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
387			$reference2 = new Reference( array( new PropertyNoValueSnak( 2 ) ) );
388			$references = new ReferenceList( array( $reference1, $reference2 ) );
389
390			$references->removeReferenceHash( $reference1->getHash() );
391
392			$this->assertSame( 0, $references->indexOf( $reference2 ) );
393			}
394
395			public function testGivenOneSnak_addNewReferenceAddsSnak() {
396			$references = new ReferenceList();
397			$snak = new PropertyNoValueSnak( 1 );
398
399			$references->addNewReference( $snak );
400			$this->assertTrue( $references->hasReference( new Reference( array( $snak ) ) ) );
401			}
402
403			public function testGivenMultipleSnaks_addNewReferenceAddsThem() {
404			$references = new ReferenceList();
405			$snak1 = new PropertyNoValueSnak( 1 );
406			$snak2 = new PropertyNoValueSnak( 3 );
407			$snak3 = new PropertyNoValueSnak( 2 );
408
409			$references->addNewReference( $snak1, $snak2, $snak3 );
410
411			$expectedSnaks = array( $snak1, $snak2, $snak3 );
412			$this->assertTrue( $references->hasReference( new Reference( $expectedSnaks ) ) );
413			}
414
415			public function testGivenAnArrayOfSnaks_addNewReferenceAddsThem() {
416			$references = new ReferenceList();
417			$snaks = array(
418			new PropertyNoValueSnak( 1 ),
419			new PropertyNoValueSnak( 3 ),
420			new PropertyNoValueSnak( 2 )
421			);
422
423			$references->addNewReference( $snaks );
424			$this->assertTrue( $references->hasReference( new Reference( $snaks ) ) );
425			}
426
427			public function testGivenNoneSnak_addNewReferenceThrowsException() {
428			$references = new ReferenceList();
429
430			$this->setExpectedException( 'InvalidArgumentException' );
			0 ignored issues – show Deprecated Code introduced 2016-02-18 16:34 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...
431			$references->addNewReference( new PropertyNoValueSnak( 1 ), null );
432			}
433
434			public function testSerializationStability() {
435			$references = new ReferenceList();
436			$this->assertSame( 'a:0:{}', $references->serialize() );
437			}
438
439			public function testSerializeRoundtrip() {
440			$references = new ReferenceList();
441
442			$references->addReference( new Reference() );
443
444			$references->addReference( new Reference( array(
445			new PropertyNoValueSnak( 2 ),
446			new PropertyNoValueSnak( 3 ),
447			) ) );
448
449			$serialized = serialize( $references );
450			$this->assertTrue( $references->equals( unserialize( $serialized ) ) );
451			}
452
453			public function testGivenEmptyList_isEmpty() {
454			$references = new ReferenceList();
455			$this->assertTrue( $references->isEmpty() );
456			}
457
458			public function testGivenNonEmptyList_isNotEmpty() {
459			$references = new ReferenceList();
460			$references->addNewReference( new PropertyNoValueSnak( 1 ) );
461
462			$this->assertFalse( $references->isEmpty() );
463			}
464
465			}
466

wmde / WikibaseDataModel

Push — refDuplicates ( 2ea7b8 )

ReferenceListTest::testConstructorIgnoresCopies() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like