UnboundedQuantityValueTest::transformProvider() - Code Metrics - Inspection of "Merge pull request #84 from DataValues/assertSame" - DataValues/Number - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 5763d0...f2497e )

unknown

created 2016-08-01 08:49 UTC

UnboundedQuantityValueTest::transformProvider() A

↳ Parent: UnboundedQuantityValueTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	57
Code Lines	40

Duplication

Lines	0
Ratio	0 %

Importance

Changes	2
Bugs	1	Features	1

Metric	Value
c	2
b	1
f	1
dl	0
loc	57
rs	9.6818
cc	1
eloc	40
nc	1
nop	0

How to fix Long Method

<?php

namespace DataValues\Tests;

use DataValues\DecimalValue;
use DataValues\UnboundedQuantityValue;

/**
 * @covers DataValues\UnboundedQuantityValue
 *
 * @group DataValue
 * @group DataValueExtensions
 *
 * @license GPL-2.0+
 * @author Daniel Kinzler
 */
class UnboundedQuantityValueTest extends DataValueTest {

	/**
	 * @see DataValueTest::getClass
	 *
	 * @return string
	 */
	public function getClass() {
		return 'DataValues\UnboundedQuantityValue';
	}

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

		$argLists[] = array( new DecimalValue( '+42' ), '1' );
		$argLists[] = array( new DecimalValue( '+0.01' ), '1' );
		$argLists[] = array( new DecimalValue( '-0.5' ), '1' );

