ReferenceListTest - Code Metrics - Inspection of "Fix unexpected behavior of ReferenceList::removeRe..." - wmde/WikibaseDataModel - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Push — refHashBehavior ( db11d8 )

by no

created 2016-02-18 15:57 UTC

ReferenceListTest B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	398
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Importance

Changes	12
Bugs	2	Features	4

Metric	Value
wmc	45
c	12
b	2
f	4
lcom	1
cbo	6
dl	0
loc	398
rs	8.3673

35 Methods

Rating	Name	Size	Complexity
A	instanceProvider()	9	2
A	getElementInstances()	7	1
A	getConstructorArg()	6	1
A	testCanConstructWithReferenceListObject()	8	1
A	testGivenInvalidConstructorArguments_constructorThrowsException()	3	1
A	invalidConstructorArgumentsProvider()	18	1
A	testHasReferenceBeforeRemoveButNotAfter()	15	3
A	testRemoveReference()	23	2
A	testAddReferenceOnEmptyList()	11	1
A	assertSameReferenceOrder()	6	1
A	testAddReferenceOnNonEmptyList()	13	1
A	testAddReferenceAtIndexZero()	11	1
A	testAddReferenceAtNegativeIndex()	7	1
A	testGivenEmptyReference_addReferenceDoesNotAdd()	11	1
A	testIndexOf()	8	2
A	testGetIterator_isTraversable()	11	2
A	testGivenCloneOfReferenceInList_hasReferenceReturnsTrue()	13	1
A	testGivenEmptyReferenceAndIndex_addReferenceDoesNotAdd()	11	1
A	testIndexOf_checksForIdentity()	10	1
A	testEquals()	4	1
A	testGetValueHashReturnsString()	3	1
A	testGetValueHashIsTheSameForClone()	4	1
A	testHasReferenceHash()	10	2
A	testGetReference()	10	2
A	testRemoveReferenceHash()	18	3
A	testRemoveReferenceHashRemovesDuplicates()	8	1
A	testRemoveReferenceHashUpdatesIndexes()	9	1
A	testGivenOneSnak_addNewReferenceAddsSnak()	7	1
A	testGivenMultipleSnaks_addNewReferenceAddsThem()	11	1
A	testGivenAnArrayOfSnaks_addNewReferenceAddsThem()	11	1
A	testGivenNoneSnak_addNewReferenceThrowsException()	6	1
A	testSerializationStability()	4	1
A	testSerializeRoundtrip()	13	1
A	testGivenEmptyList_isEmpty()	4	1
A	testGivenNonEmptyList_isNotEmpty()	6	1

How to fix Complexity

