EnumMapTest::testDeprecatedGetEnumClass() - Code Metrics - Inspection of "fix #68: removed deprecated" - marc-mabe/php-enum - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 9803f7...848250 )

by Marc

created 2017-07-02 11:58 UTC

EnumMapTest::testDeprecatedGetEnumClass() A

↳ Parent: EnumMapTest::testBasicWithConstantValuesAsEnums()

Complexity

Conditions	1
Paths	1

Size

Total Lines	5
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

<?php

namespace MabeEnumTest;

use MabeEnum\EnumMap;
use MabeEnumTest\TestAsset\EnumBasic;
use MabeEnumTest\TestAsset\EnumInheritance;
use PHPUnit_Framework_TestCase as TestCase;
use ReflectionClass;

/**
 * Unit tests for the class MabeEnum\EnumMap
 *
 * @link http://github.com/marc-mabe/php-enum for the canonical source repository
 * @copyright Copyright (c) 2015 Marc Bennewitz
 * @license http://github.com/marc-mabe/php-enum/blob/master/LICENSE.txt New BSD License
 */
class EnumMapTest extends TestCase
{
    public function testBasic()
    {
        $enumMap = new EnumMap('MabeEnumTest\TestAsset\EnumBasic');
        $this->assertSame('MabeEnumTest\TestAsset\EnumBasic', $enumMap->getEnumeration());

        $enum1  = EnumBasic::ONE();
        $value1 = 'value1';

        $enum2  = EnumBasic::TWO();
        $value2 = 'value2';

        $this->assertFalse($enumMap->contains($enum1));
        $this->assertNull($enumMap->attach($enum1, $value1));
        $this->assertTrue($enumMap->contains($enum1));
        $this->assertSame($value1, $enumMap[$enum1]);
        $this->assertSame(spl_object_hash($enum1), $enumMap->getHash($enum1));

        $this->assertFalse($enumMap->contains($enum2));
        $this->assertNull($enumMap->attach($enum2, $value2));
        $this->assertTrue($enumMap->contains($enum2));
        $this->assertSame($value2, $enumMap[$enum2]);
        $this->assertSame(spl_object_hash($enum2), $enumMap->getHash($enum2));

        $this->assertNull($enumMap->detach($enum1));
        $this->assertFalse($enumMap->contains($enum1));

        $this->assertNull($enumMap->detach($enum2));
        $this->assertFalse($enumMap->contains($enum2));
    }

    public function testBasicWithConstantValuesAsEnums()
    {
        $enumMap = new EnumMap('MabeEnumTest\TestAsset\EnumBasic');

        $enum1  = EnumBasic::ONE;
        $value1 = 'value1';

        $enum2  = EnumBasic::TWO;
        $value2 = 'value2';

        $this->assertFalse($enumMap->contains($enum1));
        $this->assertNull($enumMap->attach($enum1, $value1));
        $this->assertTrue($enumMap->contains($enum1));
        $this->assertSame($value1, $enumMap[$enum1]);
        $this->assertSame(spl_object_hash(EnumBasic::ONE()), $enumMap->getHash($enum1));

        $this->assertFalse($enumMap->contains($enum2));
        $this->assertNull($enumMap->attach($enum2, $value2));
        $this->assertTrue($enumMap->contains($enum2));
        $this->assertSame($value2, $enumMap[$enum2]);
        $this->assertSame(spl_object_hash(EnumBasic::TWO()), $enumMap->getHash($enum2));

        $this->assertNull($enumMap->detach($enum1));
        $this->assertFalse($enumMap->contains($enum1));

        $this->assertNull($enumMap->detach($enum2));
        $this->assertFalse($enumMap->contains($enum2));
    }

