EnumMapTest::testBasic() - Code Metrics - Inspection of "#74 provide integer (or binary) based EnumSet" - marc-mabe/php-enum - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — feature/74 ( 60c27e...f551d9 )

by Marc

created 2017-08-29 21:21 UTC

EnumMapTest::testBasic() B

↳ Parent: Project

Complexity

Conditions	1
Paths	1

Size

Total Lines	29
Code Lines	21

Duplication

Lines	0
Ratio	0 %

Importance

Changes	3
Bugs	2	Features	0

Metric	Value
c	3
b	2
f	0
dl	0
loc	29
rs	8.8571
cc	1
eloc	21
nc	1
nop	0

<?php

namespace MabeEnumTest;

use InvalidArgumentException;
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(EnumBasic::class);
        $this->assertSame(EnumBasic::class, $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(EnumBasic::class);

        $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(EnumBasic::class);

        $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, $value1);
        $enumMap->attach($enum2, $value2);

        // 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($enum1, $enumMap->key());
        $this->assertSame($value1, $enumMap->current());

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

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

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

    public function testArrayAccessWithObjects()
    {
        $enumMap = new EnumMap(EnumBasic::class);

        $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(EnumBasic::class);

        $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::class);
        new EnumMap('stdClass');
    }

    public function testInitEnumThrowsInvalidArgumentExceptionOnInvalidEnumGiven()
    {
        $enumMap = new EnumMap(EnumBasic::class);

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

    public function testContainsAndOffsetExistsReturnsFalseOnInvalidEnum()
    {
        $enumMap = new EnumMap(EnumBasic::class);

        $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 InvalidArgumentException;
6			use MabeEnum\EnumMap;
7			use MabeEnumTest\TestAsset\EnumBasic;
8			use MabeEnumTest\TestAsset\EnumInheritance;
9			use PHPUnit_Framework_TestCase as TestCase;
10			use ReflectionClass;
11
12			/**
13			* Unit tests for the class MabeEnum\EnumMap
14			*
15			* @link http://github.com/marc-mabe/php-enum for the canonical source repository
16			* @copyright Copyright (c) 2015 Marc Bennewitz
17			* @license http://github.com/marc-mabe/php-enum/blob/master/LICENSE.txt New BSD License
18			*/
19			class EnumMapTest extends TestCase
20			{
21			public function testBasic()
22			{
23			$enumMap = new EnumMap(EnumBasic::class);
24			$this->assertSame(EnumBasic::class, $enumMap->getEnumeration());
25
26			$enum1 = EnumBasic::ONE();
27			$value1 = 'value1';
28
29			$enum2 = EnumBasic::TWO();
30			$value2 = 'value2';
31
32			$this->assertFalse($enumMap->contains($enum1));
33			$this->assertNull($enumMap->attach($enum1, $value1));
34			$this->assertTrue($enumMap->contains($enum1));
35			$this->assertSame($value1, $enumMap[$enum1]);
36			$this->assertSame(spl_object_hash($enum1), $enumMap->getHash($enum1));
37
38			$this->assertFalse($enumMap->contains($enum2));
39			$this->assertNull($enumMap->attach($enum2, $value2));
40			$this->assertTrue($enumMap->contains($enum2));
41			$this->assertSame($value2, $enumMap[$enum2]);
42			$this->assertSame(spl_object_hash($enum2), $enumMap->getHash($enum2));
43
44			$this->assertNull($enumMap->detach($enum1));
45			$this->assertFalse($enumMap->contains($enum1));
46
47			$this->assertNull($enumMap->detach($enum2));
48			$this->assertFalse($enumMap->contains($enum2));
49			}
50
51			public function testBasicWithConstantValuesAsEnums()
52			{
53			$enumMap = new EnumMap(EnumBasic::class);
54
55			$enum1 = EnumBasic::ONE;
56			$value1 = 'value1';
57
58			$enum2 = EnumBasic::TWO;
59			$value2 = 'value2';
60
61			$this->assertFalse($enumMap->contains($enum1));
62			$this->assertNull($enumMap->attach($enum1, $value1));
63			$this->assertTrue($enumMap->contains($enum1));
64			$this->assertSame($value1, $enumMap[$enum1]);
65			$this->assertSame(spl_object_hash(EnumBasic::ONE()), $enumMap->getHash($enum1));
66
67			$this->assertFalse($enumMap->contains($enum2));
68			$this->assertNull($enumMap->attach($enum2, $value2));
69			$this->assertTrue($enumMap->contains($enum2));
70			$this->assertSame($value2, $enumMap[$enum2]);
71			$this->assertSame(spl_object_hash(EnumBasic::TWO()), $enumMap->getHash($enum2));
72
73			$this->assertNull($enumMap->detach($enum1));
74			$this->assertFalse($enumMap->contains($enum1));
75
76			$this->assertNull($enumMap->detach($enum2));
77			$this->assertFalse($enumMap->contains($enum2));
78			}
79
80			public function testIterate()
81			{
82			$enumMap = new EnumMap(EnumBasic::class);
83
84			$enum1 = EnumBasic::ONE();
85			$value1 = 'value1';
86
87			$enum2 = EnumBasic::TWO();
88			$value2 = 'value2';
89
90			// an empty enum map needs to be invalid, starting by 0
91			$enumMap->rewind();
92			$this->assertSame(0, $enumMap->count());
93			$this->assertFalse($enumMap->valid());
94
95			// attach
96			$enumMap->attach($enum1, $value1);
97			$enumMap->attach($enum2, $value2);
98
99			// a not empty enum map should be valid, starting by 0 (if not iterated)
100			$enumMap->rewind();
101			$this->assertSame(2, $enumMap->count());
102			$this->assertTrue($enumMap->valid());
103			$this->assertSame($enum1, $enumMap->key());
104			$this->assertSame($value1, $enumMap->current());
105
106			// go to the next element (last)
107			$this->assertNull($enumMap->next());
108			$this->assertTrue($enumMap->valid());
109			$this->assertSame($enum2, $enumMap->key());
110			$this->assertSame($value2, $enumMap->current());
111
112			// go to the next element (out of range)
113			$this->assertNull($enumMap->next());
114			$this->assertFalse($enumMap->valid());
115			$this->assertSame(null, $enumMap->key());
116
117			// rewind will set the iterator position back to 0
118			$enumMap->rewind();
119			$this->assertTrue($enumMap->valid());
120			$this->assertSame($enum1, $enumMap->key());
121			$this->assertSame($value1, $enumMap->current());
122			}
123
124			public function testArrayAccessWithObjects()
125			{
126			$enumMap = new EnumMap(EnumBasic::class);
127
128			$enumMap[EnumBasic::ONE()] = 'first';
129			$enumMap[EnumBasic::TWO()] = 'second';
130
131			$this->assertTrue(isset($enumMap[EnumBasic::ONE()]));
132			$this->assertTrue(isset($enumMap[EnumBasic::TWO()]));
133
134			$this->assertSame('first', $enumMap[EnumBasic::ONE()]);
135			$this->assertSame('second', $enumMap[EnumBasic::TWO()]);
136
137			unset($enumMap[EnumBasic::ONE()], $enumMap[EnumBasic::TWO()]);
138
139			$this->assertFalse(isset($enumMap[EnumBasic::ONE()]));
140			$this->assertFalse(isset($enumMap[EnumBasic::TWO()]));
141			}
142
143			public function testArrayAccessWithValues()
144			{
145			$enumMap = new EnumMap(EnumBasic::class);
146
147			$enumMap[EnumBasic::ONE] = 'first';
148			$enumMap[EnumBasic::TWO] = 'second';
149
150			$this->assertTrue(isset($enumMap[EnumBasic::ONE]));
151			$this->assertTrue(isset($enumMap[EnumBasic::TWO]));
152
153			$this->assertSame('first', $enumMap[EnumBasic::ONE]);
154			$this->assertSame('second', $enumMap[EnumBasic::TWO]);
155
156			unset($enumMap[EnumBasic::ONE], $enumMap[EnumBasic::TWO]);
157
158			$this->assertFalse(isset($enumMap[EnumBasic::ONE]));
159			$this->assertFalse(isset($enumMap[EnumBasic::TWO]));
160			}
161
162			public function testConstructThrowsInvalidArgumentExceptionIfEnumClassDoesNotExtendBaseEnum()
163			{
164			$this->setExpectedException(InvalidArgumentException::class);
165			new EnumMap('stdClass');
166			}
167
168			public function testInitEnumThrowsInvalidArgumentExceptionOnInvalidEnumGiven()
169			{
170			$enumMap = new EnumMap(EnumBasic::class);
171
172			$this->setExpectedException(InvalidArgumentException::class);
173			$enumMap->offsetSet(EnumInheritance::INHERITANCE(), 'test');
174			}
175
176			public function testContainsAndOffsetExistsReturnsFalseOnInvalidEnum()
177			{
178			$enumMap = new EnumMap(EnumBasic::class);
179
180			$this->assertFalse($enumMap->contains(EnumInheritance::INHERITANCE()));
181			$this->assertFalse($enumMap->contains(EnumInheritance::INHERITANCE));
182
183			$this->assertFalse(isset($enumMap[EnumInheritance::INHERITANCE()]));
184			$this->assertFalse(isset($enumMap[EnumInheritance::INHERITANCE]));
185			}
186			}
187

marc-mabe / php-enum

Push — feature/74 ( 60c27e...f551d9 )

EnumMapTest::testBasic() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like