Inspection of "Exceptions for large numbers instead of TypeErrors" - wmde/Euro - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#9)

by Jeroen De

created 2019-01-17 12:55 UTC

Status

Spacing +110 added lines, -110 removed lines patch added patch discarded remove patch

@@ -1,6 +1,6 @@  discard block
 block discarded – undo
 <?php
 
-declare( strict_types = 1 );
+declare(strict_types=1);
 
 namespace WMDE\Euro\Tests\Unit;
 
@@ -19,201 +19,201 @@  discard block
 block discarded – undo
 	/**
 	 * @dataProvider unsignedIntegerProvider
 	 */
-	public function testGetCentsReturnsConstructorArgument( int $unsignedInteger ) {
-		$amount = Euro::newFromCents( $unsignedInteger );
-		$this->assertSame( $unsignedInteger, $amount->getEuroCents() );
+	public function testGetCentsReturnsConstructorArgument(int $unsignedInteger) {
+		$amount = Euro::newFromCents($unsignedInteger);
+		$this->assertSame($unsignedInteger, $amount->getEuroCents());
 	}
 
 	public function unsignedIntegerProvider() {
 		return [
-			[ 0 ], [ 1 ], [ 2 ], [ 9 ], [ 10 ], [ 11 ],
-			[ 99 ], [ 100 ], [ 101 ], [ 999 ], [ 1000 ], [ 1001 ],
+			[0], [1], [2], [9], [10], [11],
+			[99], [100], [101], [999], [1000], [1001],
 		];
 	}
 
 	public function testGivenZero_getEuroFloatReturnsZeroFloat() {
-		$amount = Euro::newFromCents( 0 );
-		$this->assertExactFloat( 0.0, $amount->getEuroFloat() );
-		$this->assertNotSame( 0, $amount->getEuroFloat() );
+		$amount = Euro::newFromCents(0);
+		$this->assertExactFloat(0.0, $amount->getEuroFloat());
+		$this->assertNotSame(0, $amount->getEuroFloat());
 	}
 
-	private function assertExactFloat( float $expected, $actual ) {
-		$this->assertInternalType( 'float', $actual );
-		$this->assertEquals( $expected, $actual, '', 0 );
+	private function assertExactFloat(float $expected, $actual) {
+		$this->assertInternalType('float', $actual);
+		$this->assertEquals($expected, $actual, '', 0);
 	}
 
 	public function testGivenOneEuro_getEuroFloatReturnsOne() {
-		$amount = Euro::newFromCents( 100 );
-		$this->assertExactFloat( 1.0, $amount->getEuroFloat() );
+		$amount = Euro::newFromCents(100);
+		$this->assertExactFloat(1.0, $amount->getEuroFloat());
 	}
 
 	public function testGivenOneCent_getEuroFloatReturnsPointZeroOne() {
-		$amount = Euro::newFromCents( 1 );
-		$this->assertExactFloat( 0.01, $amount->getEuroFloat() );
+		$amount = Euro::newFromCents(1);
+		$this->assertExactFloat(0.01, $amount->getEuroFloat());
 	}
 
 	public function testGiven33cents_getEuroFloatReturnsPointThreeThree() {
-		$amount = Euro::newFromCents( 33 );
-		$this->assertExactFloat( 0.33, $amount->getEuroFloat() );
+		$amount = Euro::newFromCents(33);
+		$this->assertExactFloat(0.33, $amount->getEuroFloat());
 	}
 
 	public function testGivenNegativeAmount_constructorThrowsException() {
-		$this->expectException( \InvalidArgumentException::class );
+		$this->expectException(\InvalidArgumentException::class);
 		Euro::newFromCents( -1 );
 	}
 
 	public function testGivenZero_getEuroStringReturnsZeroString() {
-		$amount = Euro::newFromCents( 0 );
-		$this->assertSame( '0.00', $amount->getEuroString() );
+		$amount = Euro::newFromCents(0);
+		$this->assertSame('0.00', $amount->getEuroString());
 	}
 
 	public function testGivenOneEuro_getEuroStringReturnsOnePointZeroZero() {
-		$amount = Euro::newFromCents( 100 );
-		$this->assertSame( '1.00', $amount->getEuroString() );
+		$amount = Euro::newFromCents(100);
+		$this->assertSame('1.00', $amount->getEuroString());
 	}
 
 	public function testGivenTwoEuros_getEuroStringReturnsTwoPointZeroZero() {
-		$amount = Euro::newFromCents( 200 );
-		$this->assertSame( '2.00', $amount->getEuroString() );
+		$amount = Euro::newFromCents(200);
+		$this->assertSame('2.00', $amount->getEuroString());
 	}
 
 	public function testGivenOneCent_getEuroStringReturnsZeroPointZeroOne() {
-		$amount = Euro::newFromCents( 1 );
-		$this->assertSame( '0.01', $amount->getEuroString() );
+		$amount = Euro::newFromCents(1);
+		$this->assertSame('0.01', $amount->getEuroString());
 	}
 
 	public function testGivenTenCents_getEuroStringReturnsZeroPointOneZero() {
-		$amount = Euro::newFromCents( 10 );
-		$this->assertSame( '0.10', $amount->getEuroString() );
+		$amount = Euro::newFromCents(10);
+		$this->assertSame('0.10', $amount->getEuroString());
 	}
 
 	public function testGiven1234Cents_getEuroStringReturns12euro34() {
-		$amount = Euro::newFromCents( 1234 );
-		$this->assertSame( '12.34', $amount->getEuroString() );
+		$amount = Euro::newFromCents(1234);
+		$this->assertSame('12.34', $amount->getEuroString());
 	}
 
 	public function testOneEuroString_getsTurnedInto100cents() {
-		$this->assertSame( 100, Euro::newFromString( '1.00' )->getEuroCents() );
+		$this->assertSame(100, Euro::newFromString('1.00')->getEuroCents());
 	}
 
 	public function testOneCentString_getsTurnedInto1cents() {
-		$this->assertSame( 1, Euro::newFromString( '0.01' )->getEuroCents() );
+		$this->assertSame(1, Euro::newFromString('0.01')->getEuroCents());
 	}
 
 	public function testTenCentString_getsTurnedInto10cents() {
-		$this->assertSame( 10, Euro::newFromString( '0.10' )->getEuroCents() );
+		$this->assertSame(10, Euro::newFromString('0.10')->getEuroCents());
 	}
 
 	public function testShortTenCentString_getsTurnedInto10cents() {
-		$this->assertSame( 10, Euro::newFromString( '0.1' )->getEuroCents() );
+		$this->assertSame(10, Euro::newFromString('0.1')->getEuroCents());
 	}
 
 	public function testShortOneEuroString_getsTurnedInto100cents() {
-		$this->assertSame( 100, Euro::newFromString( '1' )->getEuroCents() );
+		$this->assertSame(100, Euro::newFromString('1')->getEuroCents());
 	}
 
 	public function testOneDecimalOneEuroString_getsTurnedInto100cents() {
-		$this->assertSame( 100, Euro::newFromString( '1.0' )->getEuroCents() );
+		$this->assertSame(100, Euro::newFromString('1.0')->getEuroCents());
 	}
 
 	public function testMultiDecimalOneEuroString_getsTurnedInto100cents() {
-		$this->assertSame( 100, Euro::newFromString( '1.00000' )->getEuroCents() );
+		$this->assertSame(100, Euro::newFromString('1.00000')->getEuroCents());
 	}
 
 	public function testHandlingOfLargeEuroString() {
-		$this->assertSame( 3133742, Euro::newFromString( '31337.42' )->getEuroCents() );
+		$this->assertSame(3133742, Euro::newFromString('31337.42')->getEuroCents());
 	}
 
 	public function testEuroStringThatCausedRoundingError_doesNotCauseRoundingError() {
 		// Regression test for https://phabricator.wikimedia.org/T183481
-		$this->assertSame( 870, Euro::newFromString( '8.70' )->getEuroCents() );
-		$this->assertSame( 920, Euro::newFromString( '9.20' )->getEuroCents() );
+		$this->assertSame(870, Euro::newFromString('8.70')->getEuroCents());
+		$this->assertSame(920, Euro::newFromString('9.20')->getEuroCents());
 	}
 
 	public function testEuroStringWithRoundingError_getsRoundedAppropriately() {
-		$this->assertSame( 101, Euro::newFromString( '1.0100000001' )->getEuroCents() );
-		$this->assertSame( 101, Euro::newFromString( '1.010000009999' )->getEuroCents() );
-		$this->assertSame( 101, Euro::newFromString( '1.011' )->getEuroCents() );
-		$this->assertSame( 101, Euro::newFromString( '1.014' )->getEuroCents() );
-		$this->assertSame( 101, Euro::newFromString( '1.0149' )->getEuroCents() );
-		$this->assertSame( 102, Euro::newFromString( '1.015' )->getEuroCents() );
-		$this->assertSame( 102, Euro::newFromString( '1.019' )->getEuroCents() );
-		$this->assertSame( 102, Euro::newFromString( '1.0199999' )->getEuroCents() );
-		$this->assertSame( 870, Euro::newFromString( '8.701' )->getEuroCents() );
-		$this->assertSame( 870, Euro::newFromString( '8.70499' )->getEuroCents() );
-		$this->assertSame( 871, Euro::newFromString( '8.705' )->getEuroCents() );
-		$this->assertSame( 871, Euro::newFromString( '8.705000' )->getEuroCents() );
-		$this->assertSame( 871, Euro::newFromString( '8.705001' )->getEuroCents() );
-		$this->assertSame( 871, Euro::newFromString( '8.709999' )->getEuroCents() );
+		$this->assertSame(101, Euro::newFromString('1.0100000001')->getEuroCents());
+		$this->assertSame(101, Euro::newFromString('1.010000009999')->getEuroCents());
+		$this->assertSame(101, Euro::newFromString('1.011')->getEuroCents());
+		$this->assertSame(101, Euro::newFromString('1.014')->getEuroCents());
+		$this->assertSame(101, Euro::newFromString('1.0149')->getEuroCents());
+		$this->assertSame(102, Euro::newFromString('1.015')->getEuroCents());
+		$this->assertSame(102, Euro::newFromString('1.019')->getEuroCents());
+		$this->assertSame(102, Euro::newFromString('1.0199999')->getEuroCents());
+		$this->assertSame(870, Euro::newFromString('8.701')->getEuroCents());
+		$this->assertSame(870, Euro::newFromString('8.70499')->getEuroCents());
+		$this->assertSame(871, Euro::newFromString('8.705')->getEuroCents());
+		$this->assertSame(871, Euro::newFromString('8.705000')->getEuroCents());
+		$this->assertSame(871, Euro::newFromString('8.705001')->getEuroCents());
+		$this->assertSame(871, Euro::newFromString('8.709999')->getEuroCents());
 	}
 
 	public function testGivenNegativeAmountString_exceptionIsThrown() {
-		$this->expectException( \InvalidArgumentException::class );
-		Euro::newFromString( '-1.00' );
+		$this->expectException(\InvalidArgumentException::class);
+		Euro::newFromString('-1.00');
 	}
 
 	public function testGivenStringWithComma_exceptionIsThrown() {
-		$this->expectException( \InvalidArgumentException::class );
-		Euro::newFromString( '1,00' );
+		$this->expectException(\InvalidArgumentException::class);
+		Euro::newFromString('1,00');
 	}
 
 	public function testGivenStringWithMultipleDots_ExceptionIsThrown() {
-		$this->expectException( \InvalidArgumentException::class );
-		Euro::newFromString( '1.0.0' );
+		$this->expectException(\InvalidArgumentException::class);
+		Euro::newFromString('1.0.0');
 	}
 
 	public function testGivenNonNumber_exceptionIsThrown() {
-		$this->expectException( \InvalidArgumentException::class );
-		Euro::newFromString( '1.00abc' );
+		$this->expectException(\InvalidArgumentException::class);
+		Euro::newFromString('1.00abc');
 	}
 
 	public function testGivenNegativeFloatAmount_exceptionIsThrown() {
-		$this->expectException( \InvalidArgumentException::class );
+		$this->expectException(\InvalidArgumentException::class);
 		Euro::newFromFloat( -1.00 );
 	}
 
 	public function testOneEuroFloat_getsTurnedInto100cents() {
-		$this->assertSame( 100, Euro::newFromFloat( 1.0 )->getEuroCents() );
+		$this->assertSame(100, Euro::newFromFloat(1.0)->getEuroCents());
 	}
 
 	public function testOneCentFloat_getsTurnedInto1cent() {
-		$this->assertSame( 1, Euro::newFromFloat( 0.01 )->getEuroCents() );
+		$this->assertSame(1, Euro::newFromFloat(0.01)->getEuroCents());
 	}
 
 	public function testTenCentFloat_getsTurnedInto10cents() {
-		$this->assertSame( 10, Euro::newFromFloat( 0.1 )->getEuroCents() );
+		$this->assertSame(10, Euro::newFromFloat(0.1)->getEuroCents());
 	}
 
 	public function testHandlingOfLargeEuroFloat() {
-		$this->assertSame( 3133742, Euro::newFromFloat( 31337.42 )->getEuroCents() );
+		$this->assertSame(3133742, Euro::newFromFloat(31337.42)->getEuroCents());
 	}
 
 	public function testFloatWithRoundingError_getsRoundedAppropriately() {
-		$this->assertSame( 101, Euro::newFromFloat( 1.0100000001 )->getEuroCents() );
-		$this->assertSame( 101, Euro::newFromFloat( 1.010000009999 )->getEuroCents() );
-		$this->assertSame( 101, Euro::newFromFloat( 1.011 )->getEuroCents() );
-		$this->assertSame( 101, Euro::newFromFloat( 1.014 )->getEuroCents() );
-		$this->assertSame( 101, Euro::newFromFloat( 1.0149 )->getEuroCents() );
-		$this->assertSame( 102, Euro::newFromFloat( 1.015 )->getEuroCents() );
-		$this->assertSame( 102, Euro::newFromFloat( 1.019 )->getEuroCents() );
-		$this->assertSame( 102, Euro::newFromFloat( 1.0199999 )->getEuroCents() );
-		$this->assertSame( 870, Euro::newFromFloat( 8.70 )->getEuroCents() );
+		$this->assertSame(101, Euro::newFromFloat(1.0100000001)->getEuroCents());
+		$this->assertSame(101, Euro::newFromFloat(1.010000009999)->getEuroCents());
+		$this->assertSame(101, Euro::newFromFloat(1.011)->getEuroCents());
+		$this->assertSame(101, Euro::newFromFloat(1.014)->getEuroCents());
+		$this->assertSame(101, Euro::newFromFloat(1.0149)->getEuroCents());
+		$this->assertSame(102, Euro::newFromFloat(1.015)->getEuroCents());
+		$this->assertSame(102, Euro::newFromFloat(1.019)->getEuroCents());
+		$this->assertSame(102, Euro::newFromFloat(1.0199999)->getEuroCents());
+		$this->assertSame(870, Euro::newFromFloat(8.70)->getEuroCents());
 	}
 
 	public function testZeroEuroIntegers_isZeroCents() {
-		$this->assertSame( 0, Euro::newFromInt( 0 )->getEuroCents() );
+		$this->assertSame(0, Euro::newFromInt(0)->getEuroCents());
 	}
 
 	public function testOneEuroIntegers_is100cents() {
-		$this->assertSame( 100, Euro::newFromInt( 1 )->getEuroCents() );
+		$this->assertSame(100, Euro::newFromInt(1)->getEuroCents());
 	}
 
 	public function test1337EuroIntegers_is133700cents() {
-		$this->assertSame( 133700, Euro::newFromInt( 1337 )->getEuroCents() );
+		$this->assertSame(133700, Euro::newFromInt(1337)->getEuroCents());
 	}
 
 	public function testGivenNegativeIntegerAmount_exceptionIsThrown() {
-		$this->expectException( \InvalidArgumentException::class );
+		$this->expectException(\InvalidArgumentException::class);
 		Euro::newFromInt( -1 );
 	}
 
@@ -221,78 +221,78 @@  discard block
 block discarded – undo
 	 * @dataProvider euroProvider
 	 * @param Euro $euro
 	 */
-	public function testEuroEqualsItself( Euro $euro ) {
-		$this->assertTrue( $euro->equals( clone $euro ) );
+	public function testEuroEqualsItself(Euro $euro) {
+		$this->assertTrue($euro->equals(clone $euro));
 	}
 
 	public function euroProvider() {
 		return [
-			[ Euro::newFromCents( 0 ) ],
-			[ Euro::newFromCents( 1 ) ],
-			[ Euro::newFromCents( 99 ) ],
-			[ Euro::newFromCents( 100 ) ],
-			[ Euro::newFromCents( 9999 ) ],
+			[Euro::newFromCents(0)],
+			[Euro::newFromCents(1)],
+			[Euro::newFromCents(99)],
+			[Euro::newFromCents(100)],
+			[Euro::newFromCents(9999)],
 		];
 	}
 
 	public function testOneCentDoesNotEqualOneEuro() {
-		$this->assertFalse( Euro::newFromCents( 1 )->equals( Euro::newFromInt( 1 ) ) );
+		$this->assertFalse(Euro::newFromCents(1)->equals(Euro::newFromInt(1)));
 	}
 
 	public function testOneCentDoesNotEqualTwoCents() {
-		$this->assertFalse( Euro::newFromCents( 1 )->equals( Euro::newFromCents( 2 ) ) );
+		$this->assertFalse(Euro::newFromCents(1)->equals(Euro::newFromCents(2)));
 	}
 
 	public function testOneCentDoesNotEqualOneEuroAndOneCent() {
-		$this->assertFalse( Euro::newFromCents( 1 )->equals( Euro::newFromCents( 101 ) ) );
+		$this->assertFalse(Euro::newFromCents(1)->equals(Euro::newFromCents(101)));
 	}
 
 	public function test9001centsDoesNotEqual9000cents() {
-		$this->assertFalse( Euro::newFromCents( 9001 )->equals( Euro::newFromCents( 9000 ) ) );
+		$this->assertFalse(Euro::newFromCents(9001)->equals(Euro::newFromCents(9000)));
 	}
 
 	/**
 	 * @dataProvider tooLongStringProvider
 	 */
-	public function testNewFromStringThrowsExceptionWhenStringIsTooLong( string $string ) {
-		$this->expectException( InvalidArgumentException::class );
-		$this->expectExceptionMessage( 'Number is too big' );
+	public function testNewFromStringThrowsExceptionWhenStringIsTooLong(string $string) {
+		$this->expectException(InvalidArgumentException::class);
+		$this->expectExceptionMessage('Number is too big');
 
-		Euro::newFromString( $string );
+		Euro::newFromString($string);
 	}
 
 	public function tooLongStringProvider() {
-		yield [ '1111111111111111111111111111111' ];
-		yield [ (string)PHP_INT_MAX ];
-		yield [ substr( (string)PHP_INT_MAX, 0, -2 ) ];
+		yield ['1111111111111111111111111111111'];
+		yield [(string) PHP_INT_MAX];
+		yield [substr((string) PHP_INT_MAX, 0, -2)];
 	}
 
 	public function testNewFromStringHandlesLongStrings() {
-		Euro::newFromString( substr( (string)PHP_INT_MAX, 0, -3 ) );
-		$this->assertTrue( true );
+		Euro::newFromString(substr((string) PHP_INT_MAX, 0, -3));
+		$this->assertTrue(true);
 	}
 
 	/**
 	 * @dataProvider tooHighIntegerProvider
 	 */
-	public function testNewFromIntThrowsExceptionWhenIntegerIsTooHigh( int $int ) {
-		$this->expectException( InvalidArgumentException::class );
-		$this->expectExceptionMessage( 'Number is too big' );
-		Euro::newFromInt( $int );
+	public function testNewFromIntThrowsExceptionWhenIntegerIsTooHigh(int $int) {
+		$this->expectException(InvalidArgumentException::class);
+		$this->expectExceptionMessage('Number is too big');
+		Euro::newFromInt($int);
 	}
 
 	public function tooHighIntegerProvider() {
-		yield [ PHP_INT_MAX ];
-		yield [ PHP_INT_MAX / 10 ];
-		yield [ PHP_INT_MAX / 100 ];
+		yield [PHP_INT_MAX];
+		yield [PHP_INT_MAX / 10];
+		yield [PHP_INT_MAX / 100];
 	}
 
 	public function testNewFromIntHandlesBigIntegers() {
-		$number = (int)floor( PHP_INT_MAX / 101 );
+		$number = (int) floor(PHP_INT_MAX / 101);
 
 		$this->assertSame(
 			$number * 100,
-			Euro::newFromInt( $number )->getEuroCents()
+			Euro::newFromInt($number)->getEuroCents()
 		);
 	}
 

Please login to merge, or discard this patch.

src/Euro.php 1 patch

Spacing +34 added lines, -34 removed lines patch added patch discarded remove patch

@@ -1,6 +1,6 @@  discard block
 block discarded – undo
 <?php
 
-declare( strict_types = 1 );
+declare(strict_types=1);
 
 namespace WMDE\Euro;
 
@@ -21,9 +21,9 @@  discard block
 block discarded – undo
 	 * @param int $cents
 	 * @throws InvalidArgumentException
 	 */
-	private function __construct( int $cents ) {
-		if ( $cents < 0 ) {
-			throw new InvalidArgumentException( 'Amount needs to be positive' );
+	private function __construct(int $cents) {
+		if ($cents < 0) {
+			throw new InvalidArgumentException('Amount needs to be positive');
 		}
 
 		$this->cents = $cents;
@@ -34,8 +34,8 @@  discard block
 block discarded – undo
 	 * @return self
 	 * @throws InvalidArgumentException
 	 */
-	public static function newFromCents( int $cents ): self {
-		return new self( $cents );
+	public static function newFromCents(int $cents): self {
+		return new self($cents);
 	}
 
 	/**
@@ -49,40 +49,40 @@  discard block
 block discarded – undo
 	 * @return self
 	 * @throws InvalidArgumentException
 	 */
-	public static function newFromString( string $euroAmount ): self {
-		if ( !is_numeric( $euroAmount ) ) {
-			throw new InvalidArgumentException( 'Not a number' );
+	public static function newFromString(string $euroAmount): self {
+		if (!is_numeric($euroAmount)) {
+			throw new InvalidArgumentException('Not a number');
 		}
 
-		if ( self::stringIsTooLong( $euroAmount ) ) {
-			throw new InvalidArgumentException( 'Number is too big' );
+		if (self::stringIsTooLong($euroAmount)) {
+			throw new InvalidArgumentException('Number is too big');
 		}
 
-		$parts = explode( '.', $euroAmount, 2 );
+		$parts = explode('.', $euroAmount, 2);
 
-		$euros = (int)$parts[0];
-		$cents = self::centsFromString( $parts[1] ?? '0' );
+		$euros = (int) $parts[0];
+		$cents = self::centsFromString($parts[1] ?? '0');
 
-		return new self( $euros * self::CENTS_PER_EURO + $cents );
+		return new self($euros * self::CENTS_PER_EURO + $cents);
 	}
 
-	private static function stringIsTooLong( string $euroString ): bool {
-		return strlen( $euroString ) + 2 > log10( PHP_INT_MAX );
+	private static function stringIsTooLong(string $euroString): bool {
+		return strlen($euroString) + 2 > log10(PHP_INT_MAX);
 	}
 
-	private static function centsFromString( string $cents ): int {
-		if ( strlen( $cents ) > self::DECIMAL_COUNT ) {
-			return self::roundCentsToInt( $cents );
+	private static function centsFromString(string $cents): int {
+		if (strlen($cents) > self::DECIMAL_COUNT) {
+			return self::roundCentsToInt($cents);
 		}
 
 		// Turn .1 into .10, so it ends up as 10 cents
-		return (int)str_pad( $cents, self::DECIMAL_COUNT, '0' );
+		return (int) str_pad($cents, self::DECIMAL_COUNT, '0');
 	}
 
-	private static function roundCentsToInt( string $cents ): int {
-		$centsInt = (int)substr( $cents, 0, self::DECIMAL_COUNT );
+	private static function roundCentsToInt(string $cents): int {
+		$centsInt = (int) substr($cents, 0, self::DECIMAL_COUNT);
 
-		if ( (int)$cents[self::DECIMAL_COUNT] >= 5 ) {
+		if ((int) $cents[self::DECIMAL_COUNT] >= 5) {
 			$centsInt++;
 		}
 
@@ -98,13 +98,13 @@  discard block
 block discarded – undo
 	 * @return self
 	 * @throws InvalidArgumentException
 	 */
-	public static function newFromFloat( float $euroAmount ): self {
-		return new self( intval(
+	public static function newFromFloat(float $euroAmount): self {
+		return new self(intval(
 			round(
-				round( $euroAmount, self::DECIMAL_COUNT ) * self::CENTS_PER_EURO,
+				round($euroAmount, self::DECIMAL_COUNT) * self::CENTS_PER_EURO,
 				0
 			)
-		) );
+		));
 	}
 
 	/**
@@ -112,12 +112,12 @@  discard block
 block discarded – undo
 	 * @return self
 	 * @throws InvalidArgumentException
 	 */
-	public static function newFromInt( int $euroAmount ): self {
-		if ( $euroAmount > floor( PHP_INT_MAX / 101 ) ) {
-			throw new InvalidArgumentException( 'Number is too big' );
+	public static function newFromInt(int $euroAmount): self {
+		if ($euroAmount > floor(PHP_INT_MAX / 101)) {
+			throw new InvalidArgumentException('Number is too big');
 		}
 
-		return new self( $euroAmount * self::CENTS_PER_EURO );
+		return new self($euroAmount * self::CENTS_PER_EURO);
 	}
 
 	public function getEuroCents(): int {
@@ -132,10 +132,10 @@  discard block
 block discarded – undo
 	 * Returns the euro amount as string with two decimals always present in format "42.00".
 	 */
 	public function getEuroString(): string {
-		return number_format( $this->getEuroFloat(), self::DECIMAL_COUNT, '.', '' );
+		return number_format($this->getEuroFloat(), self::DECIMAL_COUNT, '.', '');
 	}
 
-	public function equals( Euro $euro ): bool {
+	public function equals(Euro $euro): bool {
 		return $this->cents === $euro->cents;
 	}
 

Please login to merge, or discard this patch.

		@@ -1,6 +1,6 @@ discard block
		block discarded – undo
1	1	<?php
2	2
3		-declare( strict_types = 1 );
	3	+declare(strict_types=1);
4	4
5	5	namespace WMDE\Euro\Tests\Unit;
6	6
		@@ -19,201 +19,201 @@ discard block
		block discarded – undo
19	19	/**
20	20	* @dataProvider unsignedIntegerProvider
21	21	*/
22		- public function testGetCentsReturnsConstructorArgument( int $unsignedInteger ) {
23		- $amount = Euro::newFromCents( $unsignedInteger );
24		- $this->assertSame( $unsignedInteger, $amount->getEuroCents() );
	22	+ public function testGetCentsReturnsConstructorArgument(int $unsignedInteger) {
	23	+ $amount = Euro::newFromCents($unsignedInteger);
	24	+ $this->assertSame($unsignedInteger, $amount->getEuroCents());
25	25	}
26	26
27	27	public function unsignedIntegerProvider() {
28	28	return [
29		- [ 0 ], [ 1 ], [ 2 ], [ 9 ], [ 10 ], [ 11 ],
30		- [ 99 ], [ 100 ], [ 101 ], [ 999 ], [ 1000 ], [ 1001 ],
	29	+ [0], [1], [2], [9], [10], [11],
	30	+ [99], [100], [101], [999], [1000], [1001],
31	31	];
32	32	}
33	33
34	34	public function testGivenZero_getEuroFloatReturnsZeroFloat() {
35		- $amount = Euro::newFromCents( 0 );
36		- $this->assertExactFloat( 0.0, $amount->getEuroFloat() );
37		- $this->assertNotSame( 0, $amount->getEuroFloat() );
	35	+ $amount = Euro::newFromCents(0);
	36	+ $this->assertExactFloat(0.0, $amount->getEuroFloat());
	37	+ $this->assertNotSame(0, $amount->getEuroFloat());
38	38	}
39	39
40		- private function assertExactFloat( float $expected, $actual ) {
41		- $this->assertInternalType( 'float', $actual );
42		- $this->assertEquals( $expected, $actual, '', 0 );
	40	+ private function assertExactFloat(float $expected, $actual) {
	41	+ $this->assertInternalType('float', $actual);
	42	+ $this->assertEquals($expected, $actual, '', 0);
43	43	}
44	44
45	45	public function testGivenOneEuro_getEuroFloatReturnsOne() {
46		- $amount = Euro::newFromCents( 100 );
47		- $this->assertExactFloat( 1.0, $amount->getEuroFloat() );
	46	+ $amount = Euro::newFromCents(100);
	47	+ $this->assertExactFloat(1.0, $amount->getEuroFloat());
48	48	}
49	49
50	50	public function testGivenOneCent_getEuroFloatReturnsPointZeroOne() {
51		- $amount = Euro::newFromCents( 1 );
52		- $this->assertExactFloat( 0.01, $amount->getEuroFloat() );
	51	+ $amount = Euro::newFromCents(1);
	52	+ $this->assertExactFloat(0.01, $amount->getEuroFloat());
53	53	}
54	54
55	55	public function testGiven33cents_getEuroFloatReturnsPointThreeThree() {
56		- $amount = Euro::newFromCents( 33 );
57		- $this->assertExactFloat( 0.33, $amount->getEuroFloat() );
	56	+ $amount = Euro::newFromCents(33);
	57	+ $this->assertExactFloat(0.33, $amount->getEuroFloat());
58	58	}
59	59
60	60	public function testGivenNegativeAmount_constructorThrowsException() {
61		- $this->expectException( \InvalidArgumentException::class );
	61	+ $this->expectException(\InvalidArgumentException::class);
62	62	Euro::newFromCents( -1 );
63	63	}
64	64
65	65	public function testGivenZero_getEuroStringReturnsZeroString() {
66		- $amount = Euro::newFromCents( 0 );
67		- $this->assertSame( '0.00', $amount->getEuroString() );
	66	+ $amount = Euro::newFromCents(0);
	67	+ $this->assertSame('0.00', $amount->getEuroString());
68	68	}
69	69
70	70	public function testGivenOneEuro_getEuroStringReturnsOnePointZeroZero() {
71		- $amount = Euro::newFromCents( 100 );
72		- $this->assertSame( '1.00', $amount->getEuroString() );
	71	+ $amount = Euro::newFromCents(100);
	72	+ $this->assertSame('1.00', $amount->getEuroString());
73	73	}
74	74
75	75	public function testGivenTwoEuros_getEuroStringReturnsTwoPointZeroZero() {
76		- $amount = Euro::newFromCents( 200 );
77		- $this->assertSame( '2.00', $amount->getEuroString() );
	76	+ $amount = Euro::newFromCents(200);
	77	+ $this->assertSame('2.00', $amount->getEuroString());
78	78	}
79	79
80	80	public function testGivenOneCent_getEuroStringReturnsZeroPointZeroOne() {
81		- $amount = Euro::newFromCents( 1 );
82		- $this->assertSame( '0.01', $amount->getEuroString() );
	81	+ $amount = Euro::newFromCents(1);
	82	+ $this->assertSame('0.01', $amount->getEuroString());
83	83	}
84	84
85	85	public function testGivenTenCents_getEuroStringReturnsZeroPointOneZero() {
86		- $amount = Euro::newFromCents( 10 );
87		- $this->assertSame( '0.10', $amount->getEuroString() );
	86	+ $amount = Euro::newFromCents(10);
	87	+ $this->assertSame('0.10', $amount->getEuroString());
88	88	}
89	89
90	90	public function testGiven1234Cents_getEuroStringReturns12euro34() {
91		- $amount = Euro::newFromCents( 1234 );
92		- $this->assertSame( '12.34', $amount->getEuroString() );
	91	+ $amount = Euro::newFromCents(1234);
	92	+ $this->assertSame('12.34', $amount->getEuroString());
93	93	}
94	94
95	95	public function testOneEuroString_getsTurnedInto100cents() {
96		- $this->assertSame( 100, Euro::newFromString( '1.00' )->getEuroCents() );
	96	+ $this->assertSame(100, Euro::newFromString('1.00')->getEuroCents());
97	97	}
98	98
99	99	public function testOneCentString_getsTurnedInto1cents() {
100		- $this->assertSame( 1, Euro::newFromString( '0.01' )->getEuroCents() );
	100	+ $this->assertSame(1, Euro::newFromString('0.01')->getEuroCents());
101	101	}
102	102
103	103	public function testTenCentString_getsTurnedInto10cents() {
104		- $this->assertSame( 10, Euro::newFromString( '0.10' )->getEuroCents() );
	104	+ $this->assertSame(10, Euro::newFromString('0.10')->getEuroCents());
105	105	}
106	106
107	107	public function testShortTenCentString_getsTurnedInto10cents() {
108		- $this->assertSame( 10, Euro::newFromString( '0.1' )->getEuroCents() );
	108	+ $this->assertSame(10, Euro::newFromString('0.1')->getEuroCents());
109	109	}
110	110
111	111	public function testShortOneEuroString_getsTurnedInto100cents() {
112		- $this->assertSame( 100, Euro::newFromString( '1' )->getEuroCents() );
	112	+ $this->assertSame(100, Euro::newFromString('1')->getEuroCents());
113	113	}
114	114
115	115	public function testOneDecimalOneEuroString_getsTurnedInto100cents() {
116		- $this->assertSame( 100, Euro::newFromString( '1.0' )->getEuroCents() );
	116	+ $this->assertSame(100, Euro::newFromString('1.0')->getEuroCents());
117	117	}
118	118
119	119	public function testMultiDecimalOneEuroString_getsTurnedInto100cents() {
120		- $this->assertSame( 100, Euro::newFromString( '1.00000' )->getEuroCents() );
	120	+ $this->assertSame(100, Euro::newFromString('1.00000')->getEuroCents());
121	121	}
122	122
123	123	public function testHandlingOfLargeEuroString() {
124		- $this->assertSame( 3133742, Euro::newFromString( '31337.42' )->getEuroCents() );
	124	+ $this->assertSame(3133742, Euro::newFromString('31337.42')->getEuroCents());
125	125	}
126	126
127	127	public function testEuroStringThatCausedRoundingError_doesNotCauseRoundingError() {
128	128	// Regression test for https://phabricator.wikimedia.org/T183481
129		- $this->assertSame( 870, Euro::newFromString( '8.70' )->getEuroCents() );
130		- $this->assertSame( 920, Euro::newFromString( '9.20' )->getEuroCents() );
	129	+ $this->assertSame(870, Euro::newFromString('8.70')->getEuroCents());
	130	+ $this->assertSame(920, Euro::newFromString('9.20')->getEuroCents());
131	131	}
132	132
133	133	public function testEuroStringWithRoundingError_getsRoundedAppropriately() {
134		- $this->assertSame( 101, Euro::newFromString( '1.0100000001' )->getEuroCents() );
135		- $this->assertSame( 101, Euro::newFromString( '1.010000009999' )->getEuroCents() );
136		- $this->assertSame( 101, Euro::newFromString( '1.011' )->getEuroCents() );
137		- $this->assertSame( 101, Euro::newFromString( '1.014' )->getEuroCents() );
138		- $this->assertSame( 101, Euro::newFromString( '1.0149' )->getEuroCents() );
139		- $this->assertSame( 102, Euro::newFromString( '1.015' )->getEuroCents() );
140		- $this->assertSame( 102, Euro::newFromString( '1.019' )->getEuroCents() );
141		- $this->assertSame( 102, Euro::newFromString( '1.0199999' )->getEuroCents() );
142		- $this->assertSame( 870, Euro::newFromString( '8.701' )->getEuroCents() );
143		- $this->assertSame( 870, Euro::newFromString( '8.70499' )->getEuroCents() );
144		- $this->assertSame( 871, Euro::newFromString( '8.705' )->getEuroCents() );
145		- $this->assertSame( 871, Euro::newFromString( '8.705000' )->getEuroCents() );
146		- $this->assertSame( 871, Euro::newFromString( '8.705001' )->getEuroCents() );
147		- $this->assertSame( 871, Euro::newFromString( '8.709999' )->getEuroCents() );
	134	+ $this->assertSame(101, Euro::newFromString('1.0100000001')->getEuroCents());
	135	+ $this->assertSame(101, Euro::newFromString('1.010000009999')->getEuroCents());
	136	+ $this->assertSame(101, Euro::newFromString('1.011')->getEuroCents());
	137	+ $this->assertSame(101, Euro::newFromString('1.014')->getEuroCents());
	138	+ $this->assertSame(101, Euro::newFromString('1.0149')->getEuroCents());
	139	+ $this->assertSame(102, Euro::newFromString('1.015')->getEuroCents());
	140	+ $this->assertSame(102, Euro::newFromString('1.019')->getEuroCents());
	141	+ $this->assertSame(102, Euro::newFromString('1.0199999')->getEuroCents());
	142	+ $this->assertSame(870, Euro::newFromString('8.701')->getEuroCents());
	143	+ $this->assertSame(870, Euro::newFromString('8.70499')->getEuroCents());
	144	+ $this->assertSame(871, Euro::newFromString('8.705')->getEuroCents());
	145	+ $this->assertSame(871, Euro::newFromString('8.705000')->getEuroCents());
	146	+ $this->assertSame(871, Euro::newFromString('8.705001')->getEuroCents());
	147	+ $this->assertSame(871, Euro::newFromString('8.709999')->getEuroCents());
148	148	}
149	149
150	150	public function testGivenNegativeAmountString_exceptionIsThrown() {
151		- $this->expectException( \InvalidArgumentException::class );
152		- Euro::newFromString( '-1.00' );
	151	+ $this->expectException(\InvalidArgumentException::class);
	152	+ Euro::newFromString('-1.00');
153	153	}
154	154
155	155	public function testGivenStringWithComma_exceptionIsThrown() {
156		- $this->expectException( \InvalidArgumentException::class );
157		- Euro::newFromString( '1,00' );
	156	+ $this->expectException(\InvalidArgumentException::class);
	157	+ Euro::newFromString('1,00');
158	158	}
159	159
160	160	public function testGivenStringWithMultipleDots_ExceptionIsThrown() {
161		- $this->expectException( \InvalidArgumentException::class );
162		- Euro::newFromString( '1.0.0' );
	161	+ $this->expectException(\InvalidArgumentException::class);
	162	+ Euro::newFromString('1.0.0');
163	163	}
164	164
165	165	public function testGivenNonNumber_exceptionIsThrown() {
166		- $this->expectException( \InvalidArgumentException::class );
167		- Euro::newFromString( '1.00abc' );
	166	+ $this->expectException(\InvalidArgumentException::class);
	167	+ Euro::newFromString('1.00abc');
168	168	}
169	169
170	170	public function testGivenNegativeFloatAmount_exceptionIsThrown() {
171		- $this->expectException( \InvalidArgumentException::class );
	171	+ $this->expectException(\InvalidArgumentException::class);
172	172	Euro::newFromFloat( -1.00 );
173	173	}
174	174
175	175	public function testOneEuroFloat_getsTurnedInto100cents() {
176		- $this->assertSame( 100, Euro::newFromFloat( 1.0 )->getEuroCents() );
	176	+ $this->assertSame(100, Euro::newFromFloat(1.0)->getEuroCents());
177	177	}
178	178
179	179	public function testOneCentFloat_getsTurnedInto1cent() {
180		- $this->assertSame( 1, Euro::newFromFloat( 0.01 )->getEuroCents() );
	180	+ $this->assertSame(1, Euro::newFromFloat(0.01)->getEuroCents());
181	181	}
182	182
183	183	public function testTenCentFloat_getsTurnedInto10cents() {
184		- $this->assertSame( 10, Euro::newFromFloat( 0.1 )->getEuroCents() );
	184	+ $this->assertSame(10, Euro::newFromFloat(0.1)->getEuroCents());
185	185	}
186	186
187	187	public function testHandlingOfLargeEuroFloat() {
188		- $this->assertSame( 3133742, Euro::newFromFloat( 31337.42 )->getEuroCents() );
	188	+ $this->assertSame(3133742, Euro::newFromFloat(31337.42)->getEuroCents());
189	189	}
190	190
191	191	public function testFloatWithRoundingError_getsRoundedAppropriately() {
192		- $this->assertSame( 101, Euro::newFromFloat( 1.0100000001 )->getEuroCents() );
193		- $this->assertSame( 101, Euro::newFromFloat( 1.010000009999 )->getEuroCents() );
194		- $this->assertSame( 101, Euro::newFromFloat( 1.011 )->getEuroCents() );
195		- $this->assertSame( 101, Euro::newFromFloat( 1.014 )->getEuroCents() );
196		- $this->assertSame( 101, Euro::newFromFloat( 1.0149 )->getEuroCents() );
197		- $this->assertSame( 102, Euro::newFromFloat( 1.015 )->getEuroCents() );
198		- $this->assertSame( 102, Euro::newFromFloat( 1.019 )->getEuroCents() );
199		- $this->assertSame( 102, Euro::newFromFloat( 1.0199999 )->getEuroCents() );
200		- $this->assertSame( 870, Euro::newFromFloat( 8.70 )->getEuroCents() );
	192	+ $this->assertSame(101, Euro::newFromFloat(1.0100000001)->getEuroCents());
	193	+ $this->assertSame(101, Euro::newFromFloat(1.010000009999)->getEuroCents());
	194	+ $this->assertSame(101, Euro::newFromFloat(1.011)->getEuroCents());
	195	+ $this->assertSame(101, Euro::newFromFloat(1.014)->getEuroCents());
	196	+ $this->assertSame(101, Euro::newFromFloat(1.0149)->getEuroCents());
	197	+ $this->assertSame(102, Euro::newFromFloat(1.015)->getEuroCents());
	198	+ $this->assertSame(102, Euro::newFromFloat(1.019)->getEuroCents());
	199	+ $this->assertSame(102, Euro::newFromFloat(1.0199999)->getEuroCents());
	200	+ $this->assertSame(870, Euro::newFromFloat(8.70)->getEuroCents());
201	201	}
202	202
203	203	public function testZeroEuroIntegers_isZeroCents() {
204		- $this->assertSame( 0, Euro::newFromInt( 0 )->getEuroCents() );
	204	+ $this->assertSame(0, Euro::newFromInt(0)->getEuroCents());
205	205	}
206	206
207	207	public function testOneEuroIntegers_is100cents() {
208		- $this->assertSame( 100, Euro::newFromInt( 1 )->getEuroCents() );
	208	+ $this->assertSame(100, Euro::newFromInt(1)->getEuroCents());
209	209	}
210	210
211	211	public function test1337EuroIntegers_is133700cents() {
212		- $this->assertSame( 133700, Euro::newFromInt( 1337 )->getEuroCents() );
	212	+ $this->assertSame(133700, Euro::newFromInt(1337)->getEuroCents());
213	213	}
214	214
215	215	public function testGivenNegativeIntegerAmount_exceptionIsThrown() {
216		- $this->expectException( \InvalidArgumentException::class );
	216	+ $this->expectException(\InvalidArgumentException::class);
217	217	Euro::newFromInt( -1 );
218	218	}
219	219
		@@ -221,78 +221,78 @@ discard block
		block discarded – undo
221	221	* @dataProvider euroProvider
222	222	* @param Euro $euro
223	223	*/
224		- public function testEuroEqualsItself( Euro $euro ) {
225		- $this->assertTrue( $euro->equals( clone $euro ) );
	224	+ public function testEuroEqualsItself(Euro $euro) {
	225	+ $this->assertTrue($euro->equals(clone $euro));
226	226	}
227	227
228	228	public function euroProvider() {
229	229	return [
230		- [ Euro::newFromCents( 0 ) ],
231		- [ Euro::newFromCents( 1 ) ],
232		- [ Euro::newFromCents( 99 ) ],
233		- [ Euro::newFromCents( 100 ) ],
234		- [ Euro::newFromCents( 9999 ) ],
	230	+ [Euro::newFromCents(0)],
	231	+ [Euro::newFromCents(1)],
	232	+ [Euro::newFromCents(99)],
	233	+ [Euro::newFromCents(100)],
	234	+ [Euro::newFromCents(9999)],
235	235	];
236	236	}
237	237
238	238	public function testOneCentDoesNotEqualOneEuro() {
239		- $this->assertFalse( Euro::newFromCents( 1 )->equals( Euro::newFromInt( 1 ) ) );
	239	+ $this->assertFalse(Euro::newFromCents(1)->equals(Euro::newFromInt(1)));
240	240	}
241	241
242	242	public function testOneCentDoesNotEqualTwoCents() {
243		- $this->assertFalse( Euro::newFromCents( 1 )->equals( Euro::newFromCents( 2 ) ) );
	243	+ $this->assertFalse(Euro::newFromCents(1)->equals(Euro::newFromCents(2)));
244	244	}
245	245
246	246	public function testOneCentDoesNotEqualOneEuroAndOneCent() {
247		- $this->assertFalse( Euro::newFromCents( 1 )->equals( Euro::newFromCents( 101 ) ) );
	247	+ $this->assertFalse(Euro::newFromCents(1)->equals(Euro::newFromCents(101)));
248	248	}
249	249
250	250	public function test9001centsDoesNotEqual9000cents() {
251		- $this->assertFalse( Euro::newFromCents( 9001 )->equals( Euro::newFromCents( 9000 ) ) );
	251	+ $this->assertFalse(Euro::newFromCents(9001)->equals(Euro::newFromCents(9000)));
252	252	}
253	253
254	254	/**
255	255	* @dataProvider tooLongStringProvider
256	256	*/
257		- public function testNewFromStringThrowsExceptionWhenStringIsTooLong( string $string ) {
258		- $this->expectException( InvalidArgumentException::class );
259		- $this->expectExceptionMessage( 'Number is too big' );
	257	+ public function testNewFromStringThrowsExceptionWhenStringIsTooLong(string $string) {
	258	+ $this->expectException(InvalidArgumentException::class);
	259	+ $this->expectExceptionMessage('Number is too big');
260	260
261		- Euro::newFromString( $string );
	261	+ Euro::newFromString($string);
262	262	}
263	263
264	264	public function tooLongStringProvider() {
265		- yield [ '1111111111111111111111111111111' ];
266		- yield [ (string)PHP_INT_MAX ];
267		- yield [ substr( (string)PHP_INT_MAX, 0, -2 ) ];
	265	+ yield ['1111111111111111111111111111111'];
	266	+ yield [(string) PHP_INT_MAX];
	267	+ yield [substr((string) PHP_INT_MAX, 0, -2)];
268	268	}
269	269
270	270	public function testNewFromStringHandlesLongStrings() {
271		- Euro::newFromString( substr( (string)PHP_INT_MAX, 0, -3 ) );
272		- $this->assertTrue( true );
	271	+ Euro::newFromString(substr((string) PHP_INT_MAX, 0, -3));
	272	+ $this->assertTrue(true);
273	273	}
274	274
275	275	/**
276	276	* @dataProvider tooHighIntegerProvider
277	277	*/
278		- public function testNewFromIntThrowsExceptionWhenIntegerIsTooHigh( int $int ) {
279		- $this->expectException( InvalidArgumentException::class );
280		- $this->expectExceptionMessage( 'Number is too big' );
281		- Euro::newFromInt( $int );
	278	+ public function testNewFromIntThrowsExceptionWhenIntegerIsTooHigh(int $int) {
	279	+ $this->expectException(InvalidArgumentException::class);
	280	+ $this->expectExceptionMessage('Number is too big');
	281	+ Euro::newFromInt($int);
282	282	}
283	283
284	284	public function tooHighIntegerProvider() {
285		- yield [ PHP_INT_MAX ];
286		- yield [ PHP_INT_MAX / 10 ];
287		- yield [ PHP_INT_MAX / 100 ];
	285	+ yield [PHP_INT_MAX];
	286	+ yield [PHP_INT_MAX / 10];
	287	+ yield [PHP_INT_MAX / 100];
288	288	}
289	289
290	290	public function testNewFromIntHandlesBigIntegers() {
291		- $number = (int)floor( PHP_INT_MAX / 101 );
	291	+ $number = (int) floor(PHP_INT_MAX / 101);
292	292
293	293	$this->assertSame(
294	294	$number * 100,
295		- Euro::newFromInt( $number )->getEuroCents()
	295	+ Euro::newFromInt($number)->getEuroCents()
296	296	);
297	297	}
298	298

wmde / Euro

Pull Request — master (#9)

Status

Category

Spacing +110 added lines, -110 removed lines patch added patch discarded remove patch

Spacing +34 added lines, -34 removed lines patch added patch discarded remove patch