EnumMapTest::testContainsAndOffsetExistsReturnsFalseOnInvalidEnum() - Code Metrics - Inspection of "fixed #70: removed iterator flags for EnumMap" - marc-mabe/php-enum - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 848250...ac23ee )

by Marc

created 2017-07-02 12:24 UTC

testContainsAndOffsetExistsReturnsFalseOnInvalidEnum() A

↳ Parent: EnumMapTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	10
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	1	Features	0

Metric	Value
c	1
b	1
f	0
dl	0
loc	10
rs	9.4285
cc	1
eloc	6
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, $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('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 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, $value1);
96			$enumMap->attach($enum2, $value2);
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($enum1, $enumMap->key());
103			$this->assertSame($value1, $enumMap->current());
104
105			// go to the next element (last)
106			$this->assertNull($enumMap->next());
107			$this->assertTrue($enumMap->valid());
108			$this->assertSame($enum2, $enumMap->key());
109			$this->assertSame($value2, $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(null, $enumMap->key());
115
116			// rewind will set the iterator position back to 0
117			$enumMap->rewind();
118			$this->assertTrue($enumMap->valid());
119			$this->assertSame($enum1, $enumMap->key());
120			$this->assertSame($value1, $enumMap->current());
121			}
122
123			public function testArrayAccessWithObjects()
124			{
125			$enumMap = new EnumMap('MabeEnumTest\TestAsset\EnumBasic');
126
127			$enumMap[EnumBasic::ONE()] = 'first';
128			$enumMap[EnumBasic::TWO()] = 'second';
129
130			$this->assertTrue(isset($enumMap[EnumBasic::ONE()]));
131			$this->assertTrue(isset($enumMap[EnumBasic::TWO()]));
132
133			$this->assertSame('first', $enumMap[EnumBasic::ONE()]);
134			$this->assertSame('second', $enumMap[EnumBasic::TWO()]);
135
136			unset($enumMap[EnumBasic::ONE()], $enumMap[EnumBasic::TWO()]);
137
138			$this->assertFalse(isset($enumMap[EnumBasic::ONE()]));
139			$this->assertFalse(isset($enumMap[EnumBasic::TWO()]));
140			}
141
142			public function testArrayAccessWithValues()
143			{
144			$enumMap = new EnumMap('MabeEnumTest\TestAsset\EnumBasic');
145
146			$enumMap[EnumBasic::ONE] = 'first';
147			$enumMap[EnumBasic::TWO] = 'second';
148
149			$this->assertTrue(isset($enumMap[EnumBasic::ONE]));
150			$this->assertTrue(isset($enumMap[EnumBasic::TWO]));
151
152			$this->assertSame('first', $enumMap[EnumBasic::ONE]);
153			$this->assertSame('second', $enumMap[EnumBasic::TWO]);
154
155			unset($enumMap[EnumBasic::ONE], $enumMap[EnumBasic::TWO]);
156
157			$this->assertFalse(isset($enumMap[EnumBasic::ONE]));
158			$this->assertFalse(isset($enumMap[EnumBasic::TWO]));
159			}
160
161			public function testConstructThrowsInvalidArgumentExceptionIfEnumClassDoesNotExtendBaseEnum()
162			{
163			$this->setExpectedException('InvalidArgumentException');
164			new EnumMap('stdClass');
165			}
166
167			public function testInitEnumThrowsInvalidArgumentExceptionOnInvalidEnumGiven()
168			{
169			$enumMap = new EnumMap('MabeEnumTest\TestAsset\EnumBasic');
170
171			$this->setExpectedException('InvalidArgumentException');
172			$enumMap->offsetSet(EnumInheritance::INHERITANCE(), 'test');
173			}
174
175			public function testContainsAndOffsetExistsReturnsFalseOnInvalidEnum()
176			{
177			$enumMap = new EnumMap('MabeEnumTest\TestAsset\EnumBasic');
178
179			$this->assertFalse($enumMap->contains(EnumInheritance::INHERITANCE()));
180			$this->assertFalse($enumMap->contains(EnumInheritance::INHERITANCE));
181
182			$this->assertFalse(isset($enumMap[EnumInheritance::INHERITANCE()]));
183			$this->assertFalse(isset($enumMap[EnumInheritance::INHERITANCE]));
184			}
185			}
186

marc-mabe / php-enum

Push — master ( 848250...ac23ee )

testContainsAndOffsetExistsReturnsFalseOnInvalidEnum() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like