ParserOptionsTest::testRequireOption() - Code Metrics - Inspection of "Modernize" - DataValues/Interfaces - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#50)

by Jeroen De

created 2019-09-20 13:07 UTC

ParserOptionsTest::testRequireOption() A

↳ Parent: ParserOptionsTest

Complexity

Conditions	2
Paths	2

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	17
rs	9.7
c	0
b	0
f	0
cc	2
nc	2
nop	0

<?php

namespace ValueParsers\Tests;

use PHPUnit\Framework\TestCase;
use ValueParsers\ParserOptions;

/**
 * @covers \ValueParsers\ParserOptions
 *
 * @group ValueParsers
 * @group DataValueExtensions
 *
 * @license GPL-2.0+
 * @author Jeroen De Dauw < [email protected] >
 */
class ParserOptionsTest extends TestCase {

	public function testConstructor() {
		$options = [
			'foo' => 42,
			'bar' => 4.2,
			'baz' => [ 'o_O', false, null, '42' => 42, [] ]
		];

		$parserOptions = new ParserOptions( $options );

		foreach ( $options as $option => $value ) {
			$this->assertSame(
				serialize( $value ),
				serialize( $parserOptions->getOption( $option ) ),
				'Option should be set properly'
			);
		}

		$this->assertFalse( $parserOptions->hasOption( 'ohi' ) );
	}

	public function testConstructorFail() {
		$options = [
			'foo' => 42,
			'bar' => 4.2,
			42 => [ 'o_O', false, null, '42' => 42, [] ]
		];

		$this->expectException( 'Exception' );

		new ParserOptions( $options );
	}

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

		$parserOptions = new ParserOptions();

		$argLists[] = [ $parserOptions, 'foo', 42 ];
		$argLists[] = [ $parserOptions, 'bar', 42 ];
		$argLists[] = [ $parserOptions, 'foo', 'foo' ];
		$argLists[] = [ $parserOptions, 'foo', null ];

		return $argLists;
	}

	/**
	 * @dataProvider setOptionProvider
	 */
	public function testSetAndGetOption( ParserOptions $options, $option, $value ) {
		$options->setOption( $option, $value );

		$this->assertEquals(
			$value,
			$options->getOption( $option ),
			'Setting an option should work'
		);
	}

	public function testHashOption() {
		$options = [
			'foo' => 42,
			'bar' => 4.2,
			'baz' => [ 'o_O', false, null, '42' => 42, [] ]
		];

		$parserOptions = new ParserOptions( $options );

		foreach ( array_keys( $options ) as $option ) {
			$this->assertTrue( $parserOptions->hasOption( $option ) );
		}

		$this->assertFalse( $parserOptions->hasOption( 'ohi' ) );
		$this->assertFalse( $parserOptions->hasOption( 'Foo' ) );
	}

	public function testSetOption() {
		$parserOptions = new ParserOptions( [ 'foo' => 'bar' ] );

		$values = [
			[ 'foo', 'baz' ],
			[ 'foo', 'bar' ],
			[ 'onoez', '' ],
			[ 'hax', 'zor' ],
			[ 'nyan', 9001 ],
			[ 'cat', 4.2 ],
			[ 'spam', [ '~=[,,_,,]:3' ] ],
		];

		foreach ( $values as $value ) {
			$parserOptions->setOption( $value[0], $value[1] );
			$this->assertSame( $value[1], $parserOptions->getOption( $value[0] ) );
		}
	}

	/**
	 * @dataProvider nonExistingOptionsProvider
	 */
	public function testGetOption( $nonExistingOption ) {
		$this->assertTrue( true );
		$formatterOptions = new ParserOptions( [ 'foo' => 'bar' ] );

		$this->expectException( 'InvalidArgumentException' );

		$formatterOptions->getOption( $nonExistingOption );
	}

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

		$argLists[] = [ 'bar' ];
		$argLists[] = [ 'Foo' ];
		$argLists[] = [ 'FOO' ];
		$argLists[] = [ 'spam' ];
		$argLists[] = [ 'onoez' ];

		return $argLists;
	}

	public function testRequireOption() {
		$options = [
			'foo' => 42,
			'bar' => 4.2,
			'baz' => [ 'o_O', false, null, '42' => 42, [] ]
		];

		$parserOptions = new ParserOptions( $options );

		foreach ( array_keys( $options ) as $option ) {
			$parserOptions->requireOption( $option );
		}

		$this->expectException( 'Exception' );

		$parserOptions->requireOption( 'Foo' );
	}

	public function testDefaultOption() {
		$options = [
			'foo' => 42,
			'bar' => 4.2,
			'baz' => [ 'o_O', false, null, '42' => 42, [] ]
		];

		$parserOptions = new ParserOptions( $options );

		foreach ( $options as $option => $value ) {
			$parserOptions->defaultOption( $option, 9001 );

			$this->assertSame(
				serialize( $value ),
				serialize( $parserOptions->getOption( $option ) ),
				'Defaulting a set option should not affect its value'
			);
		}

		$defaults = [
			'N' => 42,
			'y' => 4.2,
			'a' => false,
			'n' => [ '42' => 42, [ '' ] ]
		];

		foreach ( $defaults as $option => $value ) {
			$parserOptions->defaultOption( $option, $value );

			$this->assertSame(
				serialize( $value ),
				serialize( $parserOptions->getOption( $option ) ),
				'Defaulting a not set option should affect its value'
			);
		}
	}

}


