DiffTest::invalidDiffOpsProvider() - Code Metrics - Inspection of "Merge pull request #63 from wmde/testCaseProviders" - wmde/Diff - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 81f3e7...e6d8eb )

unknown

created 2016-03-11 13:41 UTC

DiffTest::invalidDiffOpsProvider() A

↳ Parent: DiffTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	20
Code Lines	14

Duplication

Lines	0
Ratio	0 %

Importance

Changes	2
Bugs	0	Features	0

Metric	Value
c	2
b	0
f	0
dl	0
loc	20
rs	9.4285
cc	1
eloc	14
nc	1
nop	0

<?php

namespace Diff\Tests\DiffOp\Diff;

use Closure;
use Diff\DiffOp\Diff\Diff;
use Diff\DiffOp\Diff\ListDiff;
use Diff\DiffOp\Diff\MapDiff;
use Diff\DiffOp\DiffOp;
use Diff\DiffOp\DiffOpAdd;
use Diff\DiffOp\DiffOpChange;
use Diff\DiffOp\DiffOpRemove;
use Diff\Tests\DiffTestCase;
use stdClass;

/**
 * @covers Diff\DiffOp\Diff\Diff
 *
 * @group Diff
 * @group DiffOp
 *
 * @licence GNU GPL v2+
 * @author Jeroen De Dauw < [email protected] >
 * @author Thiemo Mättig
 */
class DiffTest extends DiffTestCase {

	public function elementInstancesProvider() {
		return array(
			array( array(
			) ),
			array( array(
				new DiffOpAdd( 'ohi' )
			) ),
			array( array(
				new DiffOpRemove( 'ohi' )
			) ),
			array( array(
				new DiffOpAdd( 'ohi' ),
				new DiffOpRemove( 'there' )
			) ),
			array( array(
			) ),
			array( array(
				new DiffOpAdd( 'ohi' ),
				new DiffOpRemove( 'there' ),
				new DiffOpChange( 'ohi', 'there' )
			) ),
			array( array(
				'1' => new DiffOpAdd( 'ohi' ),
				'33' => new DiffOpRemove( 'there' ),
				'7' => new DiffOpChange( 'ohi', 'there' )
			) ),
		);
	}

	/**
	 * @dataProvider elementInstancesProvider
	 * @param DiffOp[] $operations
	 */
	public function testGetAdditions( array $operations ) {
		$diff = new Diff( $operations, true );

		$additions = array();

		foreach ( $operations as $operation ) {
			if ( $operation->getType() == 'add' ) {
				$additions[] = $operation;
			}
		}

		$this->assertArrayEquals( $additions, $diff->getAdditions() );
	}

	/**
	 * @dataProvider elementInstancesProvider
	 * @param DiffOp[] $operations
	 */
	public function testGetRemovals( array $operations ) {
		$diff = new Diff( $operations, true );

		$removals = array();

		foreach ( $operations as $operation ) {
			if ( $operation->getType() == 'remove' ) {
				$removals[] = $operation;
			}
		}

		$this->assertArrayEquals( $removals, $diff->getRemovals() );
	}

	public function testGetType() {
		$diff = new Diff();
		$this->assertInternalType( 'string', $diff->getType() );
	}

	public function testPreSetElement() {
		$this->setExpectedException( 'Exception' );

		$diff = new Diff( array(), false );
		$diff[] = new DiffOpChange( 0, 1 );
	}

	/**
	 * @dataProvider elementInstancesProvider
	 * @param DiffOp[] $operations
	 */
	public function testAddOperations( array $operations ) {
		$diff = new Diff();

		$diff->addOperations( $operations );

		$this->assertArrayEquals( $operations, $diff->getOperations() );
	}

	/**
	 * @dataProvider elementInstancesProvider
	 * @param DiffOp[] $operations
	 */
	public function testStuff( array $operations ) {
		$diff = new Diff( $operations );

		$this->assertInstanceOf( 'Diff\DiffOp\Diff\Diff', $diff );
		$this->assertInstanceOf( 'ArrayObject', $diff );

		$types = array();

		$this->assertContainsOnlyInstancesOf( 'Diff\DiffOp\DiffOp', $diff );

		/**
		 * @var DiffOp $operation
		 */
		foreach ( $diff as $operation ) {
			if ( !in_array( $operation->getType(), $types ) ) {
				$types[] = $operation->getType();
			}
		}

		$count = 0;

		foreach ( $types as $type ) {
			$count += count( $diff->getTypeOperations( $type ) );
		}

		$this->assertEquals( $count, $diff->count() );
	}

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

		foreach ( $this->elementInstancesProvider() as $args ) {
			$diffOps = $args[0];
			$instances[] = array( new Diff( $diffOps ) );
		}