    public function testIterate()
    {
        $enumMap = new EnumMap('MabeEnumTest\TestAsset\EnumBasic');

        $enum1  = EnumBasic::ONE();
        $value1 = 'value1';

        $enum2  = EnumBasic::TWO();
        $value2 = 'value2';

        // an empty enum map needs to be invalid, starting by 0
        $enumMap->rewind();
        $this->assertSame(0, $enumMap->count());
        $this->assertFalse($enumMap->valid());

        // attach
        $enumMap->attach($enum1, $value2);
        $enumMap->attach($enum2, $value1);

        // a not empty enum map should be valid, starting by 0 (if not iterated)
        $enumMap->rewind();
        $this->assertSame(2, $enumMap->count());
        $this->assertTrue($enumMap->valid());
        $this->assertSame(0, $enumMap->key());
        $this->assertSame($enum1, $enumMap->current());

        // go to the next element (last)
        $this->assertNull($enumMap->next());
        $this->assertTrue($enumMap->valid());
        $this->assertSame(1, $enumMap->key());
        $this->assertSame($enum2, $enumMap->current());

        // go to the next element (out of range)
        $this->assertNull($enumMap->next());
        $this->assertFalse($enumMap->valid());
        $this->assertSame(2, $enumMap->key());

        // rewind will set the iterator position back to 0
        $enumMap->rewind();
        $this->assertTrue($enumMap->valid());
        $this->assertSame(0, $enumMap->key());
        $this->assertSame($enum1, $enumMap->current());
    }

    public function testIterateWithFlags()
    {
        $enumMap = new EnumMap(
            'MabeEnumTest\TestAsset\EnumBasic',
            EnumMap::KEY_AS_INDEX | EnumMap::CURRENT_AS_ENUM
        );

        $enumMap->attach(EnumBasic::TWO(), 'first');
        $enumMap->attach(EnumBasic::ONE(), 'second');

        // EnumMap::KEY_AS_INDEX | EnumMap::CURRENT_AS_ENUM (first)
        $this->assertSame(EnumMap::KEY_AS_INDEX | EnumMap::CURRENT_AS_ENUM, $enumMap->getFlags());

        $enumMap->rewind();
        $this->assertSame(0, $enumMap->key());
        $this->assertSame(EnumBasic::TWO(), $enumMap->current());

        $enumMap->next();
        $this->assertSame(1, $enumMap->key());
        $this->assertSame(EnumBasic::ONE(), $enumMap->current());

        // EnumMap::KEY_AS_NAME | EnumMap::CURRENT_AS_DATA
        $enumMap->setFlags(EnumMap::KEY_AS_NAME | EnumMap::CURRENT_AS_DATA);
        $this->assertSame(EnumMap::KEY_AS_NAME | EnumMap::CURRENT_AS_DATA, $enumMap->getFlags());

        $enumMap->rewind();
        $this->assertSame('TWO', $enumMap->key());
        $this->assertSame('first', $enumMap->current());

        $enumMap->next();
        $this->assertSame('ONE', $enumMap->key());
        $this->assertSame('second', $enumMap->current());

        // EnumMap::KEY_AS_VALUE | EnumMap::CURRENT_AS_ORDINAL
        $enumMap->setFlags(EnumMap::KEY_AS_VALUE | EnumMap::CURRENT_AS_ORDINAL);
        $this->assertSame(EnumMap::KEY_AS_VALUE | EnumMap::CURRENT_AS_ORDINAL, $enumMap->getFlags());

        $enumMap->rewind();
        $this->assertSame(2, $enumMap->key());
        $this->assertSame(1, $enumMap->current());

        $enumMap->next();
        $this->assertSame(1, $enumMap->key());
        $this->assertSame(0, $enumMap->current());

        // EnumMap::KEY_AS_ORDINAL | EnumMap::CURRENT_AS_VALUE
        $enumMap->setFlags(EnumMap::KEY_AS_ORDINAL | EnumMap::CURRENT_AS_VALUE);
        $this->assertSame(EnumMap::KEY_AS_ORDINAL | EnumMap::CURRENT_AS_VALUE, $enumMap->getFlags());
    
        $enumMap->rewind();
        $this->assertSame(1, $enumMap->key());
        $this->assertSame(2, $enumMap->current());
    
        $enumMap->next();
        $this->assertSame(0, $enumMap->key());
        $this->assertSame(1, $enumMap->current());

        // only change current flag to EnumMap::CURRENT_AS_NAME
        $enumMap->setFlags(EnumMap::CURRENT_AS_NAME);
        $this->assertSame(EnumMap::KEY_AS_ORDINAL | EnumMap::CURRENT_AS_NAME, $enumMap->getFlags());

        $enumMap->rewind();
        $this->assertSame(1, $enumMap->key());
        $this->assertSame('TWO', $enumMap->current());

        $enumMap->next();
        $this->assertSame(0, $enumMap->key());
        $this->assertSame('ONE', $enumMap->current());

        // only change key flag to EnumMap::NAME_AS_NAME
        $enumMap->setFlags(EnumMap::KEY_AS_NAME);
        $this->assertSame(EnumMap::KEY_AS_NAME | EnumMap::CURRENT_AS_NAME, $enumMap->getFlags());

        $enumMap->rewind();
        $this->assertSame('TWO', $enumMap->key());
        $this->assertSame('TWO', $enumMap->current());

        $enumMap->next();
        $this->assertSame('ONE', $enumMap->key());
        $this->assertSame('ONE', $enumMap->current());
    }

