EnumTest::testConstVisibility() - Code Metrics - Inspection of "[WIP] handle class constant visibility" - marc-mabe/php-enum - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#59)

by Marc

created 2016-08-21 19:44 UTC

EnumTest::testConstVisibility() A

↳ Parent: EnumTest

Complexity

Conditions	2
Paths	2

Size

Total Lines	21
Code Lines	14

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	21
rs	9.3142
cc	2
eloc	14
nc	2
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 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 setUp()
    {
        EnumBasic::clear();
        EnumInheritance::clear();
    }

    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 and upper only');
        }

        $constants = ConstVisibilityEnum::getConstants();
        $this->assertArrayHasKey('IPUB', $constants);    // indirect public
        $this->assertArrayHasKey('PUB', $constants);     // public
        $this->assertArrayNotHasKey('PRO', $constants);  // protected
        $this->assertArrayNotHasKey('PRI', $constants);  // private

        $this->assertTrue(ConstVisibilityEnum::has('indirect public'));
        $this->assertSame('indirect public', ConstVisibilityEnum::IPUB()->getValue());

        $this->assertTrue(ConstVisibilityEnum::has('public'));
        $this->assertSame('public', ConstVisibilityEnum::PUB()->getValue());

        $this->assertFalse(ConstVisibilityEnum::has('protected'));
        $this->assertFalse(ConstVisibilityEnum::has('private'));
    }
}


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

marc-mabe / php-enum

Pull Request — master (#59)

EnumTest::testConstVisibility() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like