Merge pull request #15 from marc-mabe/namespaces

Marc Bennewitz · Marc Bennewitz · commit b378c30459d8 · 2013-09-11T05:12:09.000-07:00
diff --git a/README.md b/README.md
@@ -6,7 +6,7 @@
 [![Latest Unstable Version](https://poser.pugx.org/marc-mabe/php-enum/v/unstable.png)](https://packagist.org/packages/marc-mabe/php-enum)
 [![Dependency Status](https://www.versioneye.com/php/marc-mabe:php-enum/dev-master/badge.png)](https://www.versioneye.com/php/marc-mabe:php-enum/dev-master)
 
-This is a native PHP implementation to add enumeration support to PHP 5.x.
+This is a native PHP implementation to add enumeration support to PHP >= 5.3
 It's an abstract class that needs to be extended to use it.
 
 
@@ -32,7 +32,7 @@ It's an abstract class that needs to be extended to use it.
 
 # API
 
-    abstract class MabeEnum_Enum
+    abstract class MabeEnum\Enum
     {
         /**
          * Constructor
@@ -80,7 +80,7 @@ It's an abstract class that needs to be extended to use it.
          * @param string $name            The name of the constant to instantiate
          * @param array  $args            This should be an empty array (no arguments)
          * @throws BadMethodCallException If the called method hasn't the same name as a constant
-         * @return MabeEnum_Enum          The instantiated enum
+         * @return MabeEnum\Enum          The instantiated enum
          */
         final public static __callStatic($name, array $args);
     }
@@ -129,7 +129,9 @@ It's an abstract class that needs to be extended to use it.
 
 ## The way of php-enum:
 
-    class UserStatusEnum extends MabeEnum_Enum
+    use MabeEnum\Enum;
+    
+    class UserStatusEnum extends Enum
     {
         const INACTIVE = 0;
         const ACTIVE   = 1;
@@ -149,23 +151,23 @@ It's an abstract class that needs to be extended to use it.
         {
             if (!$this->status) {
                 // init default status
-                $this->status = new UserStatusEnum(UserStatusEnum::INACTIVE);
+                $this->status = UserStatusEnum::INACTIVE();
             }
             return $this->status;
         }
     }
     
     $user = new User();
     echo 'Default user status: ' . $user->getStatus() . '(' . $user->getStatus()->getValue() . ')' . PHP_EOL;
-    $user->setStatus(new UserStatusEnum(UserStatusEnum::ACTIVE));
+    $user->setStatus(UserStatusEnum::ACTIVE());
     echo 'Changed user status: ' . $user->getStatus() . '(' . $user->getStatus()->getValue() . ')' . PHP_EOL;
 
 **PRINTS**
 
     Default user status: INACTIVE (0)
     Changed user status: ACTIVE (1)
 
-* Validation will be already done on basic class ```MabeEnum_Enum```
+* Validation will be already done on basic class ```MabeEnum\Enum```
 * Using type-hint makes arguments save
 * Human readable name of a value is simple accessable
 
@@ -194,7 +196,9 @@ and extract it.
 This example defines the constant ```ONE``` with value ```1``` as default
 value.
 
-    class MyEnumWithDefaultValue extends MabeEnum_Enum
+    use MabeEnum\Enum;
+    
+    class MyEnumWithDefaultValue extends Enum
     {
         const ONE = 1;
         const TWO = 2;
@@ -209,7 +213,9 @@ value.
 
 It's also possible to extend other enumerations.
 
-    class MyEnum extends MabeEnum_Enum
+    use MabeEnum\Enum;
+    
+    class MyEnum extends Enum
     {
         const ONE = 1;
         const TWO = 2;
@@ -222,10 +228,12 @@ It's also possible to extend other enumerations.
 
 ## Simplified instantiation
 
-With PHP >= 5.3 it possible to call one of the defined constants like a method
+It's possible to call one of the defined constants like a method
 and you will get the instantiated enum as a result.
 
-    class MyEnum extends MabeEnum_Enum
+    use MabeEnum\Enum;
+    
+    class MyEnum extends Enum
     {
         const ONE = 1;
         const TWO = 2;
diff --git a/composer.json b/composer.json
@@ -25,7 +25,7 @@
     },
     "autoload": {
         "psr-0": {
-            "MabeEnum_": "src/"
+            "MabeEnum\\": "src/"
         }
     }
 }
diff --git a/src/MabeEnum/Enum.php b/src/MabeEnum/Enum.php
@@ -1,13 +1,20 @@
 <?php
 
+namespace MabeEnum;
+
+use ReflectionClass;
+use InvalidArgumentException;
+use LogicException;
+use BadMethodCallException;
+
 /**
  * Class to implement enumerations for PHP 5 (without SplEnum)
  *
  * @link http://github.com/marc-mabe/php-enum for the canonical source repository
  * @copyright Copyright (c) 2012 Marc Bennewitz
  * @license http://github.com/marc-mabe/php-enum/blob/master/LICENSE.txt New BSD License
  */
-abstract class MabeEnum_Enum
+abstract class Enum
 {
     /**
      * The selected value
@@ -29,7 +36,7 @@ abstract class MabeEnum_Enum
 
     /**
      * Already instantiated enums
-     * @param array ["$class.$value" => MabeEnum_Enum, ...]
+     * @param array ["$class.$value" => MabeEnum\Enum, ...]
      */
     private static $instances = array();
 
@@ -117,7 +124,7 @@ final public function getOrdinal()
      * Get an enum of the given value
      *
      * @param scalar $value
-     * @return MabeEnum_Enum
+     * @return Enum
      * @throws InvalidArgumentException On an unknwon or invalid value
      * @throws LogicException           On ambiguous constant values
      */
diff --git a/tests/Bootstrap.php b/tests/Bootstrap.php
@@ -11,11 +11,11 @@
 
 function autoload($className)
 {
-    $test = dirname(__FILE__) . '/../src/' . str_replace('_', '/', $className) . '.php';
+    $test = dirname(__FILE__) . '/../src/' . str_replace('\\', '/', $className) . '.php';
     if (file_exists($test)) {
         require $test;
     }
-    $test = dirname(__FILE__) . '/' . str_replace('_', '/', $className) . '.php';
+    $test = dirname(__FILE__) . '/' . str_replace('\\', '/', $className) . '.php';
     if (file_exists($test)) {
         require $test;
     }
diff --git a/tests/MabeEnumTest/EnumTest.php b/tests/MabeEnumTest/EnumTest.php
@@ -1,109 +1,117 @@
 <?php
 
+namespace MabeEnumTest;
+
+use MabeEnumTest\TestAsset\EnumWithoutDefaultValue;
+use MabeEnumTest\TestAsset\EnumInheritance;
+use MabeEnumTest\TestAsset\EnumAmbiguous;
+use PHPUnit_Framework_TestCase as TestCase;
+use ReflectionClass;
+
 /**
- * Unit tests for the class MabeEnum_Enum
+ * Unit tests for the class MabeEnum\Enum
  *
  * @link http://github.com/marc-mabe/php-enum for the canonical source repository
  * @copyright Copyright (c) 2012 Marc Bennewitz
  * @license http://github.com/marc-mabe/php-enum/blob/master/LICENSE.txt New BSD License
  */
-class MabeEnumTest_EnumTest extends PHPUnit_Framework_TestCase
+class EnumTest extends TestCase
 {
     public function testGetNameReturnsConstantNameOfCurrentValue()
     {
-        $enum = MabeEnumTest_TestAsset_EnumWithoutDefaultValue::get(MabeEnumTest_TestAsset_EnumWithoutDefaultValue::ONE);
+        $enum = EnumWithoutDefaultValue::get(EnumWithoutDefaultValue::ONE);
         $this->assertSame('ONE', $enum->getName());
     }
 
     public function testToStringMagicMethodReturnsValueAsString()
     {
-        $enum = MabeEnumTest_TestAsset_EnumWithoutDefaultValue::get(MabeEnumTest_TestAsset_EnumWithoutDefaultValue::ONE);
+        $enum = EnumWithoutDefaultValue::get(EnumWithoutDefaultValue::ONE);
         $this->assertSame('1', $enum->__toString());
     }
 
     public function testEnumInheritance()
     {
-        $enum = MabeEnumTest_TestAsset_EnumInheritance::get(MabeEnumTest_TestAsset_EnumInheritance::ONE);
+        $enum = EnumInheritance::get(EnumInheritance::ONE);
         $this->assertSame(array(
             'ONE'         => 1,
             'TWO'         => 2,
             'INHERITANCE' => 'Inheritance'
         ), $enum::getConstants());
-        $this->assertSame(MabeEnumTest_TestAsset_EnumInheritance::ONE, $enum->getValue());
+        $this->assertSame(EnumInheritance::ONE, $enum->getValue());
         $this->assertSame(0, $enum->getOrdinal());
 
-        $enum = MabeEnumTest_TestAsset_EnumInheritance::get(MabeEnumTest_TestAsset_EnumInheritance::INHERITANCE);
-        $this->assertSame(MabeEnumTest_TestAsset_EnumInheritance::INHERITANCE, $enum->getValue());
+        $enum = EnumInheritance::get(EnumInheritance::INHERITANCE);
+        $this->assertSame(EnumInheritance::INHERITANCE, $enum->getValue());
         $this->assertSame(2, $enum->getOrdinal());
     }
 
     public function testConstructorStrictValue()
     {
-        $enum = MabeEnumTest_TestAsset_EnumWithoutDefaultValue::get(MabeEnumTest_TestAsset_EnumWithoutDefaultValue::ONE);
+        $enum = EnumWithoutDefaultValue::get(EnumWithoutDefaultValue::ONE);
         $this->assertSame(1, $enum->getValue());
         $this->assertSame(0, $enum->getOrdinal());
     }
 
     public function testConstuctorNonStrictValue()
     {
-        $enum = MabeEnumTest_TestAsset_EnumWithoutDefaultValue::get((string)MabeEnumTest_TestAsset_EnumWithoutDefaultValue::TWO);
+        $enum = EnumWithoutDefaultValue::get((string)EnumWithoutDefaultValue::TWO);
         $this->assertSame(2, $enum->getValue());
         $this->assertSame(1, $enum->getOrdinal());
     }
 
     public function testConstructorInvalidValueThrowsInvalidArgumentException()
     {
         $this->setExpectedException('InvalidArgumentException');
-        MabeEnumTest_TestAsset_EnumWithoutDefaultValue::get('unknown');
+        EnumWithoutDefaultValue::get('unknown');
     }
 
     public function testCallingGetOrdinalTwoTimesWillResultTheSameValue()
     {
-        $enum = MabeEnumTest_TestAsset_EnumWithoutDefaultValue::get(MabeEnumTest_TestAsset_EnumWithoutDefaultValue::TWO);
+        $enum = EnumWithoutDefaultValue::get(EnumWithoutDefaultValue::TWO);
         $this->assertSame(1, $enum->getOrdinal());
         $this->assertSame(1, $enum->getOrdinal());
     }
 
     public function testInstantiateUsingMagicMethod()
     {
-        $enum = MabeEnumTest_TestAsset_EnumInheritance::ONE();
-        $this->assertInstanceOf('MabeEnumTest_TestAsset_EnumInheritance', $enum);
-        $this->assertSame(MabeEnumTest_TestAsset_EnumInheritance::ONE, $enum->getValue());
+        $enum = EnumInheritance::ONE();
+        $this->assertInstanceOf('MabeEnumTest\TestAsset\EnumInheritance', $enum);
+        $this->assertSame(EnumInheritance::ONE, $enum->getValue());
     }
 
     public function testInstantiateUsingMagicMethodThrowsBadMethodCallException()
     {
         $this->setExpectedException('BadMethodCallException');
-        MabeEnumTest_TestAsset_EnumInheritance::UNKNOWN();
+        EnumInheritance::UNKNOWN();
     }
 
     public function testAmbuguousConstantsThrowsLogicException()
     {
         $this->setExpectedException('LogicException');
-        MabeEnumTest_TestAsset_EnumAmbiguous::get(MabeEnumTest_TestAsset_EnumAmbiguous::AMBIGUOUS1);
+        EnumAmbiguous::get(EnumAmbiguous::AMBIGUOUS1);
     }
 
     public function testSingleton()
     {
-        $enum1 = MabeEnumTest_TestAsset_EnumWithoutDefaultValue::get(MabeEnumTest_TestAsset_EnumWithoutDefaultValue::ONE);
-        $enum2 = MabeEnumTest_TestAsset_EnumWithoutDefaultValue::ONE();
+        $enum1 = EnumWithoutDefaultValue::get(EnumWithoutDefaultValue::ONE);
+        $enum2 = EnumWithoutDefaultValue::ONE();
         $this->assertSame($enum1, $enum2);
     }
 
     public function testClear()
     {
-        $enum1 = MabeEnumTest_TestAsset_EnumWithoutDefaultValue::ONE();
-        MabeEnumTest_TestAsset_EnumWithoutDefaultValue::clear();
-        $enum2 = MabeEnumTest_TestAsset_EnumWithoutDefaultValue::ONE();
-        $enum3 = MabeEnumTest_TestAsset_EnumWithoutDefaultValue::ONE();
+        $enum1 = EnumWithoutDefaultValue::ONE();
+        EnumWithoutDefaultValue::clear();
+        $enum2 = EnumWithoutDefaultValue::ONE();
+        $enum3 = EnumWithoutDefaultValue::ONE();
         
         $this->assertNotSame($enum1, $enum2);
         $this->assertSame($enum2, $enum3);
     }
 
     public function testCloneNotCallableAndThrowsLogicException()
     {
-        $enum = MabeEnumTest_TestAsset_EnumWithoutDefaultValue::ONE();
+        $enum = EnumWithoutDefaultValue::ONE();
 
         $reflectionClass  = new ReflectionClass($enum);
         $reflectionMethod = $reflectionClass->getMethod('__clone');
diff --git a/tests/MabeEnumTest/TestAsset/EmptyEnum.php b/tests/MabeEnumTest/TestAsset/EmptyEnum.php
@@ -1,12 +1,16 @@
 <?php
 
+namespace MabeEnumTest\TestAsset;
+
+use MabeEnum\Enum;
+
 /**
- * Unit tests for the class MabeEnum_Enum
+ * Unit tests for the class MabeEnum\Enum
  *
  * @link http://github.com/marc-mabe/php-enum for the canonical source repository
  * @copyright Copyright (c) 2012 Marc Bennewitz
  * @license http://github.com/marc-mabe/php-enum/blob/master/LICENSE.txt New BSD License
  */
-class MabeEnumTest_TestAsset_EmptyEnum extends MabeEnum_Enum
+class EmptyEnum extends Enum
 {
 }
diff --git a/tests/MabeEnumTest/TestAsset/EnumAmbiguous.php b/tests/MabeEnumTest/TestAsset/EnumAmbiguous.php
@@ -1,13 +1,17 @@
 <?php
 
+namespace MabeEnumTest\TestAsset;
+
+use MabeEnum\Enum;
+
 /**
- * Unit tests for the class MabeEnum_Enum
+ * Unit tests for the class MabeEnum\Enum
  *
  * @link http://github.com/marc-mabe/php-enum for the canonical source repository
  * @copyright Copyright (c) 2012 Marc Bennewitz
  * @license http://github.com/marc-mabe/php-enum/blob/master/LICENSE.txt New BSD License
  */
-class MabeEnumTest_TestAsset_EnumAmbiguous extends MabeEnum_Enum
+class EnumAmbiguous extends Enum
 {
     const UNIQUE1    = 'unique1';
     const AMBIGUOUS1 = 1;
diff --git a/tests/MabeEnumTest/TestAsset/EnumInheritance.php b/tests/MabeEnumTest/TestAsset/EnumInheritance.php
@@ -1,13 +1,15 @@
 <?php
 
+namespace MabeEnumTest\TestAsset;
+
 /**
- * Unit tests for the class MabeEnum_Enum
+ * Unit tests for the class MabeEnum\Enum
  *
  * @link http://github.com/marc-mabe/php-enum for the canonical source repository
  * @copyright Copyright (c) 2012 Marc Bennewitz
  * @license http://github.com/marc-mabe/php-enum/blob/master/LICENSE.txt New BSD License
  */
-class MabeEnumTest_TestAsset_EnumInheritance extends MabeEnumTest_TestAsset_EnumWithoutDefaultValue
+class EnumInheritance extends EnumWithoutDefaultValue
 {
     const INHERITANCE = 'Inheritance';
 }
diff --git a/tests/MabeEnumTest/TestAsset/EnumWithoutDefaultValue.php b/tests/MabeEnumTest/TestAsset/EnumWithoutDefaultValue.php
@@ -1,13 +1,17 @@
 <?php
 
+namespace MabeEnumTest\TestAsset;
+
+use MabeEnum\Enum;
+
 /**
- * Unit tests for the class MabeEnum_Enum
+ * Unit tests for the class MabeEnum\Enum
  *
  * @link http://github.com/marc-mabe/php-enum for the canonical source repository
  * @copyright Copyright (c) 2012 Marc Bennewitz
  * @license http://github.com/marc-mabe/php-enum/blob/master/LICENSE.txt New BSD License
  */
-class MabeEnumTest_TestAsset_EnumWithoutDefaultValue extends MabeEnum_Enum
+class EnumWithoutDefaultValue extends Enum
 {
     const ONE = 1;
     const TWO = 2;

Original file line number	Diff line number	Diff line change
`@@ -25,7 +25,7 @@`
`25`	`25`	`},`
`26`	`26`	`"autoload": {`
`27`	`27`	`"psr-0": {`
`28`		`- "MabeEnum_": "src/"`
	`28`	`+ "MabeEnum\\": "src/"`
`29`	`29`	`}`
`30`	`30`	`}`
`31`	`31`	`}`
Original file line number	Diff line number	Diff line change
`@@ -11,11 +11,11 @@`
`11`	`11`
`12`	`12`	`function autoload($className)`
`13`	`13`	`{`
`14`		`- $test = dirname(__FILE__) . '/../src/' . str_replace('_', '/', $className) . '.php';`
	`14`	`+ $test = dirname(__FILE__) . '/../src/' . str_replace('\\', '/', $className) . '.php';`
`15`	`15`	`if (file_exists($test)) {`
`16`	`16`	`require $test;`
`17`	`17`	`}`
`18`		`- $test = dirname(__FILE__) . '/' . str_replace('_', '/', $className) . '.php';`
	`18`	`+ $test = dirname(__FILE__) . '/' . str_replace('\\', '/', $className) . '.php';`
`19`	`19`	`if (file_exists($test)) {`
`20`	`20`	`require $test;`
`21`	`21`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,109 +1,117 @@`
`1`	`1`	`<?php`
`2`	`2`
	`3`	`+namespace MabeEnumTest;`
	`4`	`+`
	`5`	`+use MabeEnumTest\TestAsset\EnumWithoutDefaultValue;`
	`6`	`+use MabeEnumTest\TestAsset\EnumInheritance;`
	`7`	`+use MabeEnumTest\TestAsset\EnumAmbiguous;`
	`8`	`+use PHPUnit_Framework_TestCase as TestCase;`
	`9`	`+use ReflectionClass;`
	`10`	`+`
`3`	`11`	`/**`
`4`		`- * Unit tests for the class MabeEnum_Enum`
	`12`	`+ * Unit tests for the class MabeEnum\Enum`
`5`	`13`	`*`
`6`	`14`	`* @link http://github.com/marc-mabe/php-enum for the canonical source repository`
`7`	`15`	`* @copyright Copyright (c) 2012 Marc Bennewitz`
`8`	`16`	`* @license http://github.com/marc-mabe/php-enum/blob/master/LICENSE.txt New BSD License`
`9`	`17`	`*/`
`10`		`-class MabeEnumTest_EnumTest extends PHPUnit_Framework_TestCase`
	`18`	`+class EnumTest extends TestCase`
`11`	`19`	`{`
`12`	`20`	`public function testGetNameReturnsConstantNameOfCurrentValue()`
`13`	`21`	`{`
`14`		`- $enum = MabeEnumTest_TestAsset_EnumWithoutDefaultValue::get(MabeEnumTest_TestAsset_EnumWithoutDefaultValue::ONE);`
	`22`	`+ $enum = EnumWithoutDefaultValue::get(EnumWithoutDefaultValue::ONE);`
`15`	`23`	`$this->assertSame('ONE', $enum->getName());`
`16`	`24`	`}`
`17`	`25`
`18`	`26`	`public function testToStringMagicMethodReturnsValueAsString()`
`19`	`27`	`{`
`20`		`- $enum = MabeEnumTest_TestAsset_EnumWithoutDefaultValue::get(MabeEnumTest_TestAsset_EnumWithoutDefaultValue::ONE);`
	`28`	`+ $enum = EnumWithoutDefaultValue::get(EnumWithoutDefaultValue::ONE);`
`21`	`29`	`$this->assertSame('1', $enum->__toString());`
`22`	`30`	`}`
`23`	`31`
`24`	`32`	`public function testEnumInheritance()`
`25`	`33`	`{`
`26`		`- $enum = MabeEnumTest_TestAsset_EnumInheritance::get(MabeEnumTest_TestAsset_EnumInheritance::ONE);`
	`34`	`+ $enum = EnumInheritance::get(EnumInheritance::ONE);`
`27`	`35`	`$this->assertSame(array(`
`28`	`36`	`'ONE' => 1,`
`29`	`37`	`'TWO' => 2,`
`30`	`38`	`'INHERITANCE' => 'Inheritance'`
`31`	`39`	`), $enum::getConstants());`
`32`		`- $this->assertSame(MabeEnumTest_TestAsset_EnumInheritance::ONE, $enum->getValue());`
	`40`	`+ $this->assertSame(EnumInheritance::ONE, $enum->getValue());`
`33`	`41`	`$this->assertSame(0, $enum->getOrdinal());`
`34`	`42`
`35`		`- $enum = MabeEnumTest_TestAsset_EnumInheritance::get(MabeEnumTest_TestAsset_EnumInheritance::INHERITANCE);`
`36`		`- $this->assertSame(MabeEnumTest_TestAsset_EnumInheritance::INHERITANCE, $enum->getValue());`
	`43`	`+ $enum = EnumInheritance::get(EnumInheritance::INHERITANCE);`
	`44`	`+ $this->assertSame(EnumInheritance::INHERITANCE, $enum->getValue());`
`37`	`45`	`$this->assertSame(2, $enum->getOrdinal());`
`38`	`46`	`}`
`39`	`47`
`40`	`48`	`public function testConstructorStrictValue()`
`41`	`49`	`{`
`42`		`- $enum = MabeEnumTest_TestAsset_EnumWithoutDefaultValue::get(MabeEnumTest_TestAsset_EnumWithoutDefaultValue::ONE);`
	`50`	`+ $enum = EnumWithoutDefaultValue::get(EnumWithoutDefaultValue::ONE);`
`43`	`51`	`$this->assertSame(1, $enum->getValue());`
`44`	`52`	`$this->assertSame(0, $enum->getOrdinal());`
`45`	`53`	`}`
`46`	`54`
`47`	`55`	`public function testConstuctorNonStrictValue()`
`48`	`56`	`{`
`49`		`- $enum = MabeEnumTest_TestAsset_EnumWithoutDefaultValue::get((string)MabeEnumTest_TestAsset_EnumWithoutDefaultValue::TWO);`
	`57`	`+ $enum = EnumWithoutDefaultValue::get((string)EnumWithoutDefaultValue::TWO);`
`50`	`58`	`$this->assertSame(2, $enum->getValue());`
`51`	`59`	`$this->assertSame(1, $enum->getOrdinal());`
`52`	`60`	`}`
`53`	`61`
`54`	`62`	`public function testConstructorInvalidValueThrowsInvalidArgumentException()`
`55`	`63`	`{`
`56`	`64`	`$this->setExpectedException('InvalidArgumentException');`
`57`		`- MabeEnumTest_TestAsset_EnumWithoutDefaultValue::get('unknown');`
	`65`	`+ EnumWithoutDefaultValue::get('unknown');`
`58`	`66`	`}`
`59`	`67`
`60`	`68`	`public function testCallingGetOrdinalTwoTimesWillResultTheSameValue()`
`61`	`69`	`{`
`62`		`- $enum = MabeEnumTest_TestAsset_EnumWithoutDefaultValue::get(MabeEnumTest_TestAsset_EnumWithoutDefaultValue::TWO);`
	`70`	`+ $enum = EnumWithoutDefaultValue::get(EnumWithoutDefaultValue::TWO);`
`63`	`71`	`$this->assertSame(1, $enum->getOrdinal());`
`64`	`72`	`$this->assertSame(1, $enum->getOrdinal());`
`65`	`73`	`}`
`66`	`74`
`67`	`75`	`public function testInstantiateUsingMagicMethod()`
`68`	`76`	`{`
`69`		`- $enum = MabeEnumTest_TestAsset_EnumInheritance::ONE();`
`70`		`- $this->assertInstanceOf('MabeEnumTest_TestAsset_EnumInheritance', $enum);`
`71`		`- $this->assertSame(MabeEnumTest_TestAsset_EnumInheritance::ONE, $enum->getValue());`
	`77`	`+ $enum = EnumInheritance::ONE();`
	`78`	`+ $this->assertInstanceOf('MabeEnumTest\TestAsset\EnumInheritance', $enum);`
	`79`	`+ $this->assertSame(EnumInheritance::ONE, $enum->getValue());`
`72`	`80`	`}`
`73`	`81`
`74`	`82`	`public function testInstantiateUsingMagicMethodThrowsBadMethodCallException()`
`75`	`83`	`{`
`76`	`84`	`$this->setExpectedException('BadMethodCallException');`
`77`		`- MabeEnumTest_TestAsset_EnumInheritance::UNKNOWN();`
	`85`	`+ EnumInheritance::UNKNOWN();`
`78`	`86`	`}`
`79`	`87`
`80`	`88`	`public function testAmbuguousConstantsThrowsLogicException()`
`81`	`89`	`{`
`82`	`90`	`$this->setExpectedException('LogicException');`
`83`		`- MabeEnumTest_TestAsset_EnumAmbiguous::get(MabeEnumTest_TestAsset_EnumAmbiguous::AMBIGUOUS1);`
	`91`	`+ EnumAmbiguous::get(EnumAmbiguous::AMBIGUOUS1);`
`84`	`92`	`}`
`85`	`93`
`86`	`94`	`public function testSingleton()`
`87`	`95`	`{`
`88`		`- $enum1 = MabeEnumTest_TestAsset_EnumWithoutDefaultValue::get(MabeEnumTest_TestAsset_EnumWithoutDefaultValue::ONE);`
`89`		`- $enum2 = MabeEnumTest_TestAsset_EnumWithoutDefaultValue::ONE();`
	`96`	`+ $enum1 = EnumWithoutDefaultValue::get(EnumWithoutDefaultValue::ONE);`
	`97`	`+ $enum2 = EnumWithoutDefaultValue::ONE();`
`90`	`98`	`$this->assertSame($enum1, $enum2);`
`91`	`99`	`}`
`92`	`100`
`93`	`101`	`public function testClear()`
`94`	`102`	`{`
`95`		`- $enum1 = MabeEnumTest_TestAsset_EnumWithoutDefaultValue::ONE();`
`96`		`- MabeEnumTest_TestAsset_EnumWithoutDefaultValue::clear();`
`97`		`- $enum2 = MabeEnumTest_TestAsset_EnumWithoutDefaultValue::ONE();`
`98`		`- $enum3 = MabeEnumTest_TestAsset_EnumWithoutDefaultValue::ONE();`
	`103`	`+ $enum1 = EnumWithoutDefaultValue::ONE();`
	`104`	`+ EnumWithoutDefaultValue::clear();`
	`105`	`+ $enum2 = EnumWithoutDefaultValue::ONE();`
	`106`	`+ $enum3 = EnumWithoutDefaultValue::ONE();`
`99`	`107`
`100`	`108`	`$this->assertNotSame($enum1, $enum2);`
`101`	`109`	`$this->assertSame($enum2, $enum3);`
`102`	`110`	`}`
`103`	`111`
`104`	`112`	`public function testCloneNotCallableAndThrowsLogicException()`
`105`	`113`	`{`
`106`		`- $enum = MabeEnumTest_TestAsset_EnumWithoutDefaultValue::ONE();`
	`114`	`+ $enum = EnumWithoutDefaultValue::ONE();`
`107`	`115`
`108`	`116`	`$reflectionClass = new ReflectionClass($enum);`
`109`	`117`	`$reflectionMethod = $reflectionClass->getMethod('__clone');`
Original file line number	Diff line number	Diff line change
`@@ -1,12 +1,16 @@`
`1`	`1`	`<?php`
`2`	`2`
	`3`	`+namespace MabeEnumTest\TestAsset;`
	`4`	`+`
	`5`	`+use MabeEnum\Enum;`
	`6`	`+`
`3`	`7`	`/**`
`4`		`- * Unit tests for the class MabeEnum_Enum`
	`8`	`+ * Unit tests for the class MabeEnum\Enum`
`5`	`9`	`*`
`6`	`10`	`* @link http://github.com/marc-mabe/php-enum for the canonical source repository`
`7`	`11`	`* @copyright Copyright (c) 2012 Marc Bennewitz`
`8`	`12`	`* @license http://github.com/marc-mabe/php-enum/blob/master/LICENSE.txt New BSD License`
`9`	`13`	`*/`
`10`		`-class MabeEnumTest_TestAsset_EmptyEnum extends MabeEnum_Enum`
	`14`	`+class EmptyEnum extends Enum`
`11`	`15`	`{`
`12`	`16`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,13 +1,15 @@`
`1`	`1`	`<?php`
`2`	`2`
	`3`	`+namespace MabeEnumTest\TestAsset;`
	`4`	`+`
`3`	`5`	`/**`
`4`		`- * Unit tests for the class MabeEnum_Enum`
	`6`	`+ * Unit tests for the class MabeEnum\Enum`
`5`	`7`	`*`
`6`	`8`	`* @link http://github.com/marc-mabe/php-enum for the canonical source repository`
`7`	`9`	`* @copyright Copyright (c) 2012 Marc Bennewitz`
`8`	`10`	`* @license http://github.com/marc-mabe/php-enum/blob/master/LICENSE.txt New BSD License`
`9`	`11`	`*/`
`10`		`-class MabeEnumTest_TestAsset_EnumInheritance extends MabeEnumTest_TestAsset_EnumWithoutDefaultValue`
	`12`	`+class EnumInheritance extends EnumWithoutDefaultValue`
`11`	`13`	`{`
`12`	`14`	`const INHERITANCE = 'Inheritance';`
`13`	`15`	`}`