EnumTest::testGetByInstance() - Code Metrics - Inspection of "Merge pull request #79 from marc-mabe/deprecate_en..." - marc-mabe/php-enum - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 552324...8f0733 )

by Marc

created 2016-12-06 11:23 UTC

EnumTest::testGetByInstance() A

↳ Parent: EnumTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	6
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	6
rs	9.4285
c	0
b	0
f	0
cc	1
eloc	4
nc	1
nop	0

<?php

namespace MabeEnumTest;

use MabeEnumTest\TestAsset\EnumBasic;
use MabeEnumTest\TestAsset\EnumInheritance;
use MabeEnumTest\TestAsset\EnumAmbiguous;
use MabeEnumTest\TestAsset\EnumExtendedAmbiguous;
use MabeEnumTest\TestAsset\ConstVisibilityEnum;
use MabeEnumTest\TestAsset\ConstVisibilityEnumExtended;
use MabeEnumTest\TestAsset\SerializableEnum;
use PHPUnit_Framework_TestCase as TestCase;
use ReflectionClass;

/**
 * Unit tests for the class MabeEnum\Enum
 *
 * @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 EnumTest extends TestCase
{
    public function testGetNameReturnsConstantNameOfCurrentValue()
    {
        $enum = EnumBasic::get(EnumBasic::ONE);
        $this->assertSame('ONE', $enum->getName());
    }

    public function testToStringMagicMethodReturnsName()
    {
        $enum = EnumBasic::get(EnumBasic::ONE);
        $this->assertSame('ONE', $enum->__toString());
    }

    public function testEnumInheritance()
    {
        $this->assertSame(array(
            'ONE'           => 1,
            'TWO'           => 2,
            'THREE'         => 3,
            'FOUR'          => 4,
            'FIVE'          => 5,
            'SIX'           => 6,
            'SEVEN'         => 7,
            'EIGHT'         => 8,
            'NINE'          => 9,
            'ZERO'          => 0,
            'FLOAT'         => 0.123,
            'STR'           => 'str',
            'STR_EMPTY'     => '',
            'NIL'           => null,
            'BOOLEAN_TRUE'  => true,
            'BOOLEAN_FALSE' => false,
            'INHERITANCE'   => 'Inheritance',
        ), EnumInheritance::getConstants());

        $enum = EnumInheritance::get(EnumInheritance::ONE);
        $this->assertSame(EnumInheritance::ONE, $enum->getValue());
        $this->assertSame(0, $enum->getOrdinal());

        $enum = EnumInheritance::get(EnumInheritance::INHERITANCE);
        $this->assertSame(EnumInheritance::INHERITANCE, $enum->getValue());
        $this->assertSame(16, $enum->getOrdinal());
    }

    public function testGetWithStrictValue()
    {
        $enum = EnumBasic::get(EnumBasic::ONE);
        $this->assertSame(1, $enum->getValue());
        $this->assertSame(0, $enum->getOrdinal());
    }

    public function testGetWithNonStrictValueThrowsInvalidArgumentException()
    {
        $this->setExpectedException('InvalidArgumentException');
        EnumBasic::get((string)EnumBasic::TWO);
    }

    public function testGetWithInvalidValueThrowsInvalidArgumentException()
    {
        $this->setExpectedException('InvalidArgumentException');
        EnumBasic::get('unknown');
    }

    public function testGetWithInvalidTypeOfValueThrowsInvalidArgumentException()
    {
        $this->setExpectedException('InvalidArgumentException');
        EnumBasic::get(array());
    }

    public function testGetByInstance()
    {
        $enum1 = EnumBasic::get(EnumBasic::ONE);
        $enum2 = EnumBasic::get($enum1);
        $this->assertSame($enum1, $enum2);
    }

    public function testGetByExtendedInstanceOfKnownValue()
    {
        $enum = EnumInheritance::get(EnumInheritance::ONE);

        $this->setExpectedException('InvalidArgumentException');
        EnumBasic::get($enum);
    }

    public function testGetEnumerators()
    {
        $constants   = EnumInheritance::getConstants();
        $enumerators = EnumInheritance::getEnumerators();
        $count       = count($enumerators);

        $this->assertSame(count($constants), $count);
        for ($i = 0; $i < $count; ++$i) {
            $this->assertArrayHasKey($i, $enumerators);
            $this->assertInstanceOf('MabeEnumTest\TestAsset\EnumInheritance', $enumerators[$i]);

            $enumerator = $enumerators[$i];
            $this->assertArrayHasKey($enumerator->getName(), $constants);
            $this->assertSame($constants[$enumerator->getName()], $enumerator->getValue());
        }
    }

    public function testGetAllValues()
    {
        $constants = EnumBasic::getConstants();
        foreach ($constants as $name => $value) {
            $enum = EnumBasic::get($value);
            $this->assertSame($value, $enum->getValue());
            $this->assertSame($name, $enum->getName());
        }
    }

    public function testIsBasic()
    {
        $enum = EnumBasic::ONE();

        // by value
        $this->assertTrue($enum->is(EnumBasic::ONE));   // same
        $this->assertFalse($enum->is('1'));             // wrong value by strict comparison

        // by instance
        $this->assertTrue($enum->is(EnumBasic::ONE()));        // same
        $this->assertFalse($enum->is(EnumBasic::TWO()));       // different enumerators
        $this->assertFalse($enum->is(EnumInheritance::ONE())); // different enumeration type
    }

    public function testCallingGetOrdinalTwoTimesWillResultTheSameValue()
    {
        $enum = EnumBasic::get(EnumBasic::TWO);
        $this->assertSame(1, $enum->getOrdinal());
        $this->assertSame(1, $enum->getOrdinal());
    }

    public function testInstantiateUsingOrdinalNumber()
    {
        $enum = EnumInheritance::getByOrdinal(16);
        $this->assertSame(16, $enum->getOrdinal());
        $this->assertSame('INHERITANCE', $enum->getName());
    }

    public function testInstantiateUsingInvalidOrdinalNumberThrowsInvalidArgumentException()
    {
        $this->setExpectedException('InvalidArgumentException');
        EnumInheritance::getByOrdinal(17);
    }

    public function testInstantiateByName()
    {
        $enum = EnumInheritance::getByName('ONE');
        $this->assertInstanceOf('MabeEnumTest\TestAsset\EnumInheritance', $enum);
        $this->assertSame(EnumInheritance::ONE, $enum->getValue());
    }

    public function testInstantiateByUnknownNameThrowsInvalidArgumentException()
    {
        $this->setExpectedException('InvalidArgumentException');
        EnumInheritance::getByName('UNKNOWN');
    }

    public function testInstantiateUsingMagicMethod()
    {
        $enum = EnumInheritance::ONE();
        $this->assertInstanceOf('MabeEnumTest\TestAsset\EnumInheritance', $enum);
        $this->assertSame(EnumInheritance::ONE, $enum->getValue());
    }

    public function testAmbiguousConstantsThrowsLogicException()
    {
        $this->setExpectedException('LogicException');
        EnumAmbiguous::get('unknown');
    }

    public function testExtendedAmbiguousCanstantsThrowsLogicException()
    {
        $this->setExpectedException('LogicException');
        EnumExtendedAmbiguous::get('unknown');
    }

    public function testSingleton()
    {
        $enum1 = EnumBasic::get(EnumBasic::ONE);
        $enum2 = EnumBasic::ONE();
        $this->assertSame($enum1, $enum2);
    }

    public function testClear()
    {
        $enum1 = EnumBasic::ONE();
        EnumBasic::clear();

        $enum2 = EnumBasic::ONE();
        $enum3 = EnumBasic::ONE();
        
        $this->assertNotSame($enum1, $enum2);
        $this->assertSame($enum2, $enum3);
    }

    public function testCloneNotCallableAndThrowsLogicException()
    {
        $enum = EnumBasic::ONE();

        $reflectionClass  = new ReflectionClass($enum);
        $reflectionMethod = $reflectionClass->getMethod('__clone');
        $this->assertTrue($reflectionMethod->isPrivate(), 'The method __clone must be private');
        $this->assertTrue($reflectionMethod->isFinal(), 'The method __clone must be final');

        $reflectionMethod->setAccessible(true);
        $this->setExpectedException('LogicException');
        $reflectionMethod->invoke($enum);
    }

    public function testNotSerializable()
    {
        $enum = EnumBasic::ONE();

        $this->setExpectedException('LogicException');
        serialize($enum);
    }

    public function testNotUnserializable()
    {
        $this->setExpectedException('LogicException');
        unserialize("O:32:\"MabeEnumTest\TestAsset\EnumBasic\":0:{}");
    }

    public function testHas()
    {
        $enum = EnumBasic::ONE();

        $this->assertFalse($enum->has('invalid'));
        $this->assertFalse($enum->has(EnumInheritance::ONE()));
        $this->assertTrue($enum->has(EnumBasic::ONE()));
        $this->assertTrue($enum->has(EnumBasic::ONE));
    }
    
    public function testConstVisibility()
    {
        if (PHP_VERSION_ID < 70100) {
            $this->markTestSkipped('This test is for PHP-7.1 and upper only');
        }

        $constants = ConstVisibilityEnum::getConstants();
        $this->assertSame(array(
            'IPUB' => ConstVisibilityEnum::IPUB,
            'PUB'  => ConstVisibilityEnum::PUB,
        ), $constants);
    }
    
    public function testConstVisibilityExtended()
    {
        if (PHP_VERSION_ID < 70100) {
            $this->markTestSkipped('This test is for PHP-7.1 and upper only');
        }

        $constants = ConstVisibilityEnumExtended::getConstants();
        $this->assertSame(array(
            'IPUB'  => ConstVisibilityEnumExtended::IPUB,
            'PUB'   => ConstVisibilityEnumExtended::PUB,
            'IPUB2' => ConstVisibilityEnumExtended::IPUB2,
            'PUB2'  => ConstVisibilityEnumExtended::PUB2,
        ), $constants);
    }

    public function testIsSerializableIssue()
    {
        if (PHP_VERSION_ID < 50400) {
            $this->markTestSkipped('This test is for PHP-5.4 and upper only');
        }

        $enum1 = SerializableEnum::INT();
        $enum2 = unserialize(serialize($enum1));

        $this->assertFalse($enum1 === $enum2, 'Wrong test implementation');
        $this->assertTrue($enum1->is($enum2), 'Two different instances of exact the same enumerator should be equal');
    }
}


1		<?php
2
3		namespace MabeEnumTest;
4
5		use MabeEnumTest\TestAsset\EnumBasic;
6		use MabeEnumTest\TestAsset\EnumInheritance;
7		use MabeEnumTest\TestAsset\EnumAmbiguous;
8		use MabeEnumTest\TestAsset\EnumExtendedAmbiguous;
9		use MabeEnumTest\TestAsset\ConstVisibilityEnum;
10		use MabeEnumTest\TestAsset\ConstVisibilityEnumExtended;
11		use MabeEnumTest\TestAsset\SerializableEnum;
12		use PHPUnit_Framework_TestCase as TestCase;
13		use ReflectionClass;
14
15		/**
16		* Unit tests for the class MabeEnum\Enum
17		*
18		* @link http://github.com/marc-mabe/php-enum for the canonical source repository
19		* @copyright Copyright (c) 2015 Marc Bennewitz
20		* @license http://github.com/marc-mabe/php-enum/blob/master/LICENSE.txt New BSD License
21		*/
22		class EnumTest extends TestCase
23		{
24		public function testGetNameReturnsConstantNameOfCurrentValue()
25		{
26		$enum = EnumBasic::get(EnumBasic::ONE);
27		$this->assertSame('ONE', $enum->getName());
28		}
29
30		public function testToStringMagicMethodReturnsName()
31		{
32		$enum = EnumBasic::get(EnumBasic::ONE);
33		$this->assertSame('ONE', $enum->__toString());
34		}
35
36		public function testEnumInheritance()
37		{
38		$this->assertSame(array(
39		'ONE' => 1,
40		'TWO' => 2,
41		'THREE' => 3,
42		'FOUR' => 4,
43		'FIVE' => 5,
44		'SIX' => 6,
45		'SEVEN' => 7,
46		'EIGHT' => 8,
47		'NINE' => 9,
48		'ZERO' => 0,
49		'FLOAT' => 0.123,
50		'STR' => 'str',
51		'STR_EMPTY' => '',
52		'NIL' => null,
53		'BOOLEAN_TRUE' => true,
54		'BOOLEAN_FALSE' => false,
55		'INHERITANCE' => 'Inheritance',
56		), EnumInheritance::getConstants());
57
58		$enum = EnumInheritance::get(EnumInheritance::ONE);
59		$this->assertSame(EnumInheritance::ONE, $enum->getValue());
60		$this->assertSame(0, $enum->getOrdinal());
61
62		$enum = EnumInheritance::get(EnumInheritance::INHERITANCE);
63		$this->assertSame(EnumInheritance::INHERITANCE, $enum->getValue());
64		$this->assertSame(16, $enum->getOrdinal());
65		}
66
67		public function testGetWithStrictValue()
68		{
69		$enum = EnumBasic::get(EnumBasic::ONE);
70		$this->assertSame(1, $enum->getValue());
71		$this->assertSame(0, $enum->getOrdinal());
72		}
73
74		public function testGetWithNonStrictValueThrowsInvalidArgumentException()
75		{
76		$this->setExpectedException('InvalidArgumentException');
77		EnumBasic::get((string)EnumBasic::TWO);
78		}
79
80		public function testGetWithInvalidValueThrowsInvalidArgumentException()
81		{
82		$this->setExpectedException('InvalidArgumentException');
83		EnumBasic::get('unknown');
84		}
85
86		public function testGetWithInvalidTypeOfValueThrowsInvalidArgumentException()
87		{
88		$this->setExpectedException('InvalidArgumentException');
89		EnumBasic::get(array());
90		}
91
92		public function testGetByInstance()
93		{
94		$enum1 = EnumBasic::get(EnumBasic::ONE);
95		$enum2 = EnumBasic::get($enum1);
96		$this->assertSame($enum1, $enum2);
97		}
98
99		public function testGetByExtendedInstanceOfKnownValue()
100		{
101		$enum = EnumInheritance::get(EnumInheritance::ONE);
102
103		$this->setExpectedException('InvalidArgumentException');
104		EnumBasic::get($enum);
105		}
106
107		public function testGetEnumerators()
108		{
109		$constants = EnumInheritance::getConstants();
110		$enumerators = EnumInheritance::getEnumerators();
111		$count = count($enumerators);
112
113		$this->assertSame(count($constants), $count);
114		for ($i = 0; $i < $count; ++$i) {
115		$this->assertArrayHasKey($i, $enumerators);
116		$this->assertInstanceOf('MabeEnumTest\TestAsset\EnumInheritance', $enumerators[$i]);
117
118		$enumerator = $enumerators[$i];
119		$this->assertArrayHasKey($enumerator->getName(), $constants);
120		$this->assertSame($constants[$enumerator->getName()], $enumerator->getValue());
121		}
122		}
123
124		public function testGetAllValues()
125		{
126		$constants = EnumBasic::getConstants();
127		foreach ($constants as $name => $value) {
128		$enum = EnumBasic::get($value);
129		$this->assertSame($value, $enum->getValue());
130		$this->assertSame($name, $enum->getName());
131		}
132		}
133
134	View Code Duplication	public function testIsBasic()
135		{
136		$enum = EnumBasic::ONE();
137
138		// by value
139		$this->assertTrue($enum->is(EnumBasic::ONE)); // same
140		$this->assertFalse($enum->is('1')); // wrong value by strict comparison
141
142		// by instance
143		$this->assertTrue($enum->is(EnumBasic::ONE())); // same
144		$this->assertFalse($enum->is(EnumBasic::TWO())); // different enumerators
145		$this->assertFalse($enum->is(EnumInheritance::ONE())); // different enumeration type
146		}
147
148		public function testCallingGetOrdinalTwoTimesWillResultTheSameValue()
149		{
150		$enum = EnumBasic::get(EnumBasic::TWO);
151		$this->assertSame(1, $enum->getOrdinal());
152		$this->assertSame(1, $enum->getOrdinal());
153		}
154
155		public function testInstantiateUsingOrdinalNumber()
156		{
157		$enum = EnumInheritance::getByOrdinal(16);
158		$this->assertSame(16, $enum->getOrdinal());
159		$this->assertSame('INHERITANCE', $enum->getName());
160		}
161
162		public function testInstantiateUsingInvalidOrdinalNumberThrowsInvalidArgumentException()
163		{
164		$this->setExpectedException('InvalidArgumentException');
165		EnumInheritance::getByOrdinal(17);
166		}
167
168		public function testInstantiateByName()
169		{
170		$enum = EnumInheritance::getByName('ONE');
171		$this->assertInstanceOf('MabeEnumTest\TestAsset\EnumInheritance', $enum);
172		$this->assertSame(EnumInheritance::ONE, $enum->getValue());
173		}
174
175		public function testInstantiateByUnknownNameThrowsInvalidArgumentException()
176		{
177		$this->setExpectedException('InvalidArgumentException');
178		EnumInheritance::getByName('UNKNOWN');
179		}
180
181		public function testInstantiateUsingMagicMethod()
182		{
183		$enum = EnumInheritance::ONE();
184		$this->assertInstanceOf('MabeEnumTest\TestAsset\EnumInheritance', $enum);
185		$this->assertSame(EnumInheritance::ONE, $enum->getValue());
186		}
187
188		public function testAmbiguousConstantsThrowsLogicException()
189		{
190		$this->setExpectedException('LogicException');
191		EnumAmbiguous::get('unknown');
192		}
193
194		public function testExtendedAmbiguousCanstantsThrowsLogicException()
195		{
196		$this->setExpectedException('LogicException');
197		EnumExtendedAmbiguous::get('unknown');
198		}
199
200		public function testSingleton()
201		{
202		$enum1 = EnumBasic::get(EnumBasic::ONE);
203		$enum2 = EnumBasic::ONE();
204		$this->assertSame($enum1, $enum2);
205		}
206
207		public function testClear()
208		{
209		$enum1 = EnumBasic::ONE();
210		EnumBasic::clear();
		0 ignored issues – show Deprecated Code introduced 2016-12-05 22:33 UTC by Report Bug Copy Issue Report The method `MabeEnum\Enum::clear()` has been deprecated. This method has been deprecated. Loading history...
211		$enum2 = EnumBasic::ONE();
212		$enum3 = EnumBasic::ONE();
213
214		$this->assertNotSame($enum1, $enum2);
215		$this->assertSame($enum2, $enum3);
216		}
217
218	View Code Duplication	public function testCloneNotCallableAndThrowsLogicException()
219		{
220		$enum = EnumBasic::ONE();
221
222		$reflectionClass = new ReflectionClass($enum);
223		$reflectionMethod = $reflectionClass->getMethod('__clone');
224		$this->assertTrue($reflectionMethod->isPrivate(), 'The method __clone must be private');
225		$this->assertTrue($reflectionMethod->isFinal(), 'The method __clone must be final');
226
227		$reflectionMethod->setAccessible(true);
228		$this->setExpectedException('LogicException');
229		$reflectionMethod->invoke($enum);
230		}
231
232		public function testNotSerializable()
233		{
234		$enum = EnumBasic::ONE();
235
236		$this->setExpectedException('LogicException');
237		serialize($enum);
238		}
239
240		public function testNotUnserializable()
241		{
242		$this->setExpectedException('LogicException');
243		unserialize("O:32:\"MabeEnumTest\TestAsset\EnumBasic\":0:{}");
244		}
245
246	View Code Duplication	public function testHas()
247		{
248		$enum = EnumBasic::ONE();
249
250		$this->assertFalse($enum->has('invalid'));
251		$this->assertFalse($enum->has(EnumInheritance::ONE()));
252		$this->assertTrue($enum->has(EnumBasic::ONE()));
253		$this->assertTrue($enum->has(EnumBasic::ONE));
254		}
255
256		public function testConstVisibility()
257		{
258		if (PHP_VERSION_ID < 70100) {
259		$this->markTestSkipped('This test is for PHP-7.1 and upper only');
260		}
261
262		$constants = ConstVisibilityEnum::getConstants();
263		$this->assertSame(array(
264		'IPUB' => ConstVisibilityEnum::IPUB,
265		'PUB' => ConstVisibilityEnum::PUB,
266		), $constants);
267		}
268
269		public function testConstVisibilityExtended()
270		{
271		if (PHP_VERSION_ID < 70100) {
272		$this->markTestSkipped('This test is for PHP-7.1 and upper only');
273		}
274
275		$constants = ConstVisibilityEnumExtended::getConstants();
276		$this->assertSame(array(
277		'IPUB' => ConstVisibilityEnumExtended::IPUB,
278		'PUB' => ConstVisibilityEnumExtended::PUB,
279		'IPUB2' => ConstVisibilityEnumExtended::IPUB2,
280		'PUB2' => ConstVisibilityEnumExtended::PUB2,
281		), $constants);
282		}
283
284		public function testIsSerializableIssue()
285		{
286		if (PHP_VERSION_ID < 50400) {
287		$this->markTestSkipped('This test is for PHP-5.4 and upper only');
288		}
289
290		$enum1 = SerializableEnum::INT();
291		$enum2 = unserialize(serialize($enum1));
292
293		$this->assertFalse($enum1 === $enum2, 'Wrong test implementation');
294		$this->assertTrue($enum1->is($enum2), 'Two different instances of exact the same enumerator should be equal');
295		}
296		}
297

marc-mabe / php-enum

Push — master ( 552324...8f0733 )

EnumTest::testGetByInstance() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like