    public function testArrayAccessWithObjects()
    {
        $enumMap = new EnumMap('MabeEnumTest\TestAsset\EnumBasic');

        $enumMap[EnumBasic::ONE()] = 'first';
        $enumMap[EnumBasic::TWO()] = 'second';

        $this->assertTrue(isset($enumMap[EnumBasic::ONE()]));
        $this->assertTrue(isset($enumMap[EnumBasic::TWO()]));

        $this->assertSame('first', $enumMap[EnumBasic::ONE()]);
        $this->assertSame('second', $enumMap[EnumBasic::TWO()]);

        unset($enumMap[EnumBasic::ONE()], $enumMap[EnumBasic::TWO()]);

        $this->assertFalse(isset($enumMap[EnumBasic::ONE()]));
        $this->assertFalse(isset($enumMap[EnumBasic::TWO()]));
    }

    public function testArrayAccessWithValues()
    {
        $enumMap = new EnumMap('MabeEnumTest\TestAsset\EnumBasic');

        $enumMap[EnumBasic::ONE] = 'first';
        $enumMap[EnumBasic::TWO] = 'second';

        $this->assertTrue(isset($enumMap[EnumBasic::ONE]));
        $this->assertTrue(isset($enumMap[EnumBasic::TWO]));

        $this->assertSame('first', $enumMap[EnumBasic::ONE]);
        $this->assertSame('second', $enumMap[EnumBasic::TWO]);

        unset($enumMap[EnumBasic::ONE], $enumMap[EnumBasic::TWO]);

        $this->assertFalse(isset($enumMap[EnumBasic::ONE]));
        $this->assertFalse(isset($enumMap[EnumBasic::TWO]));
    }

    public function testConstructThrowsInvalidArgumentExceptionIfEnumClassDoesNotExtendBaseEnum()
    {
        $this->setExpectedException('InvalidArgumentException');
        new EnumMap('stdClass');
    }

    public function testSetFlagsThrowsInvalidArgumentExceptionOnUnsupportedKeyFlag()
    {
        $enumMap = new EnumMap('MabeEnumTest\TestAsset\EnumBasic');

        $this->setExpectedException('InvalidArgumentException');
        $enumMap->setFlags(5);
    }

    public function testCurrentThrowsRuntimeExceptionOnInvalidFlag()
    {
        $enumMap = new EnumMap('MabeEnumTest\TestAsset\EnumBasic');
        $enumMap->attach(EnumBasic::ONE());
        $enumMap->rewind();

        // change internal flags to an invalid current flag
        $reflectionClass = new ReflectionClass($enumMap);
        $reflectionProp  = $reflectionClass->getProperty('flags');
        $reflectionProp->setAccessible(true);
        $reflectionProp->setValue($enumMap, 0);

        $this->setExpectedException('RuntimeException');
        $enumMap->current();
    }

