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

Completed

Push — master ( 5e016a...19cfc9 )

by Daniel

created 2016-07-13 12:03 UTC

invalidConstructorArgumentsProvider() A

↳ Parent: UnboundedQuantityValueTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	8
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	1

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

<?php

namespace DataValues\Tests;

use DataValues\DataValue;
use DataValues\DecimalValue;
use DataValues\IllegalValueException;
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->assertInstanceOf( $this->getClass(), $quantity->getValue() );
	}

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

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

DataValues / Number

Push — master ( 5e016a...19cfc9 )

invalidConstructorArgumentsProvider() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like