Skip to content

Commit 1aadf44

Browse files
marc-mabemarc-mabe
committed
fixes #26: Enumerations should be unique by their string representation
also updated tests to contain this check and renamed test class EnumWithoutDefaultValue to EnumBasic plus added more numbers (now 0-9)
1 parent 5731dd4 commit 1aadf44

File tree

6 files changed

+137
-102
lines changed

6 files changed

+137
-102
lines changed

‎src/MabeEnum/Enum.php

Lines changed: 15 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -129,9 +129,22 @@ final static public function get($value)
129129

130130
// find the real value
131131
$constants = self::detectConstants($class);
132-
$name = array_search($value, $constants);
132+
$name = array_search($value, $constants, true);
133133
if ($name === false) {
134-
throw new InvalidArgumentException("Unknown value '{$value}'");
134+
// enumeration values have to be unique by their string representation
135+
// because array_search search in strict more or in non-strict mode we
136+
// have to search for a value of the same string out self.
137+
$valueStr = (string) $value;
138+
$found = false;
139+
foreach ($constants as $name => $constValue) {
140+
if ($valueStr === (string) $constValue) {
141+
$found = true;
142+
break;
143+
}
144+
}
145+
if (!$found) {
146+
throw new InvalidArgumentException("Unknown value '{$value}'");
147+
}
135148
}
136149

137150
return self::$instances[$class][$value] = new $class($constants[$name]);

‎tests/MabeEnumTest/EnumMapTest.php

Lines changed: 46 additions & 46 deletions
Original file line numberDiff line numberDiff line change
@@ -4,7 +4,7 @@
44

