wmde /
WikibaseDataModel
Complex classes like ReferenceListTest often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.
Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.
While breaking up the class, it is a good idea to analyze how other classes use ReferenceListTest, and based on these observations, apply Extract Interface, too.
| 1 | <?php |
||
| 25 | class ReferenceListTest extends PHPUnit_Framework_TestCase { |
||
| 26 | |||
| 27 | public function instanceProvider() { |
||
| 28 | return array( |
||
| 29 | array( new ReferenceList( array() ) ), |
||
| 30 | array( new ReferenceList( array( |
||
| 31 | new Reference(), |
||
| 32 | new Reference( array( new PropertyNoValueSnak( 2 ) ) ), |
||
| 33 | new Reference( array( new PropertyNoValueSnak( 3 ) ) ), |
||
| 34 | ) ) ), |
||
| 35 | ); |
||
| 36 | } |
||
| 37 | |||
| 38 | public function testCanConstructWithReferenceListObject() { |
||
| 39 | $reference = new Reference( array( new PropertyNoValueSnak( 1 ) ) ); |
||
| 40 | $original = new ReferenceList( array( $reference ) ); |
||
| 41 | $copy = new ReferenceList( $original ); |
||
| 42 | |||
| 43 | $this->assertSame( 1, $copy->count() ); |
||
| 44 | $this->assertNotNull( $copy->getReference( $reference->getHash() ) ); |
||
| 45 | } |
||
| 46 | |||
| 47 | /** |
||
| 48 | * @dataProvider invalidConstructorArgumentsProvider |
||
| 49 | * @expectedException InvalidArgumentException |
||
| 50 | */ |
||
| 51 | public function testGivenInvalidConstructorArguments_constructorThrowsException( $input ) { |
||
| 52 | new ReferenceList( $input ); |
||
| 53 | } |
||
| 54 | |||
| 55 | public function invalidConstructorArgumentsProvider() { |
||
| 56 | $id1 = new PropertyId( 'P1' ); |
||
| 57 | |||
| 58 | return array( |
||
| 59 | array( null ), |
||
| 60 | array( false ), |
||
| 61 | array( 1 ), |
||
| 62 | array( 0.1 ), |
||
| 63 | array( 'string' ), |
||
| 64 | array( $id1 ), |
||
| 65 | array( new PropertyNoValueSnak( $id1 ) ), |
||
| 66 | array( new Reference() ), |
||
| 67 | array( new SnakList( array( new PropertyNoValueSnak( $id1 ) ) ) ), |
||
| 68 | array( array( new PropertyNoValueSnak( $id1 ) ) ), |
||
| 69 | array( array( new ReferenceList() ) ), |
||
| 70 | array( array( new SnakList() ) ), |
||
| 71 | ); |
||
| 72 | } |
||
| 73 | |||
| 74 | public function testGetIterator_isTraversable() { |
||
| 75 | $references = new ReferenceList(); |
||
| 76 | $references->addNewReference( new PropertyNoValueSnak( 1 ) ); |
||
| 77 | $iterator = $references->getIterator(); |
||
| 78 | |||
| 79 | $this->assertInstanceOf( 'Traversable', $iterator ); |
||
| 80 | $this->assertCount( 1, $iterator ); |
||
| 81 | foreach ( $references as $reference ) { |
||
| 82 | $this->assertInstanceOf( 'Wikibase\DataModel\Reference', $reference ); |
||
| 83 | } |
||
| 84 | } |
||
| 85 | |||
| 86 | /** |
||
| 87 | * @dataProvider instanceProvider |
||
| 88 | */ |
||
| 89 | public function testHasReferenceBeforeRemoveButNotAfter( ReferenceList $array ) { |
||
| 90 | if ( $array->count() === 0 ) { |
||
| 91 | $this->assertTrue( true ); |
||
| 92 | return; |
||
| 93 | } |
||
| 94 | |||
| 95 | /** |
||
| 96 | * @var Reference $hashable |
||
| 97 | */ |
||
| 98 | foreach ( iterator_to_array( $array ) as $hashable ) { |
||
| 99 | $this->assertTrue( $array->hasReference( $hashable ) ); |
||
| 100 | $array->removeReference( $hashable ); |
||
| 101 | $this->assertFalse( $array->hasReference( $hashable ) ); |
||
| 102 | } |
||
| 103 | } |
||
| 104 | |||
| 105 | public function testGivenCloneOfReferenceInList_hasReferenceReturnsTrue() { |
||
| 106 | $list = new ReferenceList(); |
||
| 107 | |||
| 108 | $reference = new Reference( array( new PropertyNoValueSnak( 42 ) ) ); |
||
| 109 | $sameReference = unserialize( serialize( $reference ) ); |
||
| 110 | |||
| 111 | $list->addReference( $reference ); |
||
| 112 | |||
| 113 | $this->assertTrue( |
||
| 114 | $list->hasReference( $sameReference ), |
||
| 115 | 'hasReference should return true when a reference with the same value is present, even when its another instance' |
||
| 116 | ); |
||
| 117 | } |
||
| 118 | |||
| 119 | /** |
||
| 120 | * @dataProvider instanceProvider |
||
| 121 | */ |
||
| 122 | public function testRemoveReference( ReferenceList $array ) { |
||
| 123 | $elementCount = count( $array ); |
||
| 124 | |||
| 125 | /** |
||
| 126 | * @var Reference $element |
||
| 127 | */ |
||
| 128 | foreach ( iterator_to_array( $array ) as $element ) { |
||
| 129 | $this->assertTrue( $array->hasReference( $element ) ); |
||
| 130 | |||
| 131 | $array->removeReference( $element ); |
||
| 132 | |||
| 133 | $this->assertFalse( $array->hasReference( $element ) ); |
||
| 134 | $this->assertEquals( --$elementCount, count( $array ) ); |
||
| 135 | } |
||
| 136 | } |
||
| 137 | |||
| 138 | public function testRemoveReferenceRemovesIdenticalObjects() { |
||
| 139 | $reference = new Reference( array( new PropertyNoValueSnak( 1 ) ) ); |
||
| 140 | $references = new ReferenceList( array( $reference, $reference ) ); |
||
| 141 | |||
| 142 | $references->removeReference( $reference ); |
||
| 143 | |||
| 144 | $this->assertTrue( $references->isEmpty() ); |
||
| 145 | } |
||
| 146 | |||
| 147 | public function testRemoveReferenceDoesNotRemoveCopies() { |
||
| 148 | $reference = new Reference( array( new PropertyNoValueSnak( 1 ) ) ); |
||
| 149 | $references = new ReferenceList( array( $reference, clone $reference ) ); |
||
| 150 | |||
| 151 | $references->removeReference( $reference ); |
||
| 152 | |||
| 153 | $this->assertFalse( $references->isEmpty() ); |
||
| 154 | $this->assertTrue( $references->hasReference( $reference ) ); |
||
| 155 | $this->assertNotSame( $reference, $references->getReference( $reference->getHash() ) ); |
||
| 156 | } |
||
| 157 | |||
| 158 | public function testAddReferenceOnEmptyList() { |
||
| 159 | $reference = new Reference( array( new PropertyNoValueSnak( 1 ) ) ); |
||
| 160 | |||
| 161 | $references = new ReferenceList(); |
||
| 162 | $references->addReference( $reference ); |
||
| 163 | |||
| 164 | $this->assertCount( 1, $references ); |
||
| 165 | |||
| 166 | $expectedList = new ReferenceList( array( $reference ) ); |
||
| 167 | $this->assertSameReferenceOrder( $expectedList, $references ); |
||
| 168 | } |
||
| 169 | |||
| 170 | private function assertSameReferenceOrder( ReferenceList $expectedList, ReferenceList $references ) { |
||
| 171 | $this->assertEquals( |
||
| 172 | iterator_to_array( $expectedList ), |
||
| 173 | iterator_to_array( $references ) |
||
| 174 | ); |
||
| 175 | } |
||
| 176 | |||
| 177 | public function testAddReferenceOnNonEmptyList() { |
||
| 178 | $reference1 = new Reference( array( new PropertyNoValueSnak( 1 ) ) ); |
||
| 179 | $reference2 = new Reference( array( new PropertyNoValueSnak( 2 ) ) ); |
||
| 180 | $reference3 = new Reference( array( new PropertyNoValueSnak( 3 ) ) ); |
||
| 181 | |||
| 182 | $references = new ReferenceList( array( $reference1, $reference2 ) ); |
||
| 183 | $references->addReference( $reference3 ); |
||
| 184 | |||
| 185 | $this->assertCount( 3, $references ); |
||
| 186 | |||
| 187 | $expectedList = new ReferenceList( array( $reference1, $reference2, $reference3 ) ); |
||
| 188 | $this->assertSameReferenceOrder( $expectedList, $references ); |
||
| 189 | } |
||
| 190 | |||
| 191 | public function testAddReferenceAtIndexZero() { |
||
| 192 | $reference1 = new Reference( array( new PropertyNoValueSnak( 1 ) ) ); |
||
| 193 | $reference2 = new Reference( array( new PropertyNoValueSnak( 2 ) ) ); |
||
| 194 | $reference3 = new Reference( array( new PropertyNoValueSnak( 3 ) ) ); |
||
| 195 | |||
| 196 | $references = new ReferenceList( array( $reference1, $reference2 ) ); |
||
| 197 | $references->addReference( $reference3, 0 ); |
||
| 198 | |||
| 199 | $expectedList = new ReferenceList( array( $reference3, $reference1, $reference2 ) ); |
||
| 200 | $this->assertSameReferenceOrder( $expectedList, $references ); |
||
| 201 | } |
||
| 202 | |||
| 203 | public function testAddReferenceAtNegativeIndex() { |
||
| 204 | $reference = new Reference( array( new PropertyNoValueSnak( 1 ) ) ); |
||
| 205 | $referenceList = new ReferenceList(); |
||
| 206 | |||
| 207 | $this->setExpectedException( 'InvalidArgumentException' ); |
||
|
|
|||
| 208 | $referenceList->addReference( $reference, -1 ); |
||
| 209 | } |
||
| 210 | |||
| 211 | public function testGivenEmptyReference_addReferenceDoesNotAdd() { |
||
| 212 | $reference1 = new Reference( array( new PropertyNoValueSnak( 1 ) ) ); |
||
| 213 | $reference2 = new Reference( array( new PropertyNoValueSnak( 2 ) ) ); |
||
| 214 | $emptyReference = new Reference( array() ); |
||
| 215 | |||
| 216 | $references = new ReferenceList( array( $reference1, $reference2 ) ); |
||
| 217 | $references->addReference( $emptyReference ); |
||
| 218 | |||
| 219 | $expectedList = new ReferenceList( array( $reference1, $reference2 ) ); |
||
| 220 | $this->assertSameReferenceOrder( $expectedList, $references ); |
||
| 221 | } |
||
| 222 | |||
| 223 | public function testGivenEmptyReferenceAndIndex_addReferenceDoesNotAdd() { |
||
| 224 | $reference1 = new Reference( array( new PropertyNoValueSnak( 1 ) ) ); |
||
| 225 | $reference2 = new Reference( array( new PropertyNoValueSnak( 2 ) ) ); |
||
| 226 | $emptyReference = new Reference( array() ); |
||
| 227 | |||
| 228 | $references = new ReferenceList( array( $reference1, $reference2 ) ); |
||
| 229 | $references->addReference( $emptyReference, 0 ); |
||
| 230 | |||
| 231 | $expectedList = new ReferenceList( array( $reference1, $reference2 ) ); |
||
| 232 | $this->assertSameReferenceOrder( $expectedList, $references ); |
||
| 233 | } |
||
| 234 | |||
| 235 | /** |
||
| 236 | * @dataProvider instanceProvider |
||
| 237 | */ |
||
| 238 | public function testIndexOf( ReferenceList $array ) { |
||
| 239 | $this->assertFalse( $array->indexOf( new Reference() ) ); |
||
| 240 | |||
| 241 | $i = 0; |
||
| 242 | foreach ( $array as $reference ) { |
||
| 243 | $this->assertEquals( $i++, $array->indexOf( $reference ) ); |
||
| 244 | } |
||
| 245 | } |
||
| 246 | |||
| 247 | public function testIndexOf_checksForIdentity() { |
||
| 248 | $reference1 = new Reference( array( new PropertyNoValueSnak( 1 ) ) ); |
||
| 249 | $reference2 = new Reference( array( new PropertyNoValueSnak( 1 ) ) ); |
||
| 250 | $referenceList = new ReferenceList( array( $reference1 ) ); |
||
| 251 | |||
| 252 | $this->assertNotSame( $reference1, $reference2, 'post condition' ); |
||
| 253 | $this->assertTrue( $reference1->equals( $reference2 ), 'post condition' ); |
||
| 254 | $this->assertSame( 0, $referenceList->indexOf( $reference1 ), 'identity' ); |
||
| 255 | $this->assertFalse( $referenceList->indexOf( $reference2 ), 'not equality' ); |
||
| 256 | } |
||
| 257 | |||
| 258 | /** |
||
| 259 | * @dataProvider instanceProvider |
||
| 260 | */ |
||
| 261 | public function testEquals( ReferenceList $array ) { |
||
| 262 | $this->assertTrue( $array->equals( $array ) ); |
||
| 263 | $this->assertFalse( $array->equals( 42 ) ); |
||
| 264 | } |
||
| 265 | |||
| 266 | /** |
||
| 267 | * @dataProvider instanceProvider |
||
| 268 | */ |
||
| 269 | public function testGetValueHashReturnsString( ReferenceList $array ) { |
||
| 270 | $this->assertInternalType( 'string', $array->getValueHash() ); |
||
| 271 | } |
||
| 272 | |||
| 273 | /** |
||
| 274 | * @dataProvider instanceProvider |
||
| 275 | */ |
||
| 276 | public function testGetValueHashIsTheSameForClone( ReferenceList $array ) { |
||
| 277 | $copy = unserialize( serialize( $array ) ); |
||
| 278 | $this->assertEquals( $array->getValueHash(), $copy->getValueHash() ); |
||
| 279 | } |
||
| 280 | |||
| 281 | /** |
||
| 282 | * @dataProvider instanceProvider |
||
| 283 | */ |
||
| 284 | public function testHasReferenceHash( ReferenceList $references ) { |
||
| 285 | $this->assertFalse( $references->hasReferenceHash( '~=[,,_,,]:3' ) ); |
||
| 286 | |||
| 287 | /** |
||
| 288 | * @var Hashable $reference |
||
| 289 | */ |
||
| 290 | foreach ( $references as $reference ) { |
||
| 291 | $this->assertTrue( $references->hasReferenceHash( $reference->getHash() ) ); |
||
| 292 | } |
||
| 293 | } |
||
| 294 | |||
| 295 | /** |
||
| 296 | * @dataProvider instanceProvider |
||
| 297 | */ |
||
| 298 | public function testGetReference( ReferenceList $references ) { |
||
| 299 | $this->assertNull( $references->getReference( '~=[,,_,,]:3' ) ); |
||
| 300 | |||
| 301 | /** |
||
| 302 | * @var Reference $reference |
||
| 303 | */ |
||
| 304 | foreach ( $references as $reference ) { |
||
| 305 | $this->assertTrue( $reference->equals( $references->getReference( $reference->getHash() ) ) ); |
||
| 306 | } |
||
| 307 | } |
||
| 308 | |||
| 309 | /** |
||
| 310 | * @dataProvider instanceProvider |
||
| 311 | */ |
||
| 312 | public function testRemoveReferenceHash( ReferenceList $references ) { |
||
| 313 | $references->removeReferenceHash( '~=[,,_,,]:3' ); |
||
| 314 | |||
| 315 | $hashes = array(); |
||
| 316 | |||
| 317 | /** |
||
| 318 | * @var Reference $reference |
||
| 319 | */ |
||
| 320 | foreach ( $references as $reference ) { |
||
| 321 | $hashes[] = $reference->getHash(); |
||
| 322 | } |
||
| 323 | |||
| 324 | foreach ( $hashes as $hash ) { |
||
| 325 | $references->removeReferenceHash( $hash ); |
||
| 326 | } |
||
| 327 | |||
| 328 | $this->assertEquals( 0, count( $references ) ); |
||
| 329 | } |
||
| 330 | |||
| 331 | public function testRemoveReferenceHashRemovesIdenticalObjects() { |
||
| 332 | $reference = new Reference( array( new PropertyNoValueSnak( 1 ) ) ); |
||
| 333 | $references = new ReferenceList( array( $reference, $reference ) ); |
||
| 334 | |||
| 335 | $references->removeReferenceHash( $reference->getHash() ); |
||
| 336 | |||
| 337 | $this->assertTrue( $references->isEmpty() ); |
||
| 338 | } |
||
| 339 | |||
| 340 | public function testRemoveReferenceHashDoesNotRemoveCopies() { |
||
| 341 | $reference = new Reference( array( new PropertyNoValueSnak( 1 ) ) ); |
||
| 342 | $references = new ReferenceList( array( $reference, clone $reference ) ); |
||
| 343 | |||
| 344 | $references->removeReferenceHash( $reference->getHash() ); |
||
| 345 | |||
| 346 | $this->assertFalse( $references->isEmpty() ); |
||
| 347 | $this->assertTrue( $references->hasReference( $reference ) ); |
||
| 348 | $this->assertNotSame( $reference, $references->getReference( $reference->getHash() ) ); |
||
| 349 | } |
||
| 350 | |||
| 351 | public function testRemoveReferenceHashUpdatesIndexes() { |
||
| 352 | $reference1 = new Reference( array( new PropertyNoValueSnak( 1 ) ) ); |
||
| 353 | $reference2 = new Reference( array( new PropertyNoValueSnak( 2 ) ) ); |
||
| 354 | $references = new ReferenceList( array( $reference1, $reference2 ) ); |
||
| 355 | |||
| 356 | $references->removeReferenceHash( $reference1->getHash() ); |
||
| 357 | |||
| 358 | $this->assertSame( 0, $references->indexOf( $reference2 ) ); |
||
| 359 | } |
||
| 360 | |||
| 361 | public function testGivenOneSnak_addNewReferenceAddsSnak() { |
||
| 368 | |||
| 369 | public function testGivenMultipleSnaks_addNewReferenceAddsThem() { |
||
| 380 | |||
| 381 | public function testGivenAnArrayOfSnaks_addNewReferenceAddsThem() { |
||
| 392 | |||
| 393 | public function testGivenNoneSnak_addNewReferenceThrowsException() { |
||
| 399 | |||
| 400 | public function testSerializationStability() { |
||
| 404 | |||
| 405 | public function testSerializeRoundtrip() { |
||
| 418 | |||
| 419 | public function testGivenEmptyList_isEmpty() { |
||
| 423 | |||
| 424 | public function testGivenNonEmptyList_isNotEmpty() { |
||
| 430 | |||
| 431 | } |
||
| 432 |
Loading history...
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.