UnboundedQuantityValueTest::invalidArraySerializationProvider() - Code Metrics - wmde/Number - Measure and Improve Code Quality continuously with Scrutinizer

invalidArraySerializationProvider() B
last analyzed 2021-03-31 13:58 UTC

↳ Parent: UnboundedQuantityValueTest

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	59
rs	8.8945
c	0
b	0
f	0
cc	1
nc	1
nop	0

How to fix Long Method

<?php

namespace DataValues\Tests;

use DataValues\DecimalValue;
use DataValues\IllegalValueException;
use DataValues\QuantityValue;
use DataValues\UnboundedQuantityValue;

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

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

	public function validConstructorArgumentsProvider() {
		$argLists = [];

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

		return $argLists;
	}

	public function invalidConstructorArgumentsProvider() {
		$argLists = [];

		$argLists[] = [ new DecimalValue( '+0' ), '' ];
		$argLists[] = [ 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()->getValueFloat(), $quantity->getAmount()->getValueFloat() );
	}

	public function newFromNumberProvider() {
		return [
			[
				42, '1',
				new UnboundedQuantityValue( new DecimalValue( '+42' ), '1' )
			],
			[
				-0.05, '1',
				new UnboundedQuantityValue( new DecimalValue( '-0.05' ), '1' )
			],
			[
				0, 'm',
				new UnboundedQuantityValue( new DecimalValue( '+0' ), 'm' )
			],
			[
				'+23', '1',
				new UnboundedQuantityValue( new DecimalValue( '+23' ), '1' )
			],
			[
				'+42', '1',
				new UnboundedQuantityValue( new DecimalValue( '+42' ), '1' )
			],
			[
				'-0.05', 'm',
				new UnboundedQuantityValue( new DecimalValue( '-0.05' ), 'm' )
			],
			[
				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 [
			'unbounded' => [
				[
					'amount' => '+2',
					'unit' => '1',
				],
				UnboundedQuantityValue::newFromNumber( '+2', '1' )
			],
			'unbounded with existing array keys' => [
				[
					'amount' => '+2',
					'unit' => '1',
					'upperBound' => null,
					'lowerBound' => null,
				],
				UnboundedQuantityValue::newFromNumber( '+2', '1' )
			],
			'with-extra' => [
				[
					'amount' => '+2',
					'unit' => '1',
					'upperBound' => '+2.5',
					'lowerBound' => '+1.5',
				],
				QuantityValue::newFromNumber( '+2', '1', '+2.5', '+1.5' )
			],
		];
	}

	/**
	 * @dataProvider invalidArraySerializationProvider
	 */
	public function testNewFromArray_failure( $data ) {
		$this->expectException( IllegalValueException::class );
		UnboundedQuantityValue::newFromArray( $data );

	}

	public function invalidArraySerializationProvider() {
		return [
			'not an array (string)' => [
				'foo'
			],
			'not an array (int)' => [
				303
			],
			'not an array (object)' => [
				new \stdClass()
			],
			'no-amount' => [
				[
					'unit' => '1',
				]
			],
			'no-unit' => [
				[
					'amount' => '+2',
				]
			],
			'no-upperBound' => [
				[
					'amount' => '+2',
					'unit' => '1',
					'lowerBound' => '+1.5',
				]
			],
			'no-lowerBound' => [
				[
					'amount' => '+2',
					'unit' => '1',
					'upperBound' => '+2.5',
				]
			],
			'bad-amount' => [
				[
					'amount' => 'x',
					'unit' => '1',
				]
			],
			'bad-upperBound' => [
				[
					'amount' => '+2',
					'unit' => '1',
					'upperBound' => 'x',
					'lowerBound' => '+1.5',
				]
			],
			'bad-lowerBound' => [
				[
					'amount' => '+2',
					'unit' => '1',
					'upperBound' => '+2.5',
					'lowerBound' => 'x',
				]
			],
		];
	}

	/**
	 * @see https://phabricator.wikimedia.org/T110728
	 * @see http://www.regular-expressions.info/anchors.html#realend
	 */
	public function testTrailingNewlineRobustness() {
		$value = UnboundedQuantityValue::newFromArray( [

			'amount' => "-0.0\n",
			'unit' => "1\n",
		] );

		$this->assertSame( [
			'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 = [ $quantity, 'transform' ];
		$callArgs = array_merge( [ 'x', $transformation ], $extraArgs );
		$actual = call_user_func_array( $call, $callArgs );

		$this->assertSame( 'x', $actual->getUnit() );
		$this->assertEquals(
			floatval( $expected->getAmount()->getValue() ),
			floatval( $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 [
			0 => [
				UnboundedQuantityValue::newFromNumber( '+10', '1' ),
				$identity,
				UnboundedQuantityValue::newFromNumber( '+10', '?' )
			],
			1 => [
				UnboundedQuantityValue::newFromNumber( '-0.5', '1' ),
				$identity,
				UnboundedQuantityValue::newFromNumber( '-0.5', '?' )
			],
			2 => [
				UnboundedQuantityValue::newFromNumber( '+0', '1' ),
				$square,
				UnboundedQuantityValue::newFromNumber( '+0', '?' )
			],
			3 => [
				UnboundedQuantityValue::newFromNumber( '+10', '1' ),
				$square,
				UnboundedQuantityValue::newFromNumber( '+1000', '?' )
			],
			4 => [
				UnboundedQuantityValue::newFromNumber( '+0.5', '1' ),
				$scale,
				UnboundedQuantityValue::newFromNumber( '+0.25', '?' ),
				0.5
			],

			// note: absolutely exact values require conversion with infinite precision!
			10 => [
				UnboundedQuantityValue::newFromNumber( '+100', '1' ),
				$scale,
				UnboundedQuantityValue::newFromNumber( '+12825', '?' ),
				128.25
			],
			13 => [
				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\IllegalValueException;
7			use DataValues\QuantityValue;
8			use DataValues\UnboundedQuantityValue;
9
10			/**
11			* @covers DataValues\UnboundedQuantityValue
12			*
13			* @group DataValue
14			* @group DataValueExtensions
15			*
16			* @license GPL-2.0-or-later
17			* @author Daniel Kinzler
18			*/
19			class UnboundedQuantityValueTest extends DataValuesTestBase {
20
21			/**
22			* @see DataValueTest::getClass
23			*
24			* @return string
25			*/
26			public function getClass() {
27			return UnboundedQuantityValue::class;
28			}
29
30			public function validConstructorArgumentsProvider() {
31			$argLists = [];
32
33			$argLists[] = [ new DecimalValue( '+42' ), '1' ];
34			$argLists[] = [ new DecimalValue( '+0.01' ), '1' ];
35			$argLists[] = [ new DecimalValue( '-0.5' ), '1' ];
36
37			return $argLists;
38			}
39
40			public function invalidConstructorArgumentsProvider() {
41			$argLists = [];
42
43			$argLists[] = [ new DecimalValue( '+0' ), '' ];
44			$argLists[] = [ new DecimalValue( '+0' ), 1 ];
45
46			return $argLists;
47			}
48
49			/**
50			* @dataProvider instanceProvider
51			*/
52			public function testGetValue( UnboundedQuantityValue $quantity, array $arguments ) {
			0 ignored issues – show Unused Code introduced 2019-09-13 08:26 UTC by Report Bug Copy Issue Report The parameter `$arguments` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
53			$this->assertSame( $quantity, $quantity->getValue() );
54			}
55
56			/**
57			* @dataProvider instanceProvider
58			*/
59			public function testGetAmount( UnboundedQuantityValue $quantity, array $arguments ) {
60			$this->assertSame( $arguments[0], $quantity->getAmount() );
61			}
62
63			/**
64			* @dataProvider instanceProvider
65			*/
66			public function testGetUnit( UnboundedQuantityValue $quantity, array $arguments ) {
67			$this->assertSame( $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()->getValueFloat(), $quantity->getAmount()->getValueFloat() );
77			}
78
79			public function newFromNumberProvider() {
80			return [
81			[
82			42, '1',
83			new UnboundedQuantityValue( new DecimalValue( '+42' ), '1' )
84			],
85			[
86			-0.05, '1',
87			new UnboundedQuantityValue( new DecimalValue( '-0.05' ), '1' )
88			],
89			[
90			0, 'm',
91			new UnboundedQuantityValue( new DecimalValue( '+0' ), 'm' )
92			],
93			[
94			'+23', '1',
95			new UnboundedQuantityValue( new DecimalValue( '+23' ), '1' )
96			],
97			[
98			'+42', '1',
99			new UnboundedQuantityValue( new DecimalValue( '+42' ), '1' )
100			],
101			[
102			'-0.05', 'm',
103			new UnboundedQuantityValue( new DecimalValue( '-0.05' ), 'm' )
104			],
105			[
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, UnboundedQuantityValue $expected ) {
116			$value = UnboundedQuantityValue::newFromArray( $data );
			0 ignored issues – show Deprecated Code introduced 2019-09-13 08:26 UTC by Report Bug Copy Issue Report The method `DataValues\UnboundedQuantityValue::newFromArray()` has been deprecated with message: since 0.8.3. Static DataValue::newFromArray constructors like this are underspecified (not in the DataValue interface), and misleadingly named (should be named newFromArrayValue). Instead, use DataValue builder callbacks in @see DataValueDeserializer. 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...
117			$this->assertTrue( $expected->equals( $value ), $value . ' should equal ' . $expected );
118			}
119
120			public function validArraySerializationProvider() {
121			return [
122			'unbounded' => [
123			[
124			'amount' => '+2',
125			'unit' => '1',
126			],
127			UnboundedQuantityValue::newFromNumber( '+2', '1' )
128			],
129			'unbounded with existing array keys' => [
130			[
131			'amount' => '+2',
132			'unit' => '1',
133			'upperBound' => null,
134			'lowerBound' => null,
135			],
136			UnboundedQuantityValue::newFromNumber( '+2', '1' )
137			],
138			'with-extra' => [
139			[
140			'amount' => '+2',
141			'unit' => '1',
142			'upperBound' => '+2.5',
143			'lowerBound' => '+1.5',
144			],
145			QuantityValue::newFromNumber( '+2', '1', '+2.5', '+1.5' )
146			],
147			];
148			}
149
150			/**
151			* @dataProvider invalidArraySerializationProvider
152			*/
153			public function testNewFromArray_failure( $data ) {
154			$this->expectException( IllegalValueException::class );
155			UnboundedQuantityValue::newFromArray( $data );
			0 ignored issues – show Deprecated Code introduced 2019-09-13 08:26 UTC by Report Bug Copy Issue Report The method `DataValues\UnboundedQuantityValue::newFromArray()` has been deprecated with message: since 0.8.3. Static DataValue::newFromArray constructors like this are underspecified (not in the DataValue interface), and misleadingly named (should be named newFromArrayValue). Instead, use DataValue builder callbacks in @see DataValueDeserializer. 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...
156			}
157
158			public function invalidArraySerializationProvider() {
159			return [
160			'not an array (string)' => [
161			'foo'
162			],
163			'not an array (int)' => [
164			303
165			],
166			'not an array (object)' => [
167			new \stdClass()
168			],
169			'no-amount' => [
170			[
171			'unit' => '1',
172			]
173			],
174			'no-unit' => [
175			[
176			'amount' => '+2',
177			]
178			],
179			'no-upperBound' => [
180			[
181			'amount' => '+2',
182			'unit' => '1',
183			'lowerBound' => '+1.5',
184			]
185			],
186			'no-lowerBound' => [
187			[
188			'amount' => '+2',
189			'unit' => '1',
190			'upperBound' => '+2.5',
191			]
192			],
193			'bad-amount' => [
194			[
195			'amount' => 'x',
196			'unit' => '1',
197			]
198			],
199			'bad-upperBound' => [
200			[
201			'amount' => '+2',
202			'unit' => '1',
203			'upperBound' => 'x',
204			'lowerBound' => '+1.5',
205			]
206			],
207			'bad-lowerBound' => [
208			[
209			'amount' => '+2',
210			'unit' => '1',
211			'upperBound' => '+2.5',
212			'lowerBound' => 'x',
213			]
214			],
215			];
216			}
217
218			/**
219			* @see https://phabricator.wikimedia.org/T110728
220			* @see http://www.regular-expressions.info/anchors.html#realend
221			*/
222			public function testTrailingNewlineRobustness() {
223			$value = UnboundedQuantityValue::newFromArray( [
			0 ignored issues – show Deprecated Code introduced 2019-09-13 08:26 UTC by Report Bug Copy Issue Report The method `DataValues\UnboundedQuantityValue::newFromArray()` has been deprecated with message: since 0.8.3. Static DataValue::newFromArray constructors like this are underspecified (not in the DataValue interface), and misleadingly named (should be named newFromArrayValue). Instead, use DataValue builder callbacks in @see DataValueDeserializer. 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...
224			'amount' => "-0.0\n",
225			'unit' => "1\n",
226			] );
227
228			$this->assertSame( [
229			'amount' => '+0.0',
230			'unit' => "1\n",
231			], $value->getArrayValue() );
232			}
233
234			/**
235			* @dataProvider instanceProvider
236			*/
237			public function testGetSortKey( UnboundedQuantityValue $quantity ) {
238			$this->assertSame( $quantity->getAmount()->getValueFloat(), $quantity->getSortKey() );
			0 ignored issues – show Deprecated Code introduced 2021-03-12 16:01 UTC by Report Bug Copy Issue Report The method `DataValues\UnboundedQuantityValue::getSortKey()` has been deprecated with message: Kept for compatibility with older DataValues versions. Do not use. 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...
239			}
240
241			/**
242			* @dataProvider transformProvider
243			*/
244			public function testTransform(
245			UnboundedQuantityValue $quantity,
246			$transformation,
247			UnboundedQuantityValue $expected
248			) {
249			$args = func_get_args();
250			$extraArgs = array_slice( $args, 3 );
251
252			$call = [ $quantity, 'transform' ];
253			$callArgs = array_merge( [ 'x', $transformation ], $extraArgs );
254			$actual = call_user_func_array( $call, $callArgs );
255
256			$this->assertSame( 'x', $actual->getUnit() );
257			$this->assertEquals(
258			floatval( $expected->getAmount()->getValue() ),
259			floatval( $actual->getAmount()->getValue() ),
260			'value'
261			);
262			}
263
264			public function transformProvider() {
265			$identity = function ( DecimalValue $value ) {
266			return $value;
267			};
268
269			$square = function ( DecimalValue $value ) {
270			$v = $value->getValueFloat();
271			return new DecimalValue( $v * $v * $v );
272			};
273
274			$scale = function ( DecimalValue $value, $factor ) {
275			return new DecimalValue( $value->getValueFloat() * $factor );
276			};
277
278			return [
279			0 => [
280			UnboundedQuantityValue::newFromNumber( '+10', '1' ),
281			$identity,
282			UnboundedQuantityValue::newFromNumber( '+10', '?' )
283			],
284			1 => [
285			UnboundedQuantityValue::newFromNumber( '-0.5', '1' ),
286			$identity,
287			UnboundedQuantityValue::newFromNumber( '-0.5', '?' )
288			],
289			2 => [
290			UnboundedQuantityValue::newFromNumber( '+0', '1' ),
291			$square,
292			UnboundedQuantityValue::newFromNumber( '+0', '?' )
293			],
294			3 => [
295			UnboundedQuantityValue::newFromNumber( '+10', '1' ),
296			$square,
297			UnboundedQuantityValue::newFromNumber( '+1000', '?' )
298			],
299			4 => [
300			UnboundedQuantityValue::newFromNumber( '+0.5', '1' ),
301			$scale,
302			UnboundedQuantityValue::newFromNumber( '+0.25', '?' ),
303			0.5
304			],
305
306			// note: absolutely exact values require conversion with infinite precision!
307			10 => [
308			UnboundedQuantityValue::newFromNumber( '+100', '1' ),
309			$scale,
310			UnboundedQuantityValue::newFromNumber( '+12825', '?' ),
311			128.25
312			],
313			13 => [
314			UnboundedQuantityValue::newFromNumber( '+100', '1' ),
315			$scale,
316			UnboundedQuantityValue::newFromNumber( '+333.33', '?' ),
317			3.3333
318			],
319			];
320			}
321
322			}
323

wmde / Number

invalidArraySerializationProvider() B last analyzed 2021-03-31 13:58 UTC

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like

invalidArraySerializationProvider() B
last analyzed 2021-03-31 13:58 UTC