55
use MabeEnum\Enum;
66
use MabeEnum\EnumMap;
7-
use MabeEnumTest\TestAsset\EnumWithoutDefaultValue;
7+
use MabeEnumTest\TestAsset\EnumBasic;
88
use MabeEnumTest\TestAsset\EnumInheritance;
99
use PHPUnit_Framework_TestCase as TestCase;
1010
use ReflectionClass;
@@ -20,13 +20,13 @@ class EnumMapTest extends TestCase
2020
{
2121
public function testBasic()
2222
{
23-
$enumMap = new EnumMap('MabeEnumTest\TestAsset\EnumWithoutDefaultValue');
24-
$this->assertSame('MabeEnumTest\TestAsset\EnumWithoutDefaultValue', $enumMap->getEnumClass());
23+
$enumMap = new EnumMap('MabeEnumTest\TestAsset\EnumBasic');
24+
$this->assertSame('MabeEnumTest\TestAsset\EnumBasic', $enumMap->getEnumClass());
2525

26-
$enum1 = EnumWithoutDefaultValue::ONE();
26+
$enum1 = EnumBasic::ONE();
2727
$value1 = 'value1';
2828

29-
$enum2 = EnumWithoutDefaultValue::TWO();
29+
$enum2 = EnumBasic::TWO();
3030
$value2 = 'value2';
3131

3232
$this->assertFalse($enumMap->contains($enum1));
@@ -50,25 +50,25 @@ public function testBasic()
5050

5151
public function testBasicWithConstantValuesAsEnums()
5252
{
53-
$enumMap = new EnumMap('MabeEnumTest\TestAsset\EnumWithoutDefaultValue');
53+
$enumMap = new EnumMap('MabeEnumTest\TestAsset\EnumBasic');
5454

55-
$enum1 = EnumWithoutDefaultValue::ONE;
55+
$enum1 = EnumBasic::ONE;
5656
$value1 = 'value1';
5757

58-
$enum2 = EnumWithoutDefaultValue::TWO;
58+
$enum2 = EnumBasic::TWO;
5959
$value2 = 'value2';
6060

6161
$this->assertFalse($enumMap->contains($enum1));
6262
$this->assertNull($enumMap->attach($enum1, $value1));
6363
$this->assertTrue($enumMap->contains($enum1));
6464
$this->assertSame($value1, $enumMap[$enum1]);
65-
$this->assertSame(spl_object_hash(EnumWithoutDefaultValue::ONE()), $enumMap->getHash($enum1));
65+
$this->assertSame(spl_object_hash(EnumBasic::ONE()), $enumMap->getHash($enum1));
6666

6767
$this->assertFalse($enumMap->contains($enum2));
6868
$this->assertNull($enumMap->attach($enum2, $value2));
6969
$this->assertTrue($enumMap->contains($enum2));
7070
$this->assertSame($value2, $enumMap[$enum2]);
71-
$this->assertSame(spl_object_hash(EnumWithoutDefaultValue::TWO()), $enumMap->getHash($enum2));
71+
$this->assertSame(spl_object_hash(EnumBasic::TWO()), $enumMap->getHash($enum2));
7272

7373
$this->assertNull($enumMap->detach($enum1));
7474
$this->assertFalse($enumMap->contains($enum1));
@@ -79,12 +79,12 @@ public function testBasicWithConstantValuesAsEnums()
7979

8080
public function testIterate()
8181
{
82-
$enumMap = new EnumMap('MabeEnumTest\TestAsset\EnumWithoutDefaultValue');
82+
$enumMap = new EnumMap('MabeEnumTest\TestAsset\EnumBasic');
8383

84-
$enum1 = EnumWithoutDefaultValue::ONE();
84+
$enum1 = EnumBasic::ONE();
8585
$value1 = 'value1';
8686

87-
$enum2 = EnumWithoutDefaultValue::TWO();
87+
$enum2 = EnumBasic::TWO();
8888
$value2 = 'value2';
8989

9090
// an empty enum map needs to be invalid, starting by 0
@@ -124,23 +124,23 @@ public function testIterate()
124124
public function testIterateWithFlags()
125125
{
126126
$enumMap = new EnumMap(
127-
'MabeEnumTest\TestAsset\EnumWithoutDefaultValue',
127+
'MabeEnumTest\TestAsset\EnumBasic',
128128
EnumMap::KEY_AS_INDEX | EnumMap::CURRENT_AS_ENUM
129129
);
130130

131-
$enumMap->attach(EnumWithoutDefaultValue::TWO(), 'first');
132-
$enumMap->attach(EnumWithoutDefaultValue::ONE(), 'second');
131+
$enumMap->attach(EnumBasic::TWO(), 'first');
132+
$enumMap->attach(EnumBasic::ONE(), 'second');
133133

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

137137
$enumMap->rewind();
138138
$this->assertSame(0, $enumMap->key());
139-
$this->assertSame(EnumWithoutDefaultValue::TWO(), $enumMap->current());
139+
$this->assertSame(EnumBasic::TWO(), $enumMap->current());
140140

141141
$enumMap->next();
142142
$this->assertSame(1, $enumMap->key());
143-
$this->assertSame(EnumWithoutDefaultValue::ONE(), $enumMap->current());
143+
$this->assertSame(EnumBasic::ONE(), $enumMap->current());
144144

145145
// EnumMap::KEY_AS_NAME | EnumMap::CURRENT_AS_DATA
146146
$enumMap->setFlags(EnumMap::KEY_AS_NAME | EnumMap::CURRENT_AS_DATA);
@@ -205,40 +205,40 @@ public function testIterateWithFlags()
205205

206206
public function testArrayAccessWithObjects()
207207
{
208-
$enumMap = new EnumMap('MabeEnumTest\TestAsset\EnumWithoutDefaultValue');
208+
$enumMap = new EnumMap('MabeEnumTest\TestAsset\EnumBasic');
209209

210-
$enumMap[EnumWithoutDefaultValue::ONE()] = 'first';
211-
$enumMap[EnumWithoutDefaultValue::TWO()] = 'second';
210+
$enumMap[EnumBasic::ONE()] = 'first';
211+
$enumMap[EnumBasic::TWO()] = 'second';
212212

213-
$this->assertTrue(isset($enumMap[EnumWithoutDefaultValue::ONE()]));
214-
$this->assertTrue(isset($enumMap[EnumWithoutDefaultValue::TWO()]));
213+
$this->assertTrue(isset($enumMap[EnumBasic::ONE()]));
214+
$this->assertTrue(isset($enumMap[EnumBasic::TWO()]));
215215

216-
$this->assertSame('first', $enumMap[EnumWithoutDefaultValue::ONE()]);
217-
$this->assertSame('second', $enumMap[EnumWithoutDefaultValue::TWO()]);
216+
$this->assertSame('first', $enumMap[EnumBasic::ONE()]);
217+
$this->assertSame('second', $enumMap[EnumBasic::TWO()]);
218218

219-
unset($enumMap[EnumWithoutDefaultValue::ONE()], $enumMap[EnumWithoutDefaultValue::TWO()]);
219+
unset($enumMap[EnumBasic::ONE()], $enumMap[EnumBasic::TWO()]);
220220

221-
$this->assertFalse(isset($enumMap[EnumWithoutDefaultValue::ONE()]));
222-
$this->assertFalse(isset($enumMap[EnumWithoutDefaultValue::TWO()]));
221+
$this->assertFalse(isset($enumMap[EnumBasic::ONE()]));
222+
$this->assertFalse(isset($enumMap[EnumBasic::TWO()]));
223223
}
224224

225225
public function testArrayAccessWithValues()
226226
{
227-
$enumMap = new EnumMap('MabeEnumTest\TestAsset\EnumWithoutDefaultValue');
227+
$enumMap = new EnumMap('MabeEnumTest\TestAsset\EnumBasic');
228228

229-
$enumMap[EnumWithoutDefaultValue::ONE] = 'first';
230-
$enumMap[EnumWithoutDefaultValue::TWO] = 'second';
229+
$enumMap[EnumBasic::ONE] = 'first';
230+
$enumMap[EnumBasic::TWO] = 'second';
231231

232-
$this->assertTrue(isset($enumMap[EnumWithoutDefaultValue::ONE]));
233-
$this->assertTrue(isset($enumMap[EnumWithoutDefaultValue::TWO]));
232+
$this->assertTrue(isset($enumMap[EnumBasic::ONE]));
233+
$this->assertTrue(isset($enumMap[EnumBasic::TWO]));
234234

235-
$this->assertSame('first', $enumMap[EnumWithoutDefaultValue::ONE]);
236-
$this->assertSame('second', $enumMap[EnumWithoutDefaultValue::TWO]);
235+
$this->assertSame('first', $enumMap[EnumBasic::ONE]);
236+
$this->assertSame('second', $enumMap[EnumBasic::TWO]);
237237

238-
unset($enumMap[EnumWithoutDefaultValue::ONE], $enumMap[EnumWithoutDefaultValue::TWO]);
238+
unset($enumMap[EnumBasic::ONE], $enumMap[EnumBasic::TWO]);
239239

240-
$this->assertFalse(isset($enumMap[EnumWithoutDefaultValue::ONE]));
241-
$this->assertFalse(isset($enumMap[EnumWithoutDefaultValue::TWO]));
240+
$this->assertFalse(isset($enumMap[EnumBasic::ONE]));
241+
$this->assertFalse(isset($enumMap[EnumBasic::TWO]));
242242
}
243243

244244
public function testConstructThrowsInvalidArgumentExceptionIfEnumClassDoesNotExtendBaseEnum()
@@ -249,16 +249,16 @@ public function testConstructThrowsInvalidArgumentExceptionIfEnumClassDoesNotExt
249249

250250
public function testSetFlagsThrowsInvalidArgumentExceptionOnUnsupportedKeyFlag()
251251
{
252-
$enumMap = new EnumMap('MabeEnumTest\TestAsset\EnumWithoutDefaultValue');
252+
$enumMap = new EnumMap('MabeEnumTest\TestAsset\EnumBasic');
253253

254254
$this->setExpectedException('InvalidArgumentException');
255255
$enumMap->setFlags(5);
256256
}
257257

258258
public function testCurrentThrowsRuntimeExceptionOnInvalidFlag()
259259
{
260-
$enumMap = new EnumMap('MabeEnumTest\TestAsset\EnumWithoutDefaultValue');
261-
$enumMap->attach(EnumWithoutDefaultValue::ONE());
260+
$enumMap = new EnumMap('MabeEnumTest\TestAsset\EnumBasic');
261+
$enumMap->attach(EnumBasic::ONE());
262262
$enumMap->rewind();
263263

264264
// change internal flags to an invalid current flag
@@ -273,8 +273,8 @@ public function testCurrentThrowsRuntimeExceptionOnInvalidFlag()
273273

274274
public function testKeyThrowsRuntimeExceptionOnInvalidFlag()
275275
{
276-
$enumMap = new EnumMap('MabeEnumTest\TestAsset\EnumWithoutDefaultValue');
277-
$enumMap->attach(EnumWithoutDefaultValue::ONE());
276+
$enumMap = new EnumMap('MabeEnumTest\TestAsset\EnumBasic');
277+
$enumMap->attach(EnumBasic::ONE());
278278
$enumMap->rewind();
279279

280280
// change internal flags to an invalid current flag
@@ -289,23 +289,23 @@ public function testKeyThrowsRuntimeExceptionOnInvalidFlag()
289289

290290
public function testSetFlagsThrowsInvalidArgumentExceptionOnUnsupportedCurrentFlag()
291291
{
292-
$enumMap = new EnumMap('MabeEnumTest\TestAsset\EnumWithoutDefaultValue');
292+
$enumMap = new EnumMap('MabeEnumTest\TestAsset\EnumBasic');
293293

294294
$this->setExpectedException('InvalidArgumentException');
295295
$enumMap->setFlags(48);
296296
}
297297

298298
public function testInitEnumThrowsInvalidArgumentExceptionOnInvalidEnumGiven()
299299
{
300-
$enumMap = new EnumMap('MabeEnumTest\TestAsset\EnumWithoutDefaultValue');
300+
$enumMap = new EnumMap('MabeEnumTest\TestAsset\EnumBasic');
301301

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

306306
public function testContainsAndOffsetExistsReturnsFalseOnInvalidEnum()
307307
{
308-
$enumMap = new EnumMap('MabeEnumTest\TestAsset\EnumWithoutDefaultValue');
308+
$enumMap = new EnumMap('MabeEnumTest\TestAsset\EnumBasic');
309309

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

‎tests/MabeEnumTest/EnumSetTest.php

Lines changed: 29 additions & 29 deletions
Original file line numberDiff line numberDiff line change
@@ -4,7 +4,7 @@
44

55
use MabeEnum\Enum;
66
use MabeEnum\EnumSet;
7-
use MabeEnumTest\TestAsset\EnumWithoutDefaultValue;
7+
use MabeEnumTest\TestAsset\EnumBasic;
88
use MabeEnumTest\TestAsset\EnumInheritance;
99
use PHPUnit_Framework_TestCase as TestCase;
1010

@@ -19,12 +19,12 @@ class EnumSetTest extends TestCase
1919
{
2020
public function testBasic()
2121
{
22-
$enumSet = new EnumSet('MabeEnumTest\TestAsset\EnumWithoutDefaultValue');
23-
$this->assertSame('MabeEnumTest\TestAsset\EnumWithoutDefaultValue', $enumSet->getEnumClass());
22+
$enumSet = new EnumSet('MabeEnumTest\TestAsset\EnumBasic');
23+
$this->assertSame('MabeEnumTest\TestAsset\EnumBasic', $enumSet->getEnumClass());
2424
$this->assertSame(EnumSet::UNIQUE, $enumSet->getFlags());
2525

26-
$enum1 = EnumWithoutDefaultValue::ONE();
27-
$enum2 = EnumWithoutDefaultValue::TWO();
26+
$enum1 = EnumBasic::ONE();
27+
$enum2 = EnumBasic::TWO();
2828

2929
$this->assertFalse($enumSet->contains($enum1));
3030
$this->assertNull($enumSet->attach($enum1));
@@ -43,10 +43,10 @@ public function testBasic()
4343

4444
public function testBasicWithConstantValuesAsEnums()
4545
{
46-
$enumSet = new EnumSet('MabeEnumTest\TestAsset\EnumWithoutDefaultValue');
46+
$enumSet = new EnumSet('MabeEnumTest\TestAsset\EnumBasic');
4747

48-
$enum1 = EnumWithoutDefaultValue::ONE;
49-
$enum2 = EnumWithoutDefaultValue::TWO;
48+
$enum1 = EnumBasic::ONE;
49+
$enum2 = EnumBasic::TWO;
5050

5151
$this->assertFalse($enumSet->contains($enum1));
5252
$this->assertNull($enumSet->attach($enum1));
@@ -65,42 +65,42 @@ public function testBasicWithConstantValuesAsEnums()
6565

6666
public function testUnique()
6767
{
68-
$enumSet = new EnumSet('MabeEnumTest\TestAsset\EnumWithoutDefaultValue', EnumSet::UNIQUE);
68+
$enumSet = new EnumSet('MabeEnumTest\TestAsset\EnumBasic', EnumSet::UNIQUE);
6969
$this->assertSame(EnumSet::UNIQUE, $enumSet->getFlags());
7070

71-
$enumSet->attach(EnumWithoutDefaultValue::ONE());
72-
$enumSet->attach(EnumWithoutDefaultValue::ONE);
71+
$enumSet->attach(EnumBasic::ONE());
72+
$enumSet->attach(EnumBasic::ONE);
7373

74-
$enumSet->attach(EnumWithoutDefaultValue::TWO());
75-
$enumSet->attach(EnumWithoutDefaultValue::TWO);
74+
$enumSet->attach(EnumBasic::TWO());
75+
$enumSet->attach(EnumBasic::TWO);
7676

7777
$this->assertSame(2, $enumSet->count());
7878
}
7979

8080
public function testNotUnique()
8181
{
82-
$enumSet = new EnumSet('MabeEnumTest\TestAsset\EnumWithoutDefaultValue', 0);
82+
$enumSet = new EnumSet('MabeEnumTest\TestAsset\EnumBasic', 0);
8383
$this->assertSame(0, $enumSet->getFlags());
8484

85-
$enumSet->attach(EnumWithoutDefaultValue::ONE());
86-
$enumSet->attach(EnumWithoutDefaultValue::ONE);
85+
$enumSet->attach(EnumBasic::ONE());
86+
$enumSet->attach(EnumBasic::ONE);
8787

88-
$enumSet->attach(EnumWithoutDefaultValue::TWO());
89-
$enumSet->attach(EnumWithoutDefaultValue::TWO);
88+
$enumSet->attach(EnumBasic::TWO());
89+
$enumSet->attach(EnumBasic::TWO);
9090

9191
$this->assertSame(4, $enumSet->count());
9292

9393
// detch remove all
94-
$enumSet->detach(EnumWithoutDefaultValue::ONE);
94+
$enumSet->detach(EnumBasic::ONE);
9595
$this->assertSame(2, $enumSet->count());
9696
}
9797

9898
public function testIterateUnordered()
9999
{
100-
$enumSet = new EnumSet('MabeEnumTest\TestAsset\EnumWithoutDefaultValue', EnumSet::UNIQUE);
100+
$enumSet = new EnumSet('MabeEnumTest\TestAsset\EnumBasic', EnumSet::UNIQUE);
101101

102-
$enum1 = EnumWithoutDefaultValue::ONE();
103-
$enum2 = EnumWithoutDefaultValue::TWO();
102+
$enum1 = EnumBasic::ONE();
103+
$enum2 = EnumBasic::TWO();
104104

105105
// an empty enum set needs to be invalid, starting by 0
106106
$this->assertSame(0, $enumSet->count());
@@ -138,10 +138,10 @@ public function testIterateUnordered()
138138

139139
public function testIterateOrdered()
140140
{
141-
$enumSet = new EnumSet('MabeEnumTest\TestAsset\EnumWithoutDefaultValue', EnumSet::UNIQUE | EnumSet::ORDERED);
141+
$enumSet = new EnumSet('MabeEnumTest\TestAsset\EnumBasic', EnumSet::UNIQUE | EnumSet::ORDERED);
142142

143-
$enum1 = EnumWithoutDefaultValue::ONE();
144-
$enum2 = EnumWithoutDefaultValue::TWO();
143+
$enum1 = EnumBasic::ONE();
144+
$enum2 = EnumBasic::TWO();
145145

146146
// an empty enum set needs to be invalid, starting by 0
147147
$this->assertSame(0, $enumSet->count());
@@ -179,10 +179,10 @@ public function testIterateOrdered()
179179

180180
public function testIterateOrderedNotUnique()
181181
{
182-
$enumSet = new EnumSet('MabeEnumTest\TestAsset\EnumWithoutDefaultValue', EnumSet::ORDERED);
182+
$enumSet = new EnumSet('MabeEnumTest\TestAsset\EnumBasic', EnumSet::ORDERED);
183183

184-
$enum1 = EnumWithoutDefaultValue::ONE();
185-
$enum2 = EnumWithoutDefaultValue::TWO();
184+
$enum1 = EnumBasic::ONE();
185+
$enum2 = EnumBasic::TWO();
186186

187187
// an empty enum set needs to be invalid, starting by 0
188188
$this->assertSame(0, $enumSet->count());
@@ -267,7 +267,7 @@ public function testConstructThrowsInvalidArgumentExceptionIfEnumClassDoesNotExt
267267

268268
public function testInitEnumThrowsInvalidArgumentExceptionOnInvalidEnum()
269269
{
270-
$enumSet = new EnumSet('MabeEnumTest\TestAsset\EnumWithoutDefaultValue');
270+
$enumSet = new EnumSet('MabeEnumTest\TestAsset\EnumBasic');
271271
$this->setExpectedException('InvalidArgumentException');
272272
$this->assertFalse($enumSet->contains(EnumInheritance::INHERITANCE()));
273273
}

0 commit comments

Comments
 (0)