EnumMapTest - Code Metrics - Inspection of "Update travis versions" - marc-mabe/php-enum - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — 2.x (#116)

by Marc

created 2019-03-16 18:14 UTC

EnumMapTest A

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	304
Duplicated Lines	9.87 %

Coupling/Cohesion

Components	2
Dependencies	4

Importance

Changes	5
Bugs	3	Features	0

Metric	Value
wmc	14
c	5
b	3
f	0
lcom	2
cbo	4
dl	30
loc	304
rs	10

How to fix Duplicated Code

<?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 testDeprecatedGetEnumClass()
    {
        $enumMap = new EnumMap('MabeEnumTest\TestAsset\EnumBasic');
        $this->assertSame('MabeEnumTest\TestAsset\EnumBasic', $enumMap->getEnumClass());
    }

    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 testDeprecatedGetEnumClass()
51			{
52			$enumMap = new EnumMap('MabeEnumTest\TestAsset\EnumBasic');
53			$this->assertSame('MabeEnumTest\TestAsset\EnumBasic', $enumMap->getEnumClass());
54			}
55
56			public function testBasicWithConstantValuesAsEnums()
57			{
58			$enumMap = new EnumMap('MabeEnumTest\TestAsset\EnumBasic');
59
60			$enum1 = EnumBasic::ONE;
61			$value1 = 'value1';
62
63			$enum2 = EnumBasic::TWO;
64			$value2 = 'value2';
65
66			$this->assertFalse($enumMap->contains($enum1));
67			$this->assertNull($enumMap->attach($enum1, $value1));
68			$this->assertTrue($enumMap->contains($enum1));
69			$this->assertSame($value1, $enumMap[$enum1]);
70			$this->assertSame(spl_object_hash(EnumBasic::ONE()), $enumMap->getHash($enum1));
71
72			$this->assertFalse($enumMap->contains($enum2));
73			$this->assertNull($enumMap->attach($enum2, $value2));
74			$this->assertTrue($enumMap->contains($enum2));
75			$this->assertSame($value2, $enumMap[$enum2]);
76			$this->assertSame(spl_object_hash(EnumBasic::TWO()), $enumMap->getHash($enum2));
77
78			$this->assertNull($enumMap->detach($enum1));
79			$this->assertFalse($enumMap->contains($enum1));
80
81			$this->assertNull($enumMap->detach($enum2));
82			$this->assertFalse($enumMap->contains($enum2));
83			}
84
85			public function testIterate()
86			{
87			$enumMap = new EnumMap('MabeEnumTest\TestAsset\EnumBasic');
88
89			$enum1 = EnumBasic::ONE();
90			$value1 = 'value1';
91
92			$enum2 = EnumBasic::TWO();
93			$value2 = 'value2';
94
95			// an empty enum map needs to be invalid, starting by 0
96			$enumMap->rewind();
97			$this->assertSame(0, $enumMap->count());
98			$this->assertFalse($enumMap->valid());
99
100			// attach
101			$enumMap->attach($enum1, $value2);
102			$enumMap->attach($enum2, $value1);
103
104			// a not empty enum map should be valid, starting by 0 (if not iterated)
105			$enumMap->rewind();
106			$this->assertSame(2, $enumMap->count());
107			$this->assertTrue($enumMap->valid());
108			$this->assertSame(0, $enumMap->key());
109			$this->assertSame($enum1, $enumMap->current());
110
111			// go to the next element (last)
112			$this->assertNull($enumMap->next());
113			$this->assertTrue($enumMap->valid());
114			$this->assertSame(1, $enumMap->key());
115			$this->assertSame($enum2, $enumMap->current());
116
117			// go to the next element (out of range)
118			$this->assertNull($enumMap->next());
119			$this->assertFalse($enumMap->valid());
120			$this->assertSame(2, $enumMap->key());
121
122			// rewind will set the iterator position back to 0
123			$enumMap->rewind();
124			$this->assertTrue($enumMap->valid());
125			$this->assertSame(0, $enumMap->key());
126			$this->assertSame($enum1, $enumMap->current());
127			}
128
129			public function testIterateWithFlags()
130			{
131			$enumMap = new EnumMap(
132			'MabeEnumTest\TestAsset\EnumBasic',
133			EnumMap::KEY_AS_INDEX \| EnumMap::CURRENT_AS_ENUM
134			);
135
136			$enumMap->attach(EnumBasic::TWO(), 'first');
137			$enumMap->attach(EnumBasic::ONE(), 'second');
138
139			// EnumMap::KEY_AS_INDEX \| EnumMap::CURRENT_AS_ENUM (first)
140			$this->assertSame(EnumMap::KEY_AS_INDEX \| EnumMap::CURRENT_AS_ENUM, $enumMap->getFlags());
141
142			$enumMap->rewind();
143			$this->assertSame(0, $enumMap->key());
144			$this->assertSame(EnumBasic::TWO(), $enumMap->current());
145
146			$enumMap->next();
147			$this->assertSame(1, $enumMap->key());
148			$this->assertSame(EnumBasic::ONE(), $enumMap->current());
149
150			// EnumMap::KEY_AS_NAME \| EnumMap::CURRENT_AS_DATA
151			$enumMap->setFlags(EnumMap::KEY_AS_NAME \| EnumMap::CURRENT_AS_DATA);
152			$this->assertSame(EnumMap::KEY_AS_NAME \| EnumMap::CURRENT_AS_DATA, $enumMap->getFlags());
153
154			$enumMap->rewind();
155			$this->assertSame('TWO', $enumMap->key());
156			$this->assertSame('first', $enumMap->current());
157
158			$enumMap->next();
159			$this->assertSame('ONE', $enumMap->key());
160			$this->assertSame('second', $enumMap->current());
161
162			// EnumMap::KEY_AS_VALUE \| EnumMap::CURRENT_AS_ORDINAL
163			$enumMap->setFlags(EnumMap::KEY_AS_VALUE \| EnumMap::CURRENT_AS_ORDINAL);
164			$this->assertSame(EnumMap::KEY_AS_VALUE \| EnumMap::CURRENT_AS_ORDINAL, $enumMap->getFlags());
165
166			$enumMap->rewind();
167			$this->assertSame(2, $enumMap->key());
168			$this->assertSame(1, $enumMap->current());
169
170			$enumMap->next();
171			$this->assertSame(1, $enumMap->key());
172			$this->assertSame(0, $enumMap->current());
173
174			// EnumMap::KEY_AS_ORDINAL \| EnumMap::CURRENT_AS_VALUE
175			$enumMap->setFlags(EnumMap::KEY_AS_ORDINAL \| EnumMap::CURRENT_AS_VALUE);
176			$this->assertSame(EnumMap::KEY_AS_ORDINAL \| EnumMap::CURRENT_AS_VALUE, $enumMap->getFlags());
177
178			$enumMap->rewind();
179			$this->assertSame(1, $enumMap->key());
180			$this->assertSame(2, $enumMap->current());
181
182			$enumMap->next();
183			$this->assertSame(0, $enumMap->key());
184			$this->assertSame(1, $enumMap->current());
185
186			// only change current flag to EnumMap::CURRENT_AS_NAME
187			$enumMap->setFlags(EnumMap::CURRENT_AS_NAME);
188			$this->assertSame(EnumMap::KEY_AS_ORDINAL \| EnumMap::CURRENT_AS_NAME, $enumMap->getFlags());
189
190			$enumMap->rewind();
191			$this->assertSame(1, $enumMap->key());
192			$this->assertSame('TWO', $enumMap->current());
193
194			$enumMap->next();
195			$this->assertSame(0, $enumMap->key());
196			$this->assertSame('ONE', $enumMap->current());
197
198			// only change key flag to EnumMap::NAME_AS_NAME
199			$enumMap->setFlags(EnumMap::KEY_AS_NAME);
200			$this->assertSame(EnumMap::KEY_AS_NAME \| EnumMap::CURRENT_AS_NAME, $enumMap->getFlags());
201
202			$enumMap->rewind();
203			$this->assertSame('TWO', $enumMap->key());
204			$this->assertSame('TWO', $enumMap->current());
205
206			$enumMap->next();
207			$this->assertSame('ONE', $enumMap->key());
208			$this->assertSame('ONE', $enumMap->current());
209			}
210
211			public function testArrayAccessWithObjects()
212			{
213			$enumMap = new EnumMap('MabeEnumTest\TestAsset\EnumBasic');
214
215			$enumMap[EnumBasic::ONE()] = 'first';
216			$enumMap[EnumBasic::TWO()] = 'second';
217
218			$this->assertTrue(isset($enumMap[EnumBasic::ONE()]));
219			$this->assertTrue(isset($enumMap[EnumBasic::TWO()]));
220
221			$this->assertSame('first', $enumMap[EnumBasic::ONE()]);
222			$this->assertSame('second', $enumMap[EnumBasic::TWO()]);
223
224			unset($enumMap[EnumBasic::ONE()], $enumMap[EnumBasic::TWO()]);
225
226			$this->assertFalse(isset($enumMap[EnumBasic::ONE()]));
227			$this->assertFalse(isset($enumMap[EnumBasic::TWO()]));
228			}
229
230			public function testArrayAccessWithValues()
231			{
232			$enumMap = new EnumMap('MabeEnumTest\TestAsset\EnumBasic');
233
234			$enumMap[EnumBasic::ONE] = 'first';
235			$enumMap[EnumBasic::TWO] = 'second';
236
237			$this->assertTrue(isset($enumMap[EnumBasic::ONE]));
238			$this->assertTrue(isset($enumMap[EnumBasic::TWO]));
239
240			$this->assertSame('first', $enumMap[EnumBasic::ONE]);
241			$this->assertSame('second', $enumMap[EnumBasic::TWO]);
242
243			unset($enumMap[EnumBasic::ONE], $enumMap[EnumBasic::TWO]);
244
245			$this->assertFalse(isset($enumMap[EnumBasic::ONE]));
246			$this->assertFalse(isset($enumMap[EnumBasic::TWO]));
247			}
248
249			public function testConstructThrowsInvalidArgumentExceptionIfEnumClassDoesNotExtendBaseEnum()
250			{
251			$this->setExpectedException('InvalidArgumentException');
252			new EnumMap('stdClass');
253			}
254
255			public function testSetFlagsThrowsInvalidArgumentExceptionOnUnsupportedKeyFlag()
256			{
257			$enumMap = new EnumMap('MabeEnumTest\TestAsset\EnumBasic');
258
259			$this->setExpectedException('InvalidArgumentException');
260			$enumMap->setFlags(5);
261			}
262
263			public function testCurrentThrowsRuntimeExceptionOnInvalidFlag()
264			{
265			$enumMap = new EnumMap('MabeEnumTest\TestAsset\EnumBasic');
266			$enumMap->attach(EnumBasic::ONE());
267			$enumMap->rewind();
268
269			// change internal flags to an invalid current flag
270			$reflectionClass = new ReflectionClass($enumMap);
271			$reflectionProp = $reflectionClass->getProperty('flags');
272			$reflectionProp->setAccessible(true);
273			$reflectionProp->setValue($enumMap, 0);
274
275			$this->setExpectedException('RuntimeException');
276			$enumMap->current();
277			}
278
279			public function testKeyThrowsRuntimeExceptionOnInvalidFlag()
280			{
281			$enumMap = new EnumMap('MabeEnumTest\TestAsset\EnumBasic');
282			$enumMap->attach(EnumBasic::ONE());
283			$enumMap->rewind();
284
285			// change internal flags to an invalid current flag
286			$reflectionClass = new ReflectionClass($enumMap);
287			$reflectionProp = $reflectionClass->getProperty('flags');
288			$reflectionProp->setAccessible(true);
289			$reflectionProp->setValue($enumMap, 0);
290
291			$this->setExpectedException('RuntimeException');
292			$enumMap->key();
293			}
294
295			public function testSetFlagsThrowsInvalidArgumentExceptionOnUnsupportedCurrentFlag()
296			{
297			$enumMap = new EnumMap('MabeEnumTest\TestAsset\EnumBasic');
298
299			$this->setExpectedException('InvalidArgumentException');
300			$enumMap->setFlags(48);
301			}
302
303			public function testInitEnumThrowsInvalidArgumentExceptionOnInvalidEnumGiven()
304			{
305			$enumMap = new EnumMap('MabeEnumTest\TestAsset\EnumBasic');
306
307			$this->setExpectedException('InvalidArgumentException');
308			$enumMap->offsetSet(EnumInheritance::INHERITANCE(), 'test');
309			}
310
311			public function testContainsAndOffsetExistsReturnsFalseOnInvalidEnum()
312			{
313			$enumMap = new EnumMap('MabeEnumTest\TestAsset\EnumBasic');
314
315			$this->assertFalse($enumMap->contains(EnumInheritance::INHERITANCE()));
316			$this->assertFalse($enumMap->contains(EnumInheritance::INHERITANCE));
317
318			$this->assertFalse(isset($enumMap[EnumInheritance::INHERITANCE()]));
319			$this->assertFalse(isset($enumMap[EnumInheritance::INHERITANCE]));
320			}
321			}
322

marc-mabe / php-enum

Pull Request — 2.x (#116)

EnumMapTest A

Complexity

Size/Duplication

Coupling/Cohesion

Importance

How to fix Duplicated Code

Duplicated Code

Duplication Side-by-Side

Filter issues like