		return $instances;
	}

	/**
	 * @dataProvider instanceProvider
	 */
	public function testGetOperations( Diff $diff ) {
		$ops = $diff->getOperations();

		$this->assertInternalType( 'array', $ops );
		$this->assertContainsOnlyInstancesOf( 'Diff\DiffOp\DiffOp', $ops );
		$this->assertArrayEquals( $ops, $diff->getOperations() );
	}

	public function testRemoveEmptyOperations() {
		$diff = new Diff( array() );

		$diff['foo'] = new DiffOpAdd( 1 );
		$diff['bar'] = new Diff( array( new DiffOpAdd( 1 ) ), true );
		$diff['baz'] = new Diff( array( new DiffOpAdd( 1 ) ), false );
		$diff['bah'] = new Diff( array(), false );
		$diff['spam'] = new Diff( array(), true );

		$diff->removeEmptyOperations();

		$this->assertTrue( $diff->offsetExists( 'foo' ) );
		$this->assertTrue( $diff->offsetExists( 'bar' ) );
		$this->assertTrue( $diff->offsetExists( 'baz' ) );
		$this->assertFalse( $diff->offsetExists( 'bah' ) );
		$this->assertFalse( $diff->offsetExists( 'spam' ) );
	}

	public function looksAssociativeProvider() {
		$argLists = array();

		$diff = new Diff();

		$argLists[] = array( $diff, false );


		$diff = new Diff( array(), false );

		$argLists[] = array( $diff, false );


		$diff = new Diff( array(), true );

		$argLists[] = array( $diff, true );


		$diff = new Diff( array( new DiffOpAdd( '' ) ) );

		$argLists[] = array( $diff, false );


		$diff = new Diff( array( new DiffOpRemove( '' ) ) );

		$argLists[] = array( $diff, false );


		$diff = new Diff( array( new DiffOpRemove( '' ), new DiffOpAdd( '' ) ) );

		$argLists[] = array( $diff, false );


		$diff = new Diff( array( new DiffOpRemove( '' ) ), true );

		$argLists[] = array( $diff, true );


		$diff = new Diff( array( 'onoez' => new DiffOpChange( '', 'spam' ) ) );

		$argLists[] = array( $diff, true );


		$diff = new Diff( array( new Diff() ) );

		$argLists[] = array( $diff, true );

		return $argLists;
	}

	/**
	 * @dataProvider looksAssociativeProvider
	 */
	public function testLooksAssociative( Diff $diff, $looksAssoc ) {
		$this->assertEquals( $looksAssoc, $diff->looksAssociative() );

		if ( !$diff->looksAssociative() ) {
			$this->assertFalse( $diff->hasAssociativeOperations() );
		}
	}

	public function isAssociativeProvider() {
		$argLists = array();

		$diff = new Diff();

		$argLists[] = array( $diff, null );


		$diff = new Diff( array(), false );

		$argLists[] = array( $diff, false );


		$diff = new Diff( array(), true );

		$argLists[] = array( $diff, true );


		$diff = new Diff( array( new DiffOpAdd( '' ) ) );

		$argLists[] = array( $diff, null );


		$diff = new Diff( array( new DiffOpRemove( '' ) ), false );

		$argLists[] = array( $diff, false );


		$diff = new Diff( array( new DiffOpRemove( '' ), new DiffOpAdd( '' ) ) );

		$argLists[] = array( $diff, null );


		$diff = new Diff( array( new DiffOpRemove( '' ) ), true );

		$argLists[] = array( $diff, true );


		$diff = new Diff( array( 'onoez' => new DiffOpChange( '', 'spam' ) ) );

		$argLists[] = array( $diff, null );


		$diff = new Diff( array( new Diff() ) );

		$argLists[] = array( $diff, null );

		return $argLists;
	}

	/**
	 * @dataProvider isAssociativeProvider
	 */
	public function testIsAssociative( Diff $diff, $isAssoc ) {
		$this->assertEquals( $isAssoc, $diff->isAssociative() );
	}

	public function hasAssociativeOperationsProvider() {
		$argLists = array();

		$diff = new Diff();

		$argLists[] = array( $diff, false );


		$diff = new Diff( array(), false );

		$argLists[] = array( $diff, false );


		$diff = new Diff( array(), true );

		$argLists[] = array( $diff, false );


		$diff = new Diff( array( new DiffOpAdd( '' ) ) );

		$argLists[] = array( $diff, false );


		$diff = new Diff( array( new DiffOpRemove( '' ) ), false );

		$argLists[] = array( $diff, false );


		$diff = new Diff( array( new DiffOpRemove( '' ), new DiffOpAdd( '' ) ), true );

		$argLists[] = array( $diff, false );


		$diff = new Diff( array( new DiffOpRemove( '' ) ), true );

		$argLists[] = array( $diff, false );


		$diff = new Diff( array( 'onoez' => new DiffOpChange( '', 'spam' ) ) );

		$argLists[] = array( $diff, true );


		$diff = new Diff( array( new Diff() ) );

		$argLists[] = array( $diff, true );

		return $argLists;
	}

	/**
	 * @dataProvider hasAssociativeOperationsProvider
	 */
	public function testHasAssociativeOperations( Diff $diff, $hasAssocOps ) {
		$this->assertEquals( $hasAssocOps, $diff->hasAssociativeOperations() );
	}

	public function testSerializationCompat() {
		// @codingStandardsIgnoreStart
		$v03serialization = 'C:12:"Diff\MapDiff":569:{a:4:{s:4:"data";a:4:{i:0;C:14:"Diff\DiffOpAdd":10:{s:3:"add";}i:1;C:17:"Diff\DiffOpRemove":10:{s:3:"rem";}i:2;C:17:"Diff\DiffOpChange":30:{a:2:{i:0;s:1:"b";i:1;s:1:"a";}}i:3;C:13:"Diff\ListDiff":170:{a:4:{s:4:"data";a:1:{i:0;C:17:"Diff\DiffOpRemove":10:{s:3:"rem";}}s:5:"index";i:0;s:12:"typePointers";a:2:{s:3:"add";a:0:{}s:6:"remove";a:1:{i:0;i:0;}}s:9:"parentKey";N;}}}s:5:"index";i:0;s:12:"typePointers";a:6:{s:3:"add";a:1:{i:0;i:0;}s:6:"remove";a:1:{i:0;i:1;}s:6:"change";a:1:{i:0;i:2;}s:4:"list";a:1:{i:0;i:3;}s:3:"map";a:0:{}s:4:"diff";a:0:{}}s:9:"parentKey";N;}}';
		// @codingStandardsIgnoreEnd

		/**
		 * @var Diff $diff
		 */
		$diff = unserialize( $v03serialization );

		$this->assertInstanceOf( 'Diff\Diff', $diff );
		$this->assertTrue( $diff->isAssociative() );
		$this->assertSame( 4, $diff->count() );
		$this->assertSame( 1, count( $diff->getAdditions() ) );
		$this->assertSame( 1, count( $diff->getRemovals() ) );
		$this->assertSame( 1, count( $diff->getChanges() ) );
	}

	/**
	 * @dataProvider elementInstancesProvider
	 *
	 * @since 0.6
	 *
	 * @param DiffOp[] $elements
	 */
	public function testConstructor( array $elements ) {
		$arrayObject = new Diff( $elements );

		$this->assertEquals( count( $elements ), $arrayObject->count() );
	}

	/**
	 * @dataProvider elementInstancesProvider
	 *
	 * @since 0.6
	 *
	 * @param DiffOp[] $elements
	 */
	public function testIsEmpty( array $elements ) {
		$arrayObject = new Diff( $elements );

		$this->assertEquals( $elements === array(), $arrayObject->isEmpty() );
	}

	/**
	 * @dataProvider instanceProvider
	 *
	 * @since 0.6
	 *
	 * @param Diff $list
	 */
	public function testUnset( Diff $list ) {
		if ( $list->isEmpty() ) {
			$this->assertTrue( true ); // We cannot test unset if there are no elements
		} else {
			$offset = $list->getIterator()->key();
			$count = $list->count();
			$list->offsetUnset( $offset );
			$this->assertEquals( $count - 1, $list->count() );
		}

		if ( !$list->isEmpty() ) {
			$offset = $list->getIterator()->key();
			$count = $list->count();
			unset( $list[$offset] );
			$this->assertEquals( $count - 1, $list->count() );
		}
	}

	/**
	 * @dataProvider elementInstancesProvider
	 *
	 * @since 0.6
	 *
	 * @param DiffOp[] $elements
	 */
	public function testAppend( array $elements ) {
		$list = new Diff();

		$listSize = count( $elements );

		foreach ( $elements as $element ) {
			$list->append( $element );
		}

		$this->assertEquals( $listSize, $list->count() );

		$list = new Diff();

		foreach ( $elements as $element ) {
			$list[] = $element;
		}

		$this->assertEquals( $listSize, $list->count() );

		$this->checkTypeChecks( function ( Diff $list, $element ) {
			$list->append( $element );
		} );
	}

	/**
	 * @param Closure $function
	 */
	private function checkTypeChecks( Closure $function ) {
		$excption = null;
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
		$list = new Diff();


		foreach ( array( 42, 'foo', array(), new stdClass(), 4.2 ) as $element ) {
			$this->assertInvalidArgument( $function, $list, $element );
		}
	}

	/**
	 * Asserts that an InvalidArgumentException gets thrown when calling the provided
	 * callable. Extra arguments specified to the method are also provided to the callable.
	 *
	 * @param Closure $function
	 */
	private function assertInvalidArgument( Closure $function ) {
		$this->setExpectedException( 'InvalidArgumentException' );

		$arguments = func_get_args();
		array_shift( $arguments );

		call_user_func_array( $function, $arguments );
	}

	public function testGetAddedValues() {
		$diff = new Diff( array(
			new DiffOpAdd( 0 ),
			new DiffOpRemove( 1 ),
			new DiffOpAdd( 2 ),
			new DiffOpRemove( 3 ),
			new DiffOpAdd( 4 ),
			new DiffOpChange( 7, 5 ),
			new Diff( array( new DiffOpAdd( 9 ) ) ),
		) );

		$addedValues = $diff->getAddedValues();

		$this->assertInternalType( 'array', $addedValues );

		$this->assertArrayEquals( array( 0, 2, 4 ), $addedValues );

		$diff = new Diff();
		$this->assertArrayEquals( array(), $diff->getAddedValues() );
	}

	public function testGetRemovedValues() {
		$diff = new Diff( array(
			new DiffOpAdd( 0 ),
			new DiffOpRemove( 1 ),
			new DiffOpAdd( 2 ),
			new DiffOpRemove( 3 ),
			new DiffOpAdd( 4 ),
			new DiffOpChange( 6, 4 ),
			new Diff( array( new DiffOPRemove( 8 ) ) ),
		) );

		$removedValues = $diff->getRemovedValues();

		$this->assertInternalType( 'array', $removedValues );

		$this->assertArrayEquals( array( 1, 3 ), $removedValues );

		$diff = new Diff();
		$this->assertArrayEquals( array(), $diff->getRemovedValues() );
	}

	/**
	 * @dataProvider elementInstancesProvider
	 *
	 * @since 0.6
	 *
	 * @param DiffOp[] $elements
	 */
	public function testOffsetSet( array $elements ) {
		if ( $elements === array() ) {
			$this->assertTrue( true );
			return;
		}

		$list = new Diff();

		$element = reset( $elements );
		$list->offsetSet( 42, $element );
		$this->assertEquals( $element, $list->offsetGet( 42 ) );

		$list = new Diff();

		$element = reset( $elements );
		$list['oHai'] = $element;
		$this->assertEquals( $element, $list['oHai'] );

		$list = new Diff();

		$element = reset( $elements );
		$list->offsetSet( 9001, $element );
		$this->assertEquals( $element, $list[9001] );

		$list = new Diff();

		$element = reset( $elements );
		$list->offsetSet( null, $element );
		$this->assertEquals( $element, $list[0] );

		$list = new Diff();
		$offset = 0;

		foreach ( $elements as $element ) {
			$list->offsetSet( null, $element );
			$this->assertEquals( $element, $list[$offset++] );
		}

		$this->assertEquals( count( $elements ), $list->count() );

		$this->checkTypeChecks( function ( Diff $list, $element ) {
			$list->offsetSet( mt_rand(), $element );
		} );
	}

	/**
	 * @dataProvider instanceProvider
	 *
	 * @since 0.6
	 *
	 * @param Diff $list
	 */
	public function testSerialization( Diff $list ) {
		$serialization = serialize( $list );
		$copy = unserialize( $serialization );

		$this->assertSame( $serialization, serialize( $copy ) );
		$this->assertSame( $list->count(), $copy->count() );

		$list = $list->getArrayCopy();
		$copy = $copy->getArrayCopy();

		$this->assertArrayEquals( $list, $copy, true, true );
	}

	/**
	 * @dataProvider instanceProvider
	 *
	 * @since 0.6
	 *
	 * @param Diff $list
	 */
	public function testAddInvalidDiffOp( Diff $list ) {
		$invalidDiffOp = $this->getMock( 'Diff\DiffOp\DiffOp' );

		$invalidDiffOp->expects( $this->atLeastOnce() )
			->method( 'getType' )
			->will( $this->returnValue( '~=[,,_,,]:3' ) );

		$this->setExpectedException( 'Exception' );

		$list->append( $invalidDiffOp );
	}

	/**
	 * @dataProvider invalidIsAssociativeProvider
	 */
	public function testConstructWithInvalidIsAssociative( $isAssociative ) {
		$this->setExpectedException( 'InvalidArgumentException' );
		new Diff( array(), $isAssociative );
	}

	public function invalidIsAssociativeProvider() {
		return array(
			array( 1 ),
			array( '1' ),
			array( 'null' ),
			array( 0 ),
			array( array() ),
			array( 'foobar' ),
		);
	}

	/**
	 * @dataProvider invalidDiffOpsProvider
	 */
	public function testConstructorWithInvalidDiffOps( array $diffOps ) {
		$this->setExpectedException( 'InvalidArgumentException' );
		new Diff( $diffOps );
	}

	public function invalidDiffOpsProvider() {
		return array(
			array( array(
				'foo',
			) ),
			array( array(
				null,
			) ),
			array( array(
				false,
				true,
				array(),
			) ),
			array( array(
				new DiffOpAdd( 42 ),
				'in your list',
				new DiffOpAdd( 9001 ),
			) )
		);
	}

	/**
	 * @dataProvider equalsProvider
	 */
	public function testEquals( Diff $diff, Diff $target ) {
		$this->assertTrue( $diff->equals( $target ) );
		$this->assertTrue( $target->equals( $diff ) );
	}

	public function equalsProvider() {
		return array(
			// Empty diffs
			array( new Diff(), new Diff() ),
			array( new Diff(), new Diff( array(), null ) ),

			// Simple diffs
			array( new Diff( array( new DiffOpAdd( 1 ) ) ), new Diff( array( new DiffOpAdd( 1 ) ) ) ),
			array( new Diff( array( new DiffOpAdd( 1 ) ) ), new Diff( array( new DiffOpAdd( '1' ) ) ) ),

			// Subclasses that are shortcuts and should be equal
			array( new Diff( array(), false ), new ListDiff() ),

			array( new Diff( array(), true ), new MapDiff() ),

		);
	}

	/**
	 * @dataProvider notEqualsProvider
	 */
	public function testNotEquals( Diff $diff, Diff $target ) {
		$this->assertFalse( $diff->equals( $target ) );
		$this->assertFalse( $target->equals( $diff ) );
	}

	public function notEqualsProvider() {
		return array(
			// Empty diffs
			array( new Diff(), new Diff( array(), false ) ),
			array( new Diff(), new Diff( array(), true ) ),

			// Simple diffs
			array( new Diff(), new Diff( array( new DiffOpAdd( 1 ) ) ) ),
			array( new Diff( array( new DiffOpAdd( 1 ) ) ), new Diff( array( new DiffOpRemove( 1 ) ) ) ),
			array( new Diff( array( new DiffOpAdd( 1 ) ) ), new Diff( array( new DiffOpAdd( 2 ) ) ) ),
		);
	}

}