1			<?php
2
3			namespace ValueParsers\Tests;
4
5			use PHPUnit\Framework\TestCase;
6			use ValueParsers\ParserOptions;
7
8			/**
9			* @covers \ValueParsers\ParserOptions
10			*
11			* @group ValueParsers
12			* @group DataValueExtensions
13			*
14			* @license GPL-2.0+
15			* @author Jeroen De Dauw < [email protected] >
16			*/
17			class ParserOptionsTest extends TestCase {
18
19			public function testConstructor() {
20			$options = [
21			'foo' => 42,
22			'bar' => 4.2,
23			'baz' => [ 'o_O', false, null, '42' => 42, [] ]
24			];
25
26			$parserOptions = new ParserOptions( $options );
27
28			foreach ( $options as $option => $value ) {
29			$this->assertSame(
30			serialize( $value ),
31			serialize( $parserOptions->getOption( $option ) ),
32			'Option should be set properly'
33			);
34			}
35
36			$this->assertFalse( $parserOptions->hasOption( 'ohi' ) );
37			}
38
39			public function testConstructorFail() {
40			$options = [
41			'foo' => 42,
42			'bar' => 4.2,
43			42 => [ 'o_O', false, null, '42' => 42, [] ]
44			];
45
46			$this->expectException( 'Exception' );
47
48			new ParserOptions( $options );
49			}
50
51			public function setOptionProvider() {
52			$argLists = [];
53
54			$parserOptions = new ParserOptions();
55
56			$argLists[] = [ $parserOptions, 'foo', 42 ];
57			$argLists[] = [ $parserOptions, 'bar', 42 ];
58			$argLists[] = [ $parserOptions, 'foo', 'foo' ];
59			$argLists[] = [ $parserOptions, 'foo', null ];
60
61			return $argLists;
62			}
63
64			/**
65			* @dataProvider setOptionProvider
66			*/
67			public function testSetAndGetOption( ParserOptions $options, $option, $value ) {
68			$options->setOption( $option, $value );
69
70			$this->assertEquals(
71			$value,
72			$options->getOption( $option ),
73			'Setting an option should work'
74			);
75			}
76
77			public function testHashOption() {
78			$options = [
79			'foo' => 42,
80			'bar' => 4.2,
81			'baz' => [ 'o_O', false, null, '42' => 42, [] ]
82			];
83
84			$parserOptions = new ParserOptions( $options );
85
86			foreach ( array_keys( $options ) as $option ) {
87			$this->assertTrue( $parserOptions->hasOption( $option ) );
88			}
89
90			$this->assertFalse( $parserOptions->hasOption( 'ohi' ) );
91			$this->assertFalse( $parserOptions->hasOption( 'Foo' ) );
92			}
93
94			public function testSetOption() {
95			$parserOptions = new ParserOptions( [ 'foo' => 'bar' ] );
96
97			$values = [
98			[ 'foo', 'baz' ],
99			[ 'foo', 'bar' ],
100			[ 'onoez', '' ],
101			[ 'hax', 'zor' ],
102			[ 'nyan', 9001 ],
103			[ 'cat', 4.2 ],
104			[ 'spam', [ '~=[,,_,,]:3' ] ],
105			];
106
107			foreach ( $values as $value ) {
108			$parserOptions->setOption( $value[0], $value[1] );
109			$this->assertSame( $value[1], $parserOptions->getOption( $value[0] ) );
110			}
111			}
112
113			/**
114			* @dataProvider nonExistingOptionsProvider
115			*/
116			public function testGetOption( $nonExistingOption ) {
117			$this->assertTrue( true );
118			$formatterOptions = new ParserOptions( [ 'foo' => 'bar' ] );
119
120			$this->expectException( 'InvalidArgumentException' );
121
122			$formatterOptions->getOption( $nonExistingOption );
123			}
124
125			public function nonExistingOptionsProvider() {
126			$argLists = [];
127
128			$argLists[] = [ 'bar' ];
129			$argLists[] = [ 'Foo' ];
130			$argLists[] = [ 'FOO' ];
131			$argLists[] = [ 'spam' ];
132			$argLists[] = [ 'onoez' ];
133
134			return $argLists;
135			}
136
137			public function testRequireOption() {
138			$options = [
139			'foo' => 42,
140			'bar' => 4.2,
141			'baz' => [ 'o_O', false, null, '42' => 42, [] ]
142			];
143
144			$parserOptions = new ParserOptions( $options );
145
146			foreach ( array_keys( $options ) as $option ) {
147			$parserOptions->requireOption( $option );
148			}
149
150			$this->expectException( 'Exception' );
151
152			$parserOptions->requireOption( 'Foo' );
153			}
154
155			public function testDefaultOption() {
156			$options = [
157			'foo' => 42,
158			'bar' => 4.2,
159			'baz' => [ 'o_O', false, null, '42' => 42, [] ]
160			];
161
162			$parserOptions = new ParserOptions( $options );
163
164			foreach ( $options as $option => $value ) {
165			$parserOptions->defaultOption( $option, 9001 );
166
167			$this->assertSame(
168			serialize( $value ),
169			serialize( $parserOptions->getOption( $option ) ),
170			'Defaulting a set option should not affect its value'
171			);
172			}
173
174			$defaults = [
175			'N' => 42,
176			'y' => 4.2,
177			'a' => false,
178			'n' => [ '42' => 42, [ '' ] ]
179			];
180
181			foreach ( $defaults as $option => $value ) {
182			$parserOptions->defaultOption( $option, $value );
183
184			$this->assertSame(
185			serialize( $value ),
186			serialize( $parserOptions->getOption( $option ) ),
187			'Defaulting a not set option should affect its value'
188			);
189			}
190			}
191
192			}
193

DataValues / Interfaces

Pull Request — master (#50)

ParserOptionsTest::testRequireOption() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like