    public function testKeyThrowsRuntimeExceptionOnInvalidFlag()
    {
        $enumMap = new EnumMap('MabeEnumTest\TestAsset\EnumBasic');
        $enumMap->attach(EnumBasic::ONE());
        $enumMap->rewind();

        // change internal flags to an invalid current flag
        $reflectionClass = new ReflectionClass($enumMap);
        $reflectionProp  = $reflectionClass->getProperty('flags');
        $reflectionProp->setAccessible(true);
        $reflectionProp->setValue($enumMap, 0);

        $this->setExpectedException('RuntimeException');
        $enumMap->key();
    }

    public function testSetFlagsThrowsInvalidArgumentExceptionOnUnsupportedCurrentFlag()
    {
        $enumMap = new EnumMap('MabeEnumTest\TestAsset\EnumBasic');

        $this->setExpectedException('InvalidArgumentException');
        $enumMap->setFlags(48);
    }

    public function testInitEnumThrowsInvalidArgumentExceptionOnInvalidEnumGiven()
    {
        $enumMap = new EnumMap('MabeEnumTest\TestAsset\EnumBasic');

        $this->setExpectedException('InvalidArgumentException');
        $enumMap->offsetSet(EnumInheritance::INHERITANCE(), 'test');
    }

    public function testContainsAndOffsetExistsReturnsFalseOnInvalidEnum()
    {
        $enumMap = new EnumMap('MabeEnumTest\TestAsset\EnumBasic');

        $this->assertFalse($enumMap->contains(EnumInheritance::INHERITANCE()));
        $this->assertFalse($enumMap->contains(EnumInheritance::INHERITANCE));

        $this->assertFalse(isset($enumMap[EnumInheritance::INHERITANCE()]));
        $this->assertFalse(isset($enumMap[EnumInheritance::INHERITANCE]));
    }
}