1			<?php
2
3			namespace Diff\Tests\DiffOp\Diff;
4
5			use Closure;
6			use Diff\DiffOp\Diff\Diff;
7			use Diff\DiffOp\Diff\ListDiff;
8			use Diff\DiffOp\Diff\MapDiff;
9			use Diff\DiffOp\DiffOp;
10			use Diff\DiffOp\DiffOpAdd;
11			use Diff\DiffOp\DiffOpChange;
12			use Diff\DiffOp\DiffOpRemove;
13			use Diff\Tests\DiffTestCase;
14			use stdClass;
15
16			/**
17			* @covers Diff\DiffOp\Diff\Diff
18			*
19			* @group Diff
20			* @group DiffOp
21			*
22			* @licence GNU GPL v2+
23			* @author Jeroen De Dauw < [email protected] >
24			* @author Thiemo Mättig
25			*/
26			class DiffTest extends DiffTestCase {
27
28			public function elementInstancesProvider() {
29			return array(
30			array( array(
31			) ),
32			array( array(
33			new DiffOpAdd( 'ohi' )
34			) ),
35			array( array(
36			new DiffOpRemove( 'ohi' )
37			) ),
38			array( array(
39			new DiffOpAdd( 'ohi' ),
40			new DiffOpRemove( 'there' )
41			) ),
42			array( array(
43			) ),
44			array( array(
45			new DiffOpAdd( 'ohi' ),
46			new DiffOpRemove( 'there' ),
47			new DiffOpChange( 'ohi', 'there' )
48			) ),
49			array( array(
50			'1' => new DiffOpAdd( 'ohi' ),
51			'33' => new DiffOpRemove( 'there' ),
52			'7' => new DiffOpChange( 'ohi', 'there' )
53			) ),
54			);
55			}
56
57			/**
58			* @dataProvider elementInstancesProvider
59			* @param DiffOp[] $operations
60			*/
61			public function testGetAdditions( array $operations ) {
62			$diff = new Diff( $operations, true );
63
64			$additions = array();
65
66			foreach ( $operations as $operation ) {
67			if ( $operation->getType() == 'add' ) {
68			$additions[] = $operation;
69			}
70			}
71
72			$this->assertArrayEquals( $additions, $diff->getAdditions() );
73			}
74
75			/**
76			* @dataProvider elementInstancesProvider
77			* @param DiffOp[] $operations
78			*/
79			public function testGetRemovals( array $operations ) {
80			$diff = new Diff( $operations, true );
81
82			$removals = array();
83
84			foreach ( $operations as $operation ) {
85			if ( $operation->getType() == 'remove' ) {
86			$removals[] = $operation;
87			}
88			}
89
90			$this->assertArrayEquals( $removals, $diff->getRemovals() );
91			}
92
93			public function testGetType() {
94			$diff = new Diff();
95			$this->assertInternalType( 'string', $diff->getType() );
96			}
97
98			public function testPreSetElement() {
99			$this->setExpectedException( 'Exception' );
100
101			$diff = new Diff( array(), false );
102			$diff[] = new DiffOpChange( 0, 1 );
103			}
104
105			/**
106			* @dataProvider elementInstancesProvider
107			* @param DiffOp[] $operations
108			*/
109			public function testAddOperations( array $operations ) {
110			$diff = new Diff();
111
112			$diff->addOperations( $operations );
113
114			$this->assertArrayEquals( $operations, $diff->getOperations() );
115			}
116
117			/**
118			* @dataProvider elementInstancesProvider
119			* @param DiffOp[] $operations
120			*/
121			public function testStuff( array $operations ) {
122			$diff = new Diff( $operations );
123
124			$this->assertInstanceOf( 'Diff\DiffOp\Diff\Diff', $diff );
125			$this->assertInstanceOf( 'ArrayObject', $diff );
126
127			$types = array();
128
129			$this->assertContainsOnlyInstancesOf( 'Diff\DiffOp\DiffOp', $diff );
130
131			/**
132			* @var DiffOp $operation
133			*/
134			foreach ( $diff as $operation ) {
135			if ( !in_array( $operation->getType(), $types ) ) {
136			$types[] = $operation->getType();
137			}
138			}
139
140			$count = 0;
141
142			foreach ( $types as $type ) {
143			$count += count( $diff->getTypeOperations( $type ) );
144			}
145
146			$this->assertEquals( $count, $diff->count() );
147			}
148
149			public function instanceProvider() {
150			$instances = array();
151
152			foreach ( $this->elementInstancesProvider() as $args ) {
153			$diffOps = $args[0];
154			$instances[] = array( new Diff( $diffOps ) );
155			}
156
157			return $instances;
158			}
159
160			/**
161			* @dataProvider instanceProvider
162			*/
163			public function testGetOperations( Diff $diff ) {
164			$ops = $diff->getOperations();
165
166			$this->assertInternalType( 'array', $ops );
167			$this->assertContainsOnlyInstancesOf( 'Diff\DiffOp\DiffOp', $ops );
168			$this->assertArrayEquals( $ops, $diff->getOperations() );
169			}
170
171			public function testRemoveEmptyOperations() {
172			$diff = new Diff( array() );
173
174			$diff['foo'] = new DiffOpAdd( 1 );
175			$diff['bar'] = new Diff( array( new DiffOpAdd( 1 ) ), true );
176			$diff['baz'] = new Diff( array( new DiffOpAdd( 1 ) ), false );
177			$diff['bah'] = new Diff( array(), false );
178			$diff['spam'] = new Diff( array(), true );
179
180			$diff->removeEmptyOperations();
181
182			$this->assertTrue( $diff->offsetExists( 'foo' ) );
183			$this->assertTrue( $diff->offsetExists( 'bar' ) );
184			$this->assertTrue( $diff->offsetExists( 'baz' ) );
185			$this->assertFalse( $diff->offsetExists( 'bah' ) );
186			$this->assertFalse( $diff->offsetExists( 'spam' ) );
187			}
188
189			public function looksAssociativeProvider() {
190			$argLists = array();
191
192			$diff = new Diff();
193
194			$argLists[] = array( $diff, false );
195
196
197			$diff = new Diff( array(), false );
198
199			$argLists[] = array( $diff, false );
200
201
202			$diff = new Diff( array(), true );
203
204			$argLists[] = array( $diff, true );
205
206
207			$diff = new Diff( array( new DiffOpAdd( '' ) ) );
208
209			$argLists[] = array( $diff, false );
210
211
212			$diff = new Diff( array( new DiffOpRemove( '' ) ) );
213
214			$argLists[] = array( $diff, false );
215
216
217			$diff = new Diff( array( new DiffOpRemove( '' ), new DiffOpAdd( '' ) ) );
218
219			$argLists[] = array( $diff, false );
220
221
222			$diff = new Diff( array( new DiffOpRemove( '' ) ), true );
223
224			$argLists[] = array( $diff, true );
225
226
227			$diff = new Diff( array( 'onoez' => new DiffOpChange( '', 'spam' ) ) );
228
229			$argLists[] = array( $diff, true );
230
231
232			$diff = new Diff( array( new Diff() ) );
233
234			$argLists[] = array( $diff, true );
235
236			return $argLists;
237			}
238
239			/**
240			* @dataProvider looksAssociativeProvider
241			*/
242			public function testLooksAssociative( Diff $diff, $looksAssoc ) {
243			$this->assertEquals( $looksAssoc, $diff->looksAssociative() );
244
245			if ( !$diff->looksAssociative() ) {
246			$this->assertFalse( $diff->hasAssociativeOperations() );
247			}
248			}
249
250			public function isAssociativeProvider() {
251			$argLists = array();
252
253			$diff = new Diff();
254
255			$argLists[] = array( $diff, null );
256
257
258			$diff = new Diff( array(), false );
259
260			$argLists[] = array( $diff, false );
261
262
263			$diff = new Diff( array(), true );
264
265			$argLists[] = array( $diff, true );
266
267
268			$diff = new Diff( array( new DiffOpAdd( '' ) ) );
269
270			$argLists[] = array( $diff, null );
271
272
273			$diff = new Diff( array( new DiffOpRemove( '' ) ), false );
274
275			$argLists[] = array( $diff, false );
276
277
278			$diff = new Diff( array( new DiffOpRemove( '' ), new DiffOpAdd( '' ) ) );
279
280			$argLists[] = array( $diff, null );
281
282
283			$diff = new Diff( array( new DiffOpRemove( '' ) ), true );
284
285			$argLists[] = array( $diff, true );
286
287
288			$diff = new Diff( array( 'onoez' => new DiffOpChange( '', 'spam' ) ) );
289
290			$argLists[] = array( $diff, null );
291
292
293			$diff = new Diff( array( new Diff() ) );
294
295			$argLists[] = array( $diff, null );
296
297			return $argLists;
298			}
299
300			/**
301			* @dataProvider isAssociativeProvider
302			*/
303			public function testIsAssociative( Diff $diff, $isAssoc ) {
304			$this->assertEquals( $isAssoc, $diff->isAssociative() );
305			}
306
307			public function hasAssociativeOperationsProvider() {
308			$argLists = array();
309
310			$diff = new Diff();
311
312			$argLists[] = array( $diff, false );
313
314
315			$diff = new Diff( array(), false );
316
317			$argLists[] = array( $diff, false );
318
319
320			$diff = new Diff( array(), true );
321
322			$argLists[] = array( $diff, false );
323
324
325			$diff = new Diff( array( new DiffOpAdd( '' ) ) );
326
327			$argLists[] = array( $diff, false );
328
329
330			$diff = new Diff( array( new DiffOpRemove( '' ) ), false );
331
332			$argLists[] = array( $diff, false );
333
334
335			$diff = new Diff( array( new DiffOpRemove( '' ), new DiffOpAdd( '' ) ), true );
336
337			$argLists[] = array( $diff, false );
338
339
340			$diff = new Diff( array( new DiffOpRemove( '' ) ), true );
341
342			$argLists[] = array( $diff, false );
343
344
345			$diff = new Diff( array( 'onoez' => new DiffOpChange( '', 'spam' ) ) );
346
347			$argLists[] = array( $diff, true );
348
349
350			$diff = new Diff( array( new Diff() ) );
351
352			$argLists[] = array( $diff, true );
353
354			return $argLists;
355			}
356
357			/**
358			* @dataProvider hasAssociativeOperationsProvider
359			*/
360			public function testHasAssociativeOperations( Diff $diff, $hasAssocOps ) {
361			$this->assertEquals( $hasAssocOps, $diff->hasAssociativeOperations() );
362			}
363
364			public function testSerializationCompat() {
365			// @codingStandardsIgnoreStart
366			$v03serialization = 'C:12:"Diff\MapDiff":569:{a:4:{s:4:"data";a:4:{i:0;C:14:"Diff\DiffOpAdd":10:{s:3:"add";}i:1;C:17:"Diff\DiffOpRemove":10:{s:3:"rem";}i:2;C:17:"Diff\DiffOpChange":30:{a:2:{i:0;s:1:"b";i:1;s:1:"a";}}i:3;C:13:"Diff\ListDiff":170:{a:4:{s:4:"data";a:1:{i:0;C:17:"Diff\DiffOpRemove":10:{s:3:"rem";}}s:5:"index";i:0;s:12:"typePointers";a:2:{s:3:"add";a:0:{}s:6:"remove";a:1:{i:0;i:0;}}s:9:"parentKey";N;}}}s:5:"index";i:0;s:12:"typePointers";a:6:{s:3:"add";a:1:{i:0;i:0;}s:6:"remove";a:1:{i:0;i:1;}s:6:"change";a:1:{i:0;i:2;}s:4:"list";a:1:{i:0;i:3;}s:3:"map";a:0:{}s:4:"diff";a:0:{}}s:9:"parentKey";N;}}';
367			// @codingStandardsIgnoreEnd
368
369			/**
370			* @var Diff $diff
371			*/
372			$diff = unserialize( $v03serialization );
373
374			$this->assertInstanceOf( 'Diff\Diff', $diff );
375			$this->assertTrue( $diff->isAssociative() );
376			$this->assertSame( 4, $diff->count() );
377			$this->assertSame( 1, count( $diff->getAdditions() ) );
378			$this->assertSame( 1, count( $diff->getRemovals() ) );
379			$this->assertSame( 1, count( $diff->getChanges() ) );
380			}
381
382			/**
383			* @dataProvider elementInstancesProvider
384			*
385			* @since 0.6
386			*
387			* @param DiffOp[] $elements
388			*/
389			public function testConstructor( array $elements ) {
390			$arrayObject = new Diff( $elements );
391
392			$this->assertEquals( count( $elements ), $arrayObject->count() );
393			}
394
395			/**
396			* @dataProvider elementInstancesProvider
397			*
398			* @since 0.6
399			*
400			* @param DiffOp[] $elements
401			*/
402			public function testIsEmpty( array $elements ) {
403			$arrayObject = new Diff( $elements );
404
405			$this->assertEquals( $elements === array(), $arrayObject->isEmpty() );
406			}
407
408			/**
409			* @dataProvider instanceProvider
410			*
411			* @since 0.6
412			*
413			* @param Diff $list
414			*/
415			public function testUnset( Diff $list ) {
416			if ( $list->isEmpty() ) {
417			$this->assertTrue( true ); // We cannot test unset if there are no elements
418			} else {
419			$offset = $list->getIterator()->key();
420			$count = $list->count();
421			$list->offsetUnset( $offset );
422			$this->assertEquals( $count - 1, $list->count() );
423			}
424
425			if ( !$list->isEmpty() ) {
426			$offset = $list->getIterator()->key();
427			$count = $list->count();
428			unset( $list[$offset] );
429			$this->assertEquals( $count - 1, $list->count() );
430			}
431			}
432
433			/**
434			* @dataProvider elementInstancesProvider
435			*
436			* @since 0.6
437			*
438			* @param DiffOp[] $elements
439			*/
440			public function testAppend( array $elements ) {
441			$list = new Diff();
442
443			$listSize = count( $elements );
444
445			foreach ( $elements as $element ) {
446			$list->append( $element );
447			}
448
449			$this->assertEquals( $listSize, $list->count() );
450
451			$list = new Diff();
452
453			foreach ( $elements as $element ) {
454			$list[] = $element;
455			}
456
457			$this->assertEquals( $listSize, $list->count() );
458
459			$this->checkTypeChecks( function ( Diff $list, $element ) {
460			$list->append( $element );
461			} );
462			}
463
464			/**
465			* @param Closure $function
466			*/
467			private function checkTypeChecks( Closure $function ) {
468			$excption = null;
			0 ignored issues – show Unused Code introduced 2015-12-28 16:16 UTC by Report Bug Copy Issue Report `$excption` is not used, you could remove the assignment. This check looks for variable assignements that are either overwritten by other assignments or where the variable is not used subsequently. $myVar = 'Value'; $higher = false; if (rand(1, 6) > 3) { $higher = true; } else { $higher = false; } Both the `$myVar` assignment in line 1 and the `$higher` assignment in line 2 are dead. The first because `$myVar` is never used and the second because `$higher` is always overwritten for every possible time line. Loading history...
469			$list = new Diff();
470
471
472			foreach ( array( 42, 'foo', array(), new stdClass(), 4.2 ) as $element ) {
473			$this->assertInvalidArgument( $function, $list, $element );
474			}
475			}
476
477			/**
478			* Asserts that an InvalidArgumentException gets thrown when calling the provided
479			* callable. Extra arguments specified to the method are also provided to the callable.
480			*
481			* @param Closure $function
482			*/
483			private function assertInvalidArgument( Closure $function ) {
484			$this->setExpectedException( 'InvalidArgumentException' );
485
486			$arguments = func_get_args();
487			array_shift( $arguments );
488
489			call_user_func_array( $function, $arguments );
490			}
491
492			public function testGetAddedValues() {
493			$diff = new Diff( array(
494			new DiffOpAdd( 0 ),
495			new DiffOpRemove( 1 ),
496			new DiffOpAdd( 2 ),
497			new DiffOpRemove( 3 ),
498			new DiffOpAdd( 4 ),
499			new DiffOpChange( 7, 5 ),
500			new Diff( array( new DiffOpAdd( 9 ) ) ),
501			) );
502
503			$addedValues = $diff->getAddedValues();
504
505			$this->assertInternalType( 'array', $addedValues );
506
507			$this->assertArrayEquals( array( 0, 2, 4 ), $addedValues );
508
509			$diff = new Diff();
510			$this->assertArrayEquals( array(), $diff->getAddedValues() );
511			}
512
513			public function testGetRemovedValues() {
514			$diff = new Diff( array(
515			new DiffOpAdd( 0 ),
516			new DiffOpRemove( 1 ),
517			new DiffOpAdd( 2 ),
518			new DiffOpRemove( 3 ),
519			new DiffOpAdd( 4 ),
520			new DiffOpChange( 6, 4 ),
521			new Diff( array( new DiffOPRemove( 8 ) ) ),
522			) );
523
524			$removedValues = $diff->getRemovedValues();
525
526			$this->assertInternalType( 'array', $removedValues );
527
528			$this->assertArrayEquals( array( 1, 3 ), $removedValues );
529
530			$diff = new Diff();
531			$this->assertArrayEquals( array(), $diff->getRemovedValues() );
532			}
533
534			/**
535			* @dataProvider elementInstancesProvider
536			*
537			* @since 0.6
538			*
539			* @param DiffOp[] $elements
540			*/
541			public function testOffsetSet( array $elements ) {
542			if ( $elements === array() ) {
543			$this->assertTrue( true );
544			return;
545			}
546
547			$list = new Diff();
548
549			$element = reset( $elements );
550			$list->offsetSet( 42, $element );
551			$this->assertEquals( $element, $list->offsetGet( 42 ) );
552
553			$list = new Diff();
554
555			$element = reset( $elements );
556			$list['oHai'] = $element;
557			$this->assertEquals( $element, $list['oHai'] );
558
559			$list = new Diff();
560
561			$element = reset( $elements );
562			$list->offsetSet( 9001, $element );
563			$this->assertEquals( $element, $list[9001] );
564
565			$list = new Diff();
566
567			$element = reset( $elements );
568			$list->offsetSet( null, $element );
569			$this->assertEquals( $element, $list[0] );
570
571			$list = new Diff();
572			$offset = 0;
573
574			foreach ( $elements as $element ) {
575			$list->offsetSet( null, $element );
576			$this->assertEquals( $element, $list[$offset++] );
577			}
578
579			$this->assertEquals( count( $elements ), $list->count() );
580
581			$this->checkTypeChecks( function ( Diff $list, $element ) {
582			$list->offsetSet( mt_rand(), $element );
583			} );
584			}
585
586			/**
587			* @dataProvider instanceProvider
588			*
589			* @since 0.6
590			*
591			* @param Diff $list
592			*/
593			public function testSerialization( Diff $list ) {
594			$serialization = serialize( $list );
595			$copy = unserialize( $serialization );
596
597			$this->assertSame( $serialization, serialize( $copy ) );
598			$this->assertSame( $list->count(), $copy->count() );
599
600			$list = $list->getArrayCopy();
601			$copy = $copy->getArrayCopy();
602
603			$this->assertArrayEquals( $list, $copy, true, true );
604			}
605
606			/**
607			* @dataProvider instanceProvider
608			*
609			* @since 0.6
610			*
611			* @param Diff $list
612			*/
613			public function testAddInvalidDiffOp( Diff $list ) {
614			$invalidDiffOp = $this->getMock( 'Diff\DiffOp\DiffOp' );
615
616			$invalidDiffOp->expects( $this->atLeastOnce() )
617			->method( 'getType' )
618			->will( $this->returnValue( '~=[,,_,,]:3' ) );
619
620			$this->setExpectedException( 'Exception' );
621
622			$list->append( $invalidDiffOp );
623			}
624
625			/**
626			* @dataProvider invalidIsAssociativeProvider
627			*/
628			public function testConstructWithInvalidIsAssociative( $isAssociative ) {
629			$this->setExpectedException( 'InvalidArgumentException' );
630			new Diff( array(), $isAssociative );
631			}
632
633			public function invalidIsAssociativeProvider() {
634			return array(
635			array( 1 ),
636			array( '1' ),
637			array( 'null' ),
638			array( 0 ),
639			array( array() ),
640			array( 'foobar' ),
641			);
642			}
643
644			/**
645			* @dataProvider invalidDiffOpsProvider
646			*/
647			public function testConstructorWithInvalidDiffOps( array $diffOps ) {
648			$this->setExpectedException( 'InvalidArgumentException' );
649			new Diff( $diffOps );
650			}
651
652			public function invalidDiffOpsProvider() {
653			return array(
654			array( array(
655			'foo',
656			) ),
657			array( array(
658			null,
659			) ),
660			array( array(
661			false,
662			true,
663			array(),
664			) ),
665			array( array(
666			new DiffOpAdd( 42 ),
667			'in your list',
668			new DiffOpAdd( 9001 ),
669			) )
670			);
671			}
672
673			/**
674			* @dataProvider equalsProvider
675			*/
676			public function testEquals( Diff $diff, Diff $target ) {
677			$this->assertTrue( $diff->equals( $target ) );
678			$this->assertTrue( $target->equals( $diff ) );
679			}
680
681			public function equalsProvider() {
682			return array(
683			// Empty diffs
684			array( new Diff(), new Diff() ),
685			array( new Diff(), new Diff( array(), null ) ),
686
687			// Simple diffs
688			array( new Diff( array( new DiffOpAdd( 1 ) ) ), new Diff( array( new DiffOpAdd( 1 ) ) ) ),
689			array( new Diff( array( new DiffOpAdd( 1 ) ) ), new Diff( array( new DiffOpAdd( '1' ) ) ) ),
690
691			// Subclasses that are shortcuts and should be equal
692			array( new Diff( array(), false ), new ListDiff() ),
			0 ignored issues – show Deprecated Code introduced 2015-12-28 16:16 UTC by Report Bug Copy Issue Report The class `Diff\DiffOp\Diff\ListDiff` has been deprecated with message: since 0.5, just use Diff instead This class, trait or interface has been deprecated. The supplier of the file has supplied an explanatory message. The explanatory message should give you some clue as to whether and when the type will be removed from the class and what other constant to use instead. Loading history...
693			array( new Diff( array(), true ), new MapDiff() ),
			0 ignored issues – show Deprecated Code introduced 2015-12-28 16:16 UTC by Report Bug Copy Issue Report The class `Diff\DiffOp\Diff\MapDiff` has been deprecated with message: since 0.5, just use Diff instead This class, trait or interface has been deprecated. The supplier of the file has supplied an explanatory message. The explanatory message should give you some clue as to whether and when the type will be removed from the class and what other constant to use instead. Loading history...
694			);
695			}
696
697			/**
698			* @dataProvider notEqualsProvider
699			*/
700			public function testNotEquals( Diff $diff, Diff $target ) {
701			$this->assertFalse( $diff->equals( $target ) );
702			$this->assertFalse( $target->equals( $diff ) );
703			}
704
705			public function notEqualsProvider() {
706			return array(
707			// Empty diffs
708			array( new Diff(), new Diff( array(), false ) ),
709			array( new Diff(), new Diff( array(), true ) ),
710
711			// Simple diffs
712			array( new Diff(), new Diff( array( new DiffOpAdd( 1 ) ) ) ),
713			array( new Diff( array( new DiffOpAdd( 1 ) ) ), new Diff( array( new DiffOpRemove( 1 ) ) ) ),
714			array( new Diff( array( new DiffOpAdd( 1 ) ) ), new Diff( array( new DiffOpAdd( 2 ) ) ) ),
715			);
716			}
717
718			}
719

wmde / Diff

Push — master ( 81f3e7...e6d8eb )

DiffTest::invalidDiffOpsProvider() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like