		return $argLists;
	}

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

		$argLists[] = array( new DecimalValue( '+0' ), '' );
		$argLists[] = array( new DecimalValue( '+0' ), 1 );

		return $argLists;
	}

	/**
	 * @dataProvider instanceProvider
	 */
	public function testGetValue( UnboundedQuantityValue $quantity, array $arguments ) {
		$this->assertSame( $quantity, $quantity->getValue() );
	}

	/**
	 * @dataProvider instanceProvider
	 */
	public function testGetAmount( UnboundedQuantityValue $quantity, array $arguments ) {
		$this->assertSame( $arguments[0], $quantity->getAmount() );
	}

	/**
	 * @dataProvider instanceProvider
	 */
	public function testGetUnit( UnboundedQuantityValue $quantity, array $arguments ) {
		$this->assertSame( $arguments[1], $quantity->getUnit() );
	}

	/**
	 * @dataProvider newFromNumberProvider
	 */
	public function testNewFromNumber( $amount, $unit, UnboundedQuantityValue $expected ) {
		$quantity = UnboundedQuantityValue::newFromNumber( $amount, $unit );

		$this->assertEquals( $expected->getAmount()->getValue(), $quantity->getAmount()->getValue() );
	}

	public function newFromNumberProvider() {
		return array(
			array(
				42, '1',
				new UnboundedQuantityValue( new DecimalValue( '+42' ), '1' )
			),
			array(
				-0.05, '1',
				new UnboundedQuantityValue( new DecimalValue( '-0.05' ), '1' )
			),
			array(
				0, 'm',
				new UnboundedQuantityValue( new DecimalValue( '+0' ), 'm' )
			),
			array(
				'+23', '1',
				new UnboundedQuantityValue( new DecimalValue( '+23' ), '1' )
			),
			array(
				'+42', '1',
				new UnboundedQuantityValue( new DecimalValue( '+42' ), '1' )
			),
			array(
				'-0.05', 'm',
				new UnboundedQuantityValue( new DecimalValue( '-0.05' ), 'm' )
			),
			array(
				new DecimalValue( '+42' ), '1',
				new UnboundedQuantityValue( new DecimalValue( '+42' ), '1' )
			),
		);
	}

	/**
	 * @dataProvider validArraySerializationProvider
	 */
	public function testNewFromArray( $data, UnboundedQuantityValue $expected ) {
		$value = UnboundedQuantityValue::newFromArray( $data );
		$this->assertTrue( $expected->equals( $value ), $value . ' should equal ' . $expected );
	}

	public function validArraySerializationProvider() {
		return array(
			'unbounded' => array(
				array(
					'amount' => '+2',
					'unit' => '1',
				),
				UnboundedQuantityValue::newFromNumber( '+2', '1' )
			),
			'with-extra' => array(
				array(
					'amount' => '+2',
					'unit' => '1',
					'upperBound' => '+2.5',
					'lowerBound' => '+1.5',
				),
				UnboundedQuantityValue::newFromNumber( '+2', '1' )
			),
		);
	}

	/**
	 * @dataProvider invalidArraySerializationProvider
	 */
	public function testNewFromArray_failure( $data ) {
		$this->setExpectedException( 'DataValues\IllegalValueException' );
		UnboundedQuantityValue::newFromArray( $data );
	}

	public function invalidArraySerializationProvider() {
		return array(
			'no-amount' => array(
				array(
					'unit' => '1',
				)
			),
			'no-unit' => array(
				array(
					'amount' => '+2',
				)
			),
			'bad-amount' => array(
				array(
					'amount' => 'x',
					'unit' => '1',
				)
			),
		);
	}

	/**
	 * @see https://phabricator.wikimedia.org/T110728
	 * @see http://www.regular-expressions.info/anchors.html#realend
	 */
	public function testTrailingNewlineRobustness() {
		$value = UnboundedQuantityValue::newFromArray( array(
			'amount' => "-0.0\n",
			'unit' => "1\n",
		) );

		$this->assertSame( array(
			'amount' => '+0.0',
			'unit' => "1\n",
		), $value->getArrayValue() );
	}

	/**
	 * @dataProvider instanceProvider
	 */
	public function testGetSortKey( UnboundedQuantityValue $quantity ) {
		$this->assertSame( $quantity->getAmount()->getValueFloat(), $quantity->getSortKey() );
	}

	/**
	 * @dataProvider transformProvider
	 */
	public function testTransform( UnboundedQuantityValue $quantity, $transformation, UnboundedQuantityValue $expected ) {
		$args = func_get_args();
		$extraArgs = array_slice( $args, 3 );

		$call = array( $quantity, 'transform' );
		$callArgs = array_merge( array( 'x', $transformation ), $extraArgs );
		$actual = call_user_func_array( $call, $callArgs );

		$this->assertSame( 'x', $actual->getUnit() );
		$this->assertEquals( $expected->getAmount()->getValue(), $actual->getAmount()->getValue(), 'value' );
	}

	public function transformProvider() {
		$identity = function ( DecimalValue $value ) {
			return $value;
		};

		$square = function ( DecimalValue $value ) {
			$v = $value->getValueFloat();
			return new DecimalValue( $v * $v * $v );
		};

		$scale = function ( DecimalValue $value, $factor ) {
			return new DecimalValue( $value->getValueFloat() * $factor );
		};

		return array(
			0 => array(
				UnboundedQuantityValue::newFromNumber( '+10', '1' ),
				$identity,
				UnboundedQuantityValue::newFromNumber( '+10', '?' )
			),
			1 => array(
				UnboundedQuantityValue::newFromNumber( '-0.5', '1' ),
				$identity,
				UnboundedQuantityValue::newFromNumber( '-0.5', '?' )
			),
			2 => array(
				UnboundedQuantityValue::newFromNumber( '+0', '1' ),
				$square,
				UnboundedQuantityValue::newFromNumber( '+0', '?' )
			),
			3 => array(
				UnboundedQuantityValue::newFromNumber( '+10', '1' ),
				$square,
				UnboundedQuantityValue::newFromNumber( '+1000', '?' )
			),
			4 => array(
				UnboundedQuantityValue::newFromNumber( '+0.5', '1' ),
				$scale,
				UnboundedQuantityValue::newFromNumber( '+0.25', '?' ),
				0.5
			),

			// note: absolutely exact values require conversion with infinite precision!
			10 => array(
				UnboundedQuantityValue::newFromNumber( '+100', '1' ),
				$scale,
				UnboundedQuantityValue::newFromNumber( '+12825', '?' ),
				128.25
			),
			13 => array(
				UnboundedQuantityValue::newFromNumber( '+100', '1' ),
				$scale,
				UnboundedQuantityValue::newFromNumber( '+333.33', '?' ),
				3.3333
			),
		);
	}

}