<?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() ) );
	}

	/**
	 * @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 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 testRemoveReferenceHashRemovesDuplicates() {
		$reference = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
		$references = new ReferenceList( array( $reference, $reference ) );

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

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

	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			/**
62			* @dataProvider invalidConstructorArgumentsProvider
63			* @expectedException InvalidArgumentException
64			*/
65			public function testGivenInvalidConstructorArguments_constructorThrowsException( $input ) {
66			new ReferenceList( $input );
67			}
68
69			public function invalidConstructorArgumentsProvider() {
70			$id1 = new PropertyId( 'P1' );
71
72			return array(
73			array( null ),
74			array( false ),
75			array( 1 ),
76			array( 0.1 ),
77			array( 'string' ),
78			array( $id1 ),
79			array( new PropertyNoValueSnak( $id1 ) ),
80			array( new Reference() ),
81			array( new SnakList( array( new PropertyNoValueSnak( $id1 ) ) ) ),
82			array( array( new PropertyNoValueSnak( $id1 ) ) ),
83			array( array( new ReferenceList() ) ),
84			array( array( new SnakList() ) ),
85			);
86			}
87
88			public function testGetIterator_isTraversable() {
89			$references = new ReferenceList();
90			$references->addNewReference( new PropertyNoValueSnak( 1 ) );
91			$iterator = $references->getIterator();
92
93			$this->assertInstanceOf( 'Traversable', $iterator );
94			$this->assertCount( 1, $iterator );
95			foreach ( $references as $reference ) {
96			$this->assertInstanceOf( 'Wikibase\DataModel\Reference', $reference );
97			}
98			}
99
100			/**
101			* @dataProvider instanceProvider
102			*/
103			public function testHasReferenceBeforeRemoveButNotAfter( ReferenceList $array ) {
104			if ( $array->count() === 0 ) {
105			$this->assertTrue( true );
106			return;
107			}
108
109			/**
110			* @var Reference $hashable
111			*/
112			foreach ( iterator_to_array( $array ) as $hashable ) {
113			$this->assertTrue( $array->hasReference( $hashable ) );
114			$array->removeReference( $hashable );
115			$this->assertFalse( $array->hasReference( $hashable ) );
116			}
117			}
118
119			public function testGivenCloneOfReferenceInList_hasReferenceReturnsTrue() {
120			$list = new ReferenceList();
121
122			$reference = new Reference( array( new PropertyNoValueSnak( 42 ) ) );
123			$sameReference = unserialize( serialize( $reference ) );
124
125			$list->addReference( $reference );
126
127			$this->assertTrue(
128			$list->hasReference( $sameReference ),
129			'hasReference should return true when a reference with the same value is present, even when its another instance'
130			);
131			}
132
133			/**
134			* @dataProvider instanceProvider
135			*/
136			public function testRemoveReference( ReferenceList $array ) {
137			$elementCount = count( $array );
138
139			/**
140			* @var Reference $element
141			*/
142			foreach ( iterator_to_array( $array ) as $element ) {
143			$this->assertTrue( $array->hasReference( $element ) );
144
145			$array->removeReference( $element );
146
147			$this->assertFalse( $array->hasReference( $element ) );
148			$this->assertEquals( --$elementCount, count( $array ) );
149			}
150
151			$elements = $this->getElementInstances();
152			$element = array_shift( $elements );
153
154			$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 `152` 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...
155			$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 `152` 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...
156
157			$this->assertTrue( true );
158			}
159
160			public function testAddReferenceOnEmptyList() {
161			$reference = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
162
163			$references = new ReferenceList();
164			$references->addReference( $reference );
165
166			$this->assertCount( 1, $references );
167
168			$expectedList = new ReferenceList( array( $reference ) );
169			$this->assertSameReferenceOrder( $expectedList, $references );
170			}
171
172			private function assertSameReferenceOrder( ReferenceList $expectedList, ReferenceList $references ) {
173			$this->assertEquals(
174			iterator_to_array( $expectedList ),
175			iterator_to_array( $references )
176			);
177			}
178
179			public function testAddReferenceOnNonEmptyList() {
180			$reference1 = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
181			$reference2 = new Reference( array( new PropertyNoValueSnak( 2 ) ) );
182			$reference3 = new Reference( array( new PropertyNoValueSnak( 3 ) ) );
183
184			$references = new ReferenceList( array( $reference1, $reference2 ) );
185			$references->addReference( $reference3 );
186
187			$this->assertCount( 3, $references );
188
189			$expectedList = new ReferenceList( array( $reference1, $reference2, $reference3 ) );
190			$this->assertSameReferenceOrder( $expectedList, $references );
191			}
192
193			public function testAddReferenceAtIndexZero() {
194			$reference1 = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
195			$reference2 = new Reference( array( new PropertyNoValueSnak( 2 ) ) );
196			$reference3 = new Reference( array( new PropertyNoValueSnak( 3 ) ) );
197
198			$references = new ReferenceList( array( $reference1, $reference2 ) );
199			$references->addReference( $reference3, 0 );
200
201			$expectedList = new ReferenceList( array( $reference3, $reference1, $reference2 ) );
202			$this->assertSameReferenceOrder( $expectedList, $references );
203			}
204
205			public function testAddReferenceAtNegativeIndex() {
206			$reference = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
207			$referenceList = new ReferenceList();
208
209			$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...
210			$referenceList->addReference( $reference, -1 );
211			}
212
213			public function testGivenEmptyReference_addReferenceDoesNotAdd() {
214			$reference1 = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
215			$reference2 = new Reference( array( new PropertyNoValueSnak( 2 ) ) );
216			$emptyReference = new Reference( array() );
217
218			$references = new ReferenceList( array( $reference1, $reference2 ) );
219			$references->addReference( $emptyReference );
220
221			$expectedList = new ReferenceList( array( $reference1, $reference2 ) );
222			$this->assertSameReferenceOrder( $expectedList, $references );
223			}
224
225			public function testGivenEmptyReferenceAndIndex_addReferenceDoesNotAdd() {
226			$reference1 = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
227			$reference2 = new Reference( array( new PropertyNoValueSnak( 2 ) ) );
228			$emptyReference = new Reference( array() );
229
230			$references = new ReferenceList( array( $reference1, $reference2 ) );
231			$references->addReference( $emptyReference, 0 );
232
233			$expectedList = new ReferenceList( array( $reference1, $reference2 ) );
234			$this->assertSameReferenceOrder( $expectedList, $references );
235			}
236
237			/**
238			* @dataProvider instanceProvider
239			*/
240			public function testIndexOf( ReferenceList $array ) {
241			$this->assertFalse( $array->indexOf( new Reference() ) );
242
243			$i = 0;
244			foreach ( $array as $reference ) {
245			$this->assertEquals( $i++, $array->indexOf( $reference ) );
246			}
247			}
248
249			public function testIndexOf_checksForIdentity() {
250			$reference1 = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
251			$reference2 = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
252			$referenceList = new ReferenceList( array( $reference1 ) );
253
254			$this->assertNotSame( $reference1, $reference2, 'post condition' );
255			$this->assertTrue( $reference1->equals( $reference2 ), 'post condition' );
256			$this->assertSame( 0, $referenceList->indexOf( $reference1 ), 'identity' );
257			$this->assertFalse( $referenceList->indexOf( $reference2 ), 'not equality' );
258			}
259
260			/**
261			* @dataProvider instanceProvider
262			*/
263			public function testEquals( ReferenceList $array ) {
264			$this->assertTrue( $array->equals( $array ) );
265			$this->assertFalse( $array->equals( 42 ) );
266			}
267
268			/**
269			* @dataProvider instanceProvider
270			*/
271			public function testGetValueHashReturnsString( ReferenceList $array ) {
272			$this->assertInternalType( 'string', $array->getValueHash() );
273			}
274
275			/**
276			* @dataProvider instanceProvider
277			*/
278			public function testGetValueHashIsTheSameForClone( ReferenceList $array ) {
279			$copy = unserialize( serialize( $array ) );
280			$this->assertEquals( $array->getValueHash(), $copy->getValueHash() );
281			}
282
283			/**
284			* @dataProvider instanceProvider
285			*/
286			public function testHasReferenceHash( ReferenceList $references ) {
287			$this->assertFalse( $references->hasReferenceHash( '~=[,,_,,]:3' ) );
288
289			/**
290			* @var Hashable $reference
291			*/
292			foreach ( $references as $reference ) {
293			$this->assertTrue( $references->hasReferenceHash( $reference->getHash() ) );
294			}
295			}
296
297			/**
298			* @dataProvider instanceProvider
299			*/
300			public function testGetReference( ReferenceList $references ) {
301			$this->assertNull( $references->getReference( '~=[,,_,,]:3' ) );
302
303			/**
304			* @var Reference $reference
305			*/
306			foreach ( $references as $reference ) {
307			$this->assertTrue( $reference->equals( $references->getReference( $reference->getHash() ) ) );
308			}
309			}
310
311			/**
312			* @dataProvider instanceProvider
313			*/
314			public function testRemoveReferenceHash( ReferenceList $references ) {
315			$references->removeReferenceHash( '~=[,,_,,]:3' );
316
317			$hashes = array();
318
319			/**
320			* @var Reference $reference
321			*/
322			foreach ( $references as $reference ) {
323			$hashes[] = $reference->getHash();
324			}
325
326			foreach ( $hashes as $hash ) {
327			$references->removeReferenceHash( $hash );
328			}
329
330			$this->assertEquals( 0, count( $references ) );
331			}
332
333			public function testRemoveReferenceHashRemovesDuplicates() {
334			$reference = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
335			$references = new ReferenceList( array( $reference, $reference ) );
336
337			$references->removeReferenceHash( $reference->getHash() );
338
339			$this->assertTrue( $references->isEmpty() );
340			}
341
342			public function testRemoveReferenceHashUpdatesIndexes() {
343			$reference1 = new Reference( array( new PropertyNoValueSnak( 1 ) ) );
344			$reference2 = new Reference( array( new PropertyNoValueSnak( 2 ) ) );
345			$references = new ReferenceList( array( $reference1, $reference2 ) );
346
347			$references->removeReferenceHash( $reference1->getHash() );
348
349			$this->assertSame( 0, $references->indexOf( $reference2 ) );
350			}
351
352			public function testGivenOneSnak_addNewReferenceAddsSnak() {
353			$references = new ReferenceList();
354			$snak = new PropertyNoValueSnak( 1 );
355
356			$references->addNewReference( $snak );
357			$this->assertTrue( $references->hasReference( new Reference( array( $snak ) ) ) );
358			}
359
360			public function testGivenMultipleSnaks_addNewReferenceAddsThem() {
361			$references = new ReferenceList();
362			$snak1 = new PropertyNoValueSnak( 1 );
363			$snak2 = new PropertyNoValueSnak( 3 );
364			$snak3 = new PropertyNoValueSnak( 2 );
365
366			$references->addNewReference( $snak1, $snak2, $snak3 );
367
368			$expectedSnaks = array( $snak1, $snak2, $snak3 );
369			$this->assertTrue( $references->hasReference( new Reference( $expectedSnaks ) ) );
370			}
371
372			public function testGivenAnArrayOfSnaks_addNewReferenceAddsThem() {
373			$references = new ReferenceList();
374			$snaks = array(
375			new PropertyNoValueSnak( 1 ),
376			new PropertyNoValueSnak( 3 ),
377			new PropertyNoValueSnak( 2 )
378			);
379
380			$references->addNewReference( $snaks );
381			$this->assertTrue( $references->hasReference( new Reference( $snaks ) ) );
382			}
383
384			public function testGivenNoneSnak_addNewReferenceThrowsException() {
385			$references = new ReferenceList();
386
387			$this->setExpectedException( 'InvalidArgumentException' );
			0 ignored issues – show Deprecated Code introduced 2016-02-09 14:33 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...
388			$references->addNewReference( new PropertyNoValueSnak( 1 ), null );
389			}
390
391			public function testSerializationStability() {
392			$references = new ReferenceList();
393			$this->assertSame( 'a:0:{}', $references->serialize() );
394			}
395
396			public function testSerializeRoundtrip() {
397			$references = new ReferenceList();
398
399			$references->addReference( new Reference() );
400
401			$references->addReference( new Reference( array(
402			new PropertyNoValueSnak( 2 ),
403			new PropertyNoValueSnak( 3 ),
404			) ) );
405
406			$serialized = serialize( $references );
407			$this->assertTrue( $references->equals( unserialize( $serialized ) ) );
408			}
409
410			public function testGivenEmptyList_isEmpty() {
411			$references = new ReferenceList();
412			$this->assertTrue( $references->isEmpty() );
413			}
414
415			public function testGivenNonEmptyList_isNotEmpty() {
416			$references = new ReferenceList();
417			$references->addNewReference( new PropertyNoValueSnak( 1 ) );
418
419			$this->assertFalse( $references->isEmpty() );
420			}
421
422			}
423

wmde / WikibaseDataModel

Push — refHashBehavior ( db11d8 )

ReferenceListTest B

Complexity

Size/Duplication

Coupling/Cohesion

Importance

35 Methods

How to fix Complexity

Complex Class

Duplication Side-by-Side

Filter issues like