Test enhancement

composer.json

@@ -23,6 +23,10 @@
     "autoload-dev": {
         "psr-4": {
             "Brick\\Reflection\\Tests\\": "tests/"
-        }
+        },
+        "files": [
+            "tests/reflectedFunc.php",
+            "tests/reflectedParameterFunc.php"
+        ]
     }
-}
+}

tests/ImportResolverTest.php

@@ -51,4 +51,47 @@ public function testAliasedImport()
         $this->assertResolve(Tools::class . '\A', 'Tools\A');
         $this->assertResolve(Tools::class . '\A\B', 'Tools\A\B');
     }
+
+    /**
+     * @expectedException        \InvalidArgumentException
+     * @expectedExceptionMessage Cannot infer the file name from the given ReflectionObject
+     */
+    public function testConstructorWithInvalidInferFileNameShouldThrowInvalidArgumentException()
+    {
+        $resolver = new ImportResolver(new \ReflectionObject(new \Exception));
+    }
+
+    public function testConstructorWithReflectionProperty()
+    {
+        $resolver = new ImportResolver(new \ReflectionProperty(ReflectionTarget::class, 'foo'));
+
+        $this->assertResolve(ReflectionTarget::class, 'ReflectionTarget');
+    }
+
+    public function testConstructorWithReflectionMethod()
+    {
+        $resolver = new ImportResolver(new \ReflectionMethod(ReflectionTarget::class, 'publicStaticMethod'));
+
+        $this->assertResolve('Brick\Reflection\Tests\publicStaticMethod', 'publicStaticMethod');
+    }
+
+    public function testConstructorWithReflectionParameter()
+    {
+        $resolver = new ImportResolver(new \ReflectionParameter([
+            ReflectionTarget::class, 'privateFunc',
+        ], 'str'));
+
+        $this->assertResolve('Brick\Reflection\Tests\privateFunc', 'privateFunc');
+    }
+
+    /**
+     * @expectedException        \InvalidArgumentException
+     * @expectedExceptionMessage Cannot infer the declaring class from the given ReflectionFunction
+     */
+    public function testConstructorWithReflectedFunctionShouldThrowInvalidArgumentException()
+    {
+        $resolver = new ImportResolver(new \ReflectionFunction('Brick\Reflection\Tests\reflectedFunc'));
+
+        $this->assertNull($resolver);
+    }
 }

tests/ReflectionTarget.php

@@ -0,0 +1,47 @@
+<?php
+
+namespace Brick\Reflection\Tests;
+
+/**
+ * The Reflection Target class.
+ */
+class ReflectionTarget
+{
+    /**
+     * @param string $foo
+     */
+    private $foo;
+
+    /**
+     * @var string $bar
+     */
+    private $bar;
+
+    /**
+     * @var \\Exception $barWithType
+     */
+    private $barWithType;
+
+    public function __construct()
+    {
+        $this->foo = 'foo';
+        $this->bar = 'bar';
+    }
+
+    /**
+     * @param  string $str
+     * @return string $str
+     */
+    private function privateFunc(string $str)
+    {
+        return $str;
+    }
+
+    /**
+     * @return void
+     */
+    public static function publicStaticMethod()
+    {
+        return 'publicStaticMethod';
+    }
+}

tests/ReflectionToolsTest.php

@@ -19,6 +19,85 @@ public function testGetMethodsDoesNotReturnStaticMethods()
         $this->assertCount(0, $methods);
     }
 
+    public function testGetReflectionFunction()
+    {
+        $reflectionFunc = function()
+        {
+            return 'reflectedFunction';
+        };
+        $functions = (new ReflectionTools)->getReflectionFunction($reflectionFunc);
+
+        $this->assertCount(0, $functions->getParameters());
+    }
+
+    public function testGetFunctionParameterTypesShouldReturnEmptyArray()
+    {
+        $functions = (new ReflectionTools)->getFunctionParameterTypes(new \ReflectionFunction('Brick\Reflection\Tests\reflectedFunc'));
+
+        $this->assertCount(0, $functions);
+        $this->assertSame([], $functions);
+    }
+
+    public function testGetFunctionParameterTypesShouldReturnTypesArray()
+    {
+        $functions = (new ReflectionTools)->getFunctionParameterTypes(new \ReflectionFunction('Brick\Reflection\Tests\reflectedParameterFunc'));
+
+        $this->assertCount(1, $functions);
+        $this->assertSame('string', $functions['arg'][0]);
+    }
+
+    public function testGetParameterTypesShouldReturnTypeArray()
+    {
+        $parameters = (new ReflectionTools)->getParameterTypes(new \ReflectionParameter([
+            ReflectionTarget::class, 'privateFunc',
+        ], 'str'));
+
+        $this->assertCount(1, $parameters);
+        $this->assertSame('string', $parameters[0]);
+    }
+
+    public function testGetPropertyTypesShouldReturnEmptyArray()
+    {
+        $properties = (new ReflectionTools)->getPropertyTypes(new \ReflectionProperty(ReflectionTarget::class, 'foo'));
+
+        $this->assertCount(0, $properties);
+    }
+
+    public function testGetPropertyTypesShouldReturnTypeArray()
+    {
+        $properties = (new ReflectionTools)->getPropertyTypes(new \ReflectionProperty(ReflectionTarget::class, 'bar'));
+
+        $this->assertCount(1, $properties);
+    }
+
+    public function testGetPropertyClassShouldReturnNull()
+    {
+        $propertyClass = (new ReflectionTools)->getPropertyClass(new \ReflectionProperty(ReflectionTarget::class, 'foo'));
+
+        $this->assertNull($propertyClass);
+    }
+
+    public function testGetPropertyClassShouldReturnTypeString()
+    {
+        $propertyClass = (new ReflectionTools)->getPropertyClass(new \ReflectionProperty(ReflectionTarget::class, 'barWithType'));
+
+        $this->assertSame('\Exception', $propertyClass);
+    }
+
+    public function testGetFunctionNameShouldReturnClassMethodName()
+    {
+        $functionName = (new ReflectionTools)->getFunctionName(new \ReflectionMethod(ReflectionTarget::class, 'publicStaticMethod'));
+
+        $this->assertSame('Brick\Reflection\Tests\ReflectionTarget::publicStaticMethod', $functionName);
+    }
+
+    public function testGetFunctionNameShouldReturnCurrentFunctionName()
+    {
+        $functionName = (new ReflectionTools)->getFunctionName(new \ReflectionFunction('Brick\Reflection\Tests\reflectedFunc'));
+
+        $this->assertSame('Brick\Reflection\Tests\reflectedFunc', $functionName);
+    }
+
     /**
      * @return void
      */

tests/reflectedFunc.php

@@ -0,0 +1,11 @@
+<?php
+
+namespace Brick\Reflection\Tests;
+
+/**
+ * The Target Reflection function without parameter.
+ */
+function reflectedFunc()
+{
+    return 'test';
+}

tests/reflectedParameterFunc.php

@@ -0,0 +1,12 @@
+<?php
+
+namespace Brick\Reflection\Tests;
+
+/**
+ * The Target Reflection function with string parameter.
+ * @param string $arg
+ */
+function reflectedParameterFunc(string $arg)
+{
+    return isset($arg) ? $arg : 'test';
+}