1			<?php
2
3			namespace DataValues\Tests;
4
5			use DataValues\DecimalValue;
6			use DataValues\UnboundedQuantityValue;
7
8			/**
9			* @covers DataValues\UnboundedQuantityValue
10			*
11			* @group DataValue
12			* @group DataValueExtensions
13			*
14			* @license GPL-2.0+
15			* @author Daniel Kinzler
16			*/
17			class UnboundedQuantityValueTest extends DataValueTest {
18
19			/**
20			* @see DataValueTest::getClass
21			*
22			* @return string
23			*/
24			public function getClass() {
25			return 'DataValues\UnboundedQuantityValue';
26			}
27
28			public function validConstructorArgumentsProvider() {
29			$argLists = array();
30
31			$argLists[] = array( new DecimalValue( '+42' ), '1' );
32			$argLists[] = array( new DecimalValue( '+0.01' ), '1' );
33			$argLists[] = array( new DecimalValue( '-0.5' ), '1' );
34
35			return $argLists;
36			}
37
38			public function invalidConstructorArgumentsProvider() {
39			$argLists = array();
40
41			$argLists[] = array( new DecimalValue( '+0' ), '' );
42			$argLists[] = array( new DecimalValue( '+0' ), 1 );
43
44			return $argLists;
45			}
46
47			/**
48			* @dataProvider instanceProvider
49			*/
50			public function testGetValue( UnboundedQuantityValue $quantity, array $arguments ) {
51			$this->assertSame( $quantity, $quantity->getValue() );
52			}
53
54			/**
55			* @dataProvider instanceProvider
56			*/
57			public function testGetAmount( UnboundedQuantityValue $quantity, array $arguments ) {
58			$this->assertSame( $arguments[0], $quantity->getAmount() );
59			}
60
61			/**
62			* @dataProvider instanceProvider
63			*/
64			public function testGetUnit( UnboundedQuantityValue $quantity, array $arguments ) {
65			$this->assertSame( $arguments[1], $quantity->getUnit() );
66			}
67
68			/**
69			* @dataProvider newFromNumberProvider
70			*/
71			public function testNewFromNumber( $amount, $unit, UnboundedQuantityValue $expected ) {
72			$quantity = UnboundedQuantityValue::newFromNumber( $amount, $unit );
73
74			$this->assertEquals( $expected->getAmount()->getValue(), $quantity->getAmount()->getValue() );
75			}
76
77			public function newFromNumberProvider() {
78			return array(
79			array(
80			42, '1',
81			new UnboundedQuantityValue( new DecimalValue( '+42' ), '1' )
82			),
83			array(
84			-0.05, '1',
85			new UnboundedQuantityValue( new DecimalValue( '-0.05' ), '1' )
86			),
87			array(
88			0, 'm',
89			new UnboundedQuantityValue( new DecimalValue( '+0' ), 'm' )
90			),
91			array(
92			'+23', '1',
93			new UnboundedQuantityValue( new DecimalValue( '+23' ), '1' )
94			),
95			array(
96			'+42', '1',
97			new UnboundedQuantityValue( new DecimalValue( '+42' ), '1' )
98			),
99			array(
100			'-0.05', 'm',
101			new UnboundedQuantityValue( new DecimalValue( '-0.05' ), 'm' )
102			),
103			array(
104			new DecimalValue( '+42' ), '1',
105			new UnboundedQuantityValue( new DecimalValue( '+42' ), '1' )
106			),
107			);
108			}
109
110			/**
111			* @dataProvider validArraySerializationProvider
112			*/
113			public function testNewFromArray( $data, UnboundedQuantityValue $expected ) {
114			$value = UnboundedQuantityValue::newFromArray( $data );
115			$this->assertTrue( $expected->equals( $value ), $value . ' should equal ' . $expected );
116			}
117
118			public function validArraySerializationProvider() {
119			return array(
120			'unbounded' => array(
121			array(
122			'amount' => '+2',
123			'unit' => '1',
124			),
125			UnboundedQuantityValue::newFromNumber( '+2', '1' )
126			),
127			'with-extra' => array(
128			array(
129			'amount' => '+2',
130			'unit' => '1',
131			'upperBound' => '+2.5',
132			'lowerBound' => '+1.5',
133			),
134			UnboundedQuantityValue::newFromNumber( '+2', '1' )
135			),
136			);
137			}
138
139			/**
140			* @dataProvider invalidArraySerializationProvider
141			*/
142			public function testNewFromArray_failure( $data ) {
143			$this->setExpectedException( 'DataValues\IllegalValueException' );
144			UnboundedQuantityValue::newFromArray( $data );
145			}
146
147			public function invalidArraySerializationProvider() {
148			return array(
149			'no-amount' => array(
150			array(
151			'unit' => '1',
152			)
153			),
154			'no-unit' => array(
155			array(
156			'amount' => '+2',
157			)
158			),
159			'bad-amount' => array(
160			array(
161			'amount' => 'x',
162			'unit' => '1',
163			)
164			),
165			);
166			}
167
168			/**
169			* @see https://phabricator.wikimedia.org/T110728
170			* @see http://www.regular-expressions.info/anchors.html#realend
171			*/
172			public function testTrailingNewlineRobustness() {
173			$value = UnboundedQuantityValue::newFromArray( array(
174			'amount' => "-0.0\n",
175			'unit' => "1\n",
176			) );
177
178			$this->assertSame( array(
179			'amount' => '+0.0',
180			'unit' => "1\n",
181			), $value->getArrayValue() );
182			}
183
184			/**
185			* @dataProvider instanceProvider
186			*/
187			public function testGetSortKey( UnboundedQuantityValue $quantity ) {
188			$this->assertSame( $quantity->getAmount()->getValueFloat(), $quantity->getSortKey() );
189			}
190
191			/**
192			* @dataProvider transformProvider
193			*/
194			public function testTransform( UnboundedQuantityValue $quantity, $transformation, UnboundedQuantityValue $expected ) {
195			$args = func_get_args();
196			$extraArgs = array_slice( $args, 3 );
197
198			$call = array( $quantity, 'transform' );
199			$callArgs = array_merge( array( 'x', $transformation ), $extraArgs );
200			$actual = call_user_func_array( $call, $callArgs );
201
202			$this->assertSame( 'x', $actual->getUnit() );
203			$this->assertEquals( $expected->getAmount()->getValue(), $actual->getAmount()->getValue(), 'value' );
204			}
205
206			public function transformProvider() {
207			$identity = function ( DecimalValue $value ) {
208			return $value;
209			};
210
211			$square = function ( DecimalValue $value ) {
212			$v = $value->getValueFloat();
213			return new DecimalValue( $v * $v * $v );
214			};
215
216			$scale = function ( DecimalValue $value, $factor ) {
217			return new DecimalValue( $value->getValueFloat() * $factor );
218			};
219
220			return array(
221			0 => array(
222			UnboundedQuantityValue::newFromNumber( '+10', '1' ),
223			$identity,
224			UnboundedQuantityValue::newFromNumber( '+10', '?' )
225			),
226			1 => array(
227			UnboundedQuantityValue::newFromNumber( '-0.5', '1' ),
228			$identity,
229			UnboundedQuantityValue::newFromNumber( '-0.5', '?' )
230			),
231			2 => array(
232			UnboundedQuantityValue::newFromNumber( '+0', '1' ),
233			$square,
234			UnboundedQuantityValue::newFromNumber( '+0', '?' )
235			),
236			3 => array(
237			UnboundedQuantityValue::newFromNumber( '+10', '1' ),
238			$square,
239			UnboundedQuantityValue::newFromNumber( '+1000', '?' )
240			),
241			4 => array(
242			UnboundedQuantityValue::newFromNumber( '+0.5', '1' ),
243			$scale,
244			UnboundedQuantityValue::newFromNumber( '+0.25', '?' ),
245			0.5
246			),
247
248			// note: absolutely exact values require conversion with infinite precision!
249			10 => array(
250			UnboundedQuantityValue::newFromNumber( '+100', '1' ),
251			$scale,
252			UnboundedQuantityValue::newFromNumber( '+12825', '?' ),
253			128.25
254			),
255			13 => array(
256			UnboundedQuantityValue::newFromNumber( '+100', '1' ),
257			$scale,
258			UnboundedQuantityValue::newFromNumber( '+333.33', '?' ),
259			3.3333
260			),
261			);
262			}
263
264			}
265

DataValues / Number

Push — master ( 5763d0...f2497e )

UnboundedQuantityValueTest::transformProvider() A

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like