1		<?php
2
3		namespace MabeEnumTest;
4
5		use MabeEnum\EnumMap;
6		use MabeEnumTest\TestAsset\EnumBasic;
7		use MabeEnumTest\TestAsset\EnumInheritance;
8		use PHPUnit_Framework_TestCase as TestCase;
9		use ReflectionClass;
10
11		/**
12		* Unit tests for the class MabeEnum\EnumMap
13		*
14		* @link http://github.com/marc-mabe/php-enum for the canonical source repository
15		* @copyright Copyright (c) 2015 Marc Bennewitz
16		* @license http://github.com/marc-mabe/php-enum/blob/master/LICENSE.txt New BSD License
17		*/
18		class EnumMapTest extends TestCase
19		{
20		public function testBasic()
21		{
22		$enumMap = new EnumMap('MabeEnumTest\TestAsset\EnumBasic');
23		$this->assertSame('MabeEnumTest\TestAsset\EnumBasic', $enumMap->getEnumeration());
24
25		$enum1 = EnumBasic::ONE();
26		$value1 = 'value1';
27
28		$enum2 = EnumBasic::TWO();
29		$value2 = 'value2';
30
31		$this->assertFalse($enumMap->contains($enum1));
32		$this->assertNull($enumMap->attach($enum1, $value1));
33		$this->assertTrue($enumMap->contains($enum1));
34		$this->assertSame($value1, $enumMap[$enum1]);
35		$this->assertSame(spl_object_hash($enum1), $enumMap->getHash($enum1));
36
37		$this->assertFalse($enumMap->contains($enum2));
38		$this->assertNull($enumMap->attach($enum2, $value2));
39		$this->assertTrue($enumMap->contains($enum2));
40		$this->assertSame($value2, $enumMap[$enum2]);
41		$this->assertSame(spl_object_hash($enum2), $enumMap->getHash($enum2));
42
43		$this->assertNull($enumMap->detach($enum1));
44		$this->assertFalse($enumMap->contains($enum1));
45
46		$this->assertNull($enumMap->detach($enum2));
47		$this->assertFalse($enumMap->contains($enum2));
48		}
49
50		public function testBasicWithConstantValuesAsEnums()
51		{
52		$enumMap = new EnumMap('MabeEnumTest\TestAsset\EnumBasic');
53
54		$enum1 = EnumBasic::ONE;
55		$value1 = 'value1';
56
57		$enum2 = EnumBasic::TWO;
58		$value2 = 'value2';
59
60		$this->assertFalse($enumMap->contains($enum1));
61		$this->assertNull($enumMap->attach($enum1, $value1));
62		$this->assertTrue($enumMap->contains($enum1));
63		$this->assertSame($value1, $enumMap[$enum1]);
64		$this->assertSame(spl_object_hash(EnumBasic::ONE()), $enumMap->getHash($enum1));
65
66		$this->assertFalse($enumMap->contains($enum2));
67		$this->assertNull($enumMap->attach($enum2, $value2));
68		$this->assertTrue($enumMap->contains($enum2));
69		$this->assertSame($value2, $enumMap[$enum2]);
70		$this->assertSame(spl_object_hash(EnumBasic::TWO()), $enumMap->getHash($enum2));
71
72		$this->assertNull($enumMap->detach($enum1));
73		$this->assertFalse($enumMap->contains($enum1));
74
75		$this->assertNull($enumMap->detach($enum2));
76		$this->assertFalse($enumMap->contains($enum2));
77		}
78
79		public function testIterate()
80		{
81		$enumMap = new EnumMap('MabeEnumTest\TestAsset\EnumBasic');
82
83		$enum1 = EnumBasic::ONE();
84		$value1 = 'value1';
85
86		$enum2 = EnumBasic::TWO();
87		$value2 = 'value2';
88
89		// an empty enum map needs to be invalid, starting by 0
90		$enumMap->rewind();
91		$this->assertSame(0, $enumMap->count());
92		$this->assertFalse($enumMap->valid());
93
94		// attach
95		$enumMap->attach($enum1, $value2);
96		$enumMap->attach($enum2, $value1);
97
98		// a not empty enum map should be valid, starting by 0 (if not iterated)
99		$enumMap->rewind();
100		$this->assertSame(2, $enumMap->count());
101		$this->assertTrue($enumMap->valid());
102		$this->assertSame(0, $enumMap->key());
103		$this->assertSame($enum1, $enumMap->current());
104
105		// go to the next element (last)
106		$this->assertNull($enumMap->next());
107		$this->assertTrue($enumMap->valid());
108		$this->assertSame(1, $enumMap->key());
109		$this->assertSame($enum2, $enumMap->current());
110
111		// go to the next element (out of range)
112		$this->assertNull($enumMap->next());
113		$this->assertFalse($enumMap->valid());
114		$this->assertSame(2, $enumMap->key());
115
116		// rewind will set the iterator position back to 0
117		$enumMap->rewind();
118		$this->assertTrue($enumMap->valid());
119		$this->assertSame(0, $enumMap->key());
120		$this->assertSame($enum1, $enumMap->current());
121		}
122
123		public function testIterateWithFlags()
124		{
125		$enumMap = new EnumMap(
126		'MabeEnumTest\TestAsset\EnumBasic',
127		EnumMap::KEY_AS_INDEX \| EnumMap::CURRENT_AS_ENUM
128		);
129
130		$enumMap->attach(EnumBasic::TWO(), 'first');
131		$enumMap->attach(EnumBasic::ONE(), 'second');
132
133		// EnumMap::KEY_AS_INDEX \| EnumMap::CURRENT_AS_ENUM (first)
134		$this->assertSame(EnumMap::KEY_AS_INDEX \| EnumMap::CURRENT_AS_ENUM, $enumMap->getFlags());
135
136		$enumMap->rewind();
137		$this->assertSame(0, $enumMap->key());
138		$this->assertSame(EnumBasic::TWO(), $enumMap->current());
139
140		$enumMap->next();
141		$this->assertSame(1, $enumMap->key());
142		$this->assertSame(EnumBasic::ONE(), $enumMap->current());
143
144		// EnumMap::KEY_AS_NAME \| EnumMap::CURRENT_AS_DATA
145		$enumMap->setFlags(EnumMap::KEY_AS_NAME \| EnumMap::CURRENT_AS_DATA);
146		$this->assertSame(EnumMap::KEY_AS_NAME \| EnumMap::CURRENT_AS_DATA, $enumMap->getFlags());
147
148		$enumMap->rewind();
149		$this->assertSame('TWO', $enumMap->key());
150		$this->assertSame('first', $enumMap->current());
151
152		$enumMap->next();
153		$this->assertSame('ONE', $enumMap->key());
154		$this->assertSame('second', $enumMap->current());
155
156		// EnumMap::KEY_AS_VALUE \| EnumMap::CURRENT_AS_ORDINAL
157		$enumMap->setFlags(EnumMap::KEY_AS_VALUE \| EnumMap::CURRENT_AS_ORDINAL);
158		$this->assertSame(EnumMap::KEY_AS_VALUE \| EnumMap::CURRENT_AS_ORDINAL, $enumMap->getFlags());
159
160		$enumMap->rewind();
161		$this->assertSame(2, $enumMap->key());
162		$this->assertSame(1, $enumMap->current());
163
164		$enumMap->next();
165		$this->assertSame(1, $enumMap->key());
166		$this->assertSame(0, $enumMap->current());
167
168		// EnumMap::KEY_AS_ORDINAL \| EnumMap::CURRENT_AS_VALUE
169		$enumMap->setFlags(EnumMap::KEY_AS_ORDINAL \| EnumMap::CURRENT_AS_VALUE);
170		$this->assertSame(EnumMap::KEY_AS_ORDINAL \| EnumMap::CURRENT_AS_VALUE, $enumMap->getFlags());
171
172		$enumMap->rewind();
173		$this->assertSame(1, $enumMap->key());
174		$this->assertSame(2, $enumMap->current());
175
176		$enumMap->next();
177		$this->assertSame(0, $enumMap->key());
178		$this->assertSame(1, $enumMap->current());
179
180		// only change current flag to EnumMap::CURRENT_AS_NAME
181		$enumMap->setFlags(EnumMap::CURRENT_AS_NAME);
182		$this->assertSame(EnumMap::KEY_AS_ORDINAL \| EnumMap::CURRENT_AS_NAME, $enumMap->getFlags());
183
184		$enumMap->rewind();
185		$this->assertSame(1, $enumMap->key());
186		$this->assertSame('TWO', $enumMap->current());
187
188		$enumMap->next();
189		$this->assertSame(0, $enumMap->key());
190		$this->assertSame('ONE', $enumMap->current());
191
192		// only change key flag to EnumMap::NAME_AS_NAME
193		$enumMap->setFlags(EnumMap::KEY_AS_NAME);
194		$this->assertSame(EnumMap::KEY_AS_NAME \| EnumMap::CURRENT_AS_NAME, $enumMap->getFlags());
195
196		$enumMap->rewind();
197		$this->assertSame('TWO', $enumMap->key());
198		$this->assertSame('TWO', $enumMap->current());
199
200		$enumMap->next();
201		$this->assertSame('ONE', $enumMap->key());
202		$this->assertSame('ONE', $enumMap->current());
203		}
204
205		public function testArrayAccessWithObjects()
206		{
207		$enumMap = new EnumMap('MabeEnumTest\TestAsset\EnumBasic');
208
209		$enumMap[EnumBasic::ONE()] = 'first';
210		$enumMap[EnumBasic::TWO()] = 'second';
211
212		$this->assertTrue(isset($enumMap[EnumBasic::ONE()]));
213		$this->assertTrue(isset($enumMap[EnumBasic::TWO()]));
214
215		$this->assertSame('first', $enumMap[EnumBasic::ONE()]);
216		$this->assertSame('second', $enumMap[EnumBasic::TWO()]);
217
218		unset($enumMap[EnumBasic::ONE()], $enumMap[EnumBasic::TWO()]);
219
220		$this->assertFalse(isset($enumMap[EnumBasic::ONE()]));
221		$this->assertFalse(isset($enumMap[EnumBasic::TWO()]));
222		}
223
224		public function testArrayAccessWithValues()
225		{
226		$enumMap = new EnumMap('MabeEnumTest\TestAsset\EnumBasic');
227
228		$enumMap[EnumBasic::ONE] = 'first';
229		$enumMap[EnumBasic::TWO] = 'second';
230
231		$this->assertTrue(isset($enumMap[EnumBasic::ONE]));
232		$this->assertTrue(isset($enumMap[EnumBasic::TWO]));
233
234		$this->assertSame('first', $enumMap[EnumBasic::ONE]);
235		$this->assertSame('second', $enumMap[EnumBasic::TWO]);
236
237		unset($enumMap[EnumBasic::ONE], $enumMap[EnumBasic::TWO]);
238
239		$this->assertFalse(isset($enumMap[EnumBasic::ONE]));
240		$this->assertFalse(isset($enumMap[EnumBasic::TWO]));
241		}
242
243		public function testConstructThrowsInvalidArgumentExceptionIfEnumClassDoesNotExtendBaseEnum()
244		{
245		$this->setExpectedException('InvalidArgumentException');
246		new EnumMap('stdClass');
247		}
248
249		public function testSetFlagsThrowsInvalidArgumentExceptionOnUnsupportedKeyFlag()
250		{
251		$enumMap = new EnumMap('MabeEnumTest\TestAsset\EnumBasic');
252
253		$this->setExpectedException('InvalidArgumentException');
254		$enumMap->setFlags(5);
255		}
256
257	View Code Duplication	public function testCurrentThrowsRuntimeExceptionOnInvalidFlag()
258		{
259		$enumMap = new EnumMap('MabeEnumTest\TestAsset\EnumBasic');
260		$enumMap->attach(EnumBasic::ONE());
261		$enumMap->rewind();
262
263		// change internal flags to an invalid current flag
264		$reflectionClass = new ReflectionClass($enumMap);
265		$reflectionProp = $reflectionClass->getProperty('flags');
266		$reflectionProp->setAccessible(true);
267		$reflectionProp->setValue($enumMap, 0);
268
269		$this->setExpectedException('RuntimeException');
270		$enumMap->current();
271		}
272
273	View Code Duplication	public function testKeyThrowsRuntimeExceptionOnInvalidFlag()
274		{
275		$enumMap = new EnumMap('MabeEnumTest\TestAsset\EnumBasic');
276		$enumMap->attach(EnumBasic::ONE());
277		$enumMap->rewind();
278
279		// change internal flags to an invalid current flag
280		$reflectionClass = new ReflectionClass($enumMap);
281		$reflectionProp = $reflectionClass->getProperty('flags');
282		$reflectionProp->setAccessible(true);
283		$reflectionProp->setValue($enumMap, 0);
284
285		$this->setExpectedException('RuntimeException');
286		$enumMap->key();
287		}
288
289		public function testSetFlagsThrowsInvalidArgumentExceptionOnUnsupportedCurrentFlag()
290		{
291		$enumMap = new EnumMap('MabeEnumTest\TestAsset\EnumBasic');
292
293		$this->setExpectedException('InvalidArgumentException');
294		$enumMap->setFlags(48);
295		}
296
297		public function testInitEnumThrowsInvalidArgumentExceptionOnInvalidEnumGiven()
298		{
299		$enumMap = new EnumMap('MabeEnumTest\TestAsset\EnumBasic');
300
301		$this->setExpectedException('InvalidArgumentException');
302		$enumMap->offsetSet(EnumInheritance::INHERITANCE(), 'test');
303		}
304
305		public function testContainsAndOffsetExistsReturnsFalseOnInvalidEnum()
306		{
307		$enumMap = new EnumMap('MabeEnumTest\TestAsset\EnumBasic');
308
309		$this->assertFalse($enumMap->contains(EnumInheritance::INHERITANCE()));
310		$this->assertFalse($enumMap->contains(EnumInheritance::INHERITANCE));
311
312		$this->assertFalse(isset($enumMap[EnumInheritance::INHERITANCE()]));
313		$this->assertFalse(isset($enumMap[EnumInheritance::INHERITANCE]));
314		}
315		}
316

marc-mabe / php-enum

Push — master ( 9803f7...848250 )

EnumMapTest::testDeprecatedGetEnumClass() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like