Kint_Object_MethodTest

Complexity

Total Complexity

11

Size/Duplication

Total Lines	180
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
B	testConstruct()	0	33	1
A	testConstructWrongType()	0	4	1
A	testSetAccessPathFrom()	0	51	1
A	testGetValueShort()	0	8	1
A	testGetModifiers()	0	14	1
A	testGetAccessPath()	0	7	1
B	testGetParams()	0	27	2
A	testGetPhpDocUrl()	0	8	1
A	testGetPhpDocUrlParent()	0	8	1
A	testGetPhpDocUrlUserDefined()	0	5	1

<?php

class Kint_Object_MethodTest extends PHPUnit_Framework_TestCase

Kint_Object_MethodTest does not seem to conform to the naming convention (^[A-Z][a-zA-Z0-9]*$).

{
    public function testConstruct()
    {
        $reflection = new ReflectionMethod('TestClass', 'mix');
        $m = new Kint_Object_Method($reflection);

Avoid variables with short names like $m. Configured minimum length is 3.

        $this->assertEquals('mix', $m->name);
        $this->assertEquals($reflection->getFilename(), $m->filename);
        $this->assertEquals($reflection->getStartLine(), $m->startline);
        $this->assertEquals($reflection->getEndLine(), $m->endline);
        $this->assertEquals(false, $m->internal);
        $this->assertEquals($reflection->getDocComment(), $m->docstring);
        $this->assertEquals(Kint_Object::OPERATOR_STATIC, $m->operator);
        $this->assertEquals(Kint_Object::ACCESS_PROTECTED, $m->access);
        $this->assertEquals('TestClass', $m->owner_class);
        $this->assertTrue($m->static);
        $this->assertTrue($m->final);
        $this->assertFalse($m->abstract);
        $this->assertFalse($m->internal);

        $reflection = new ReflectionMethod('ChildTestClass', '__construct');
        $parent_reflection = new ReflectionMethod('TestClass', '__construct');

$parent_reflection does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

        $m = new Kint_Object_Method($reflection);
        $this->assertEquals($parent_reflection->getDocComment(), $m->docstring);

$parent_reflection does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

        $this->assertEquals(Kint_Object::OPERATOR_OBJECT, $m->operator);
        $this->assertEquals(Kint_Object::ACCESS_PUBLIC, $m->access);
        $this->assertEquals('TestClass', $m->owner_class);

        $reflection = new ReflectionFunction('explode');
        $m = new Kint_Object_Method($reflection);
        $this->assertTrue($m->internal);
        $this->assertEquals(Kint_Object::OPERATOR_NONE, $m->operator);
        $this->assertEquals(Kint_Object::ACCESS_NONE, $m->access);
        $this->assertEquals(null, $m->owner_class);
    }

    /**
     * @expectedException \InvalidArgumentException
     */
    public function testConstructWrongType()
    {
        $m = new Kint_Object_Method(new stdClass());

$m is not used, you could remove the assignment.

Avoid variables with short names like $m. Configured minimum length is 3.

    }

    public function testSetAccessPathFrom()
    {
        $o = Kint_Object::blank('$tc');

Avoid variables with short names like $o. Configured minimum length is 3.

        $o = $o->transplant(new Kint_Object_Instance());
        $o->classname = 'TestClass';

The property classname does not seem to exist in Kint_Object.

        $m = new Kint_Object_Method(new ReflectionMethod('TestClass', '__construct'));

Avoid variables with short names like $m. Configured minimum length is 3.

        $this->assertNull($m->getAccessPath());
        $m->setAccessPathFrom($o);

$o of type object<Kint_Object> is not a sub-type of object<Kint_Object_Instance>. It seems like you assume a child class of the class Kint_Object to be always present.

        $this->assertEquals('new \\TestClass()', $m->getAccessPath());

        $m = new Kint_Object_Method(new ReflectionMethod('TestClass', 'static_method'));
        $this->assertNull($m->getAccessPath());
        $m->setAccessPathFrom($o);

$o of type object<Kint_Object> is not a sub-type of object<Kint_Object_Instance>. It seems like you assume a child class of the class Kint_Object to be always present.

        $this->assertEquals('\\TestClass::static_method()', $m->getAccessPath());

        $m = new Kint_Object_Method(new ReflectionMethod('TestClass', 'final_method'));
        $this->assertNull($m->getAccessPath());
        $m->setAccessPathFrom($o);

$o of type object<Kint_Object> is not a sub-type of object<Kint_Object_Instance>. It seems like you assume a child class of the class Kint_Object to be always present.

        $this->assertEquals('$tc->final_method()', $m->getAccessPath());

        $m = new Kint_Object_Method(new ReflectionMethod('TestClass', 'mix'));
        $this->assertNull($m->getAccessPath());
        $m->setAccessPathFrom($o);

$o of type object<Kint_Object> is not a sub-type of object<Kint_Object_Instance>. It seems like you assume a child class of the class Kint_Object to be always present.

        $this->assertEquals(
            '\\TestClass::mix(array &$x, TestClass $y = null, $z = array(...), $_ = \'string\')',
            $m->getAccessPath()
        );

        $m = new Kint_Object_Method(new ReflectionMethod('TestClass', '__clone'));
        $this->assertNull($m->getAccessPath());
        $m->setAccessPathFrom($o);

$o of type object<Kint_Object> is not a sub-type of object<Kint_Object_Instance>. It seems like you assume a child class of the class Kint_Object to be always present.

        $this->assertEquals('clone $tc', $m->getAccessPath());

        $m = new Kint_Object_Method(new ReflectionMethod('TestClass', '__invoke'));
        $this->assertNull($m->getAccessPath());
        $m->setAccessPathFrom($o);

$o of type object<Kint_Object> is not a sub-type of object<Kint_Object_Instance>. It seems like you assume a child class of the class Kint_Object to be always present.

        $this->assertEquals('$tc($x)', $m->getAccessPath());

        // Tests both tostring and case insensitivity
        $m = new Kint_Object_Method(new ReflectionMethod('TestClass', '__tostring'));
        $this->assertNull($m->getAccessPath());
        $m->setAccessPathFrom($o);

$o of type object<Kint_Object> is not a sub-type of object<Kint_Object_Instance>. It seems like you assume a child class of the class Kint_Object to be always present.

        $this->assertEquals('__ToStRiNg', $m->name);
        $this->assertEquals('(string) $tc', $m->getAccessPath());

        $m = new Kint_Object_Method(new ReflectionMethod('TestClass', '__get'));
        $this->assertNull($m->getAccessPath());
        $m->setAccessPathFrom($o);

$o of type object<Kint_Object> is not a sub-type of object<Kint_Object_Instance>. It seems like you assume a child class of the class Kint_Object to be always present.

        $this->assertNull($m->getAccessPath());
    }

    public function testGetValueShort()
    {
        $m = new Kint_Object_Method(new ReflectionMethod('TestClass', '__construct'));

Avoid variables with short names like $m. Configured minimum length is 3.

        $this->assertEquals(
            'This is a constructor for a TestClass with the first line of the docstring split into two different lines.',
            $m->getValueShort()
        );
    }

    public function testGetModifiers()
    {
        $m = new Kint_Object_Method(new ReflectionMethod('TestClass', 'static_method'));

Avoid variables with short names like $m. Configured minimum length is 3.

        $this->assertEquals('private static', $m->getModifiers());

        $m = new Kint_Object_Method(new ReflectionMethod('TestClass', 'final_method'));
        $this->assertEquals('final public', $m->getModifiers());

        $m = new Kint_Object_Method(new ReflectionMethod('ReflectionFunctionAbstract', '__toString'));
        $this->assertEquals('abstract public', $m->getModifiers());

        $m = new Kint_Object_Method(new ReflectionMethod('TestClass', 'mix'));
        $this->assertEquals('final protected static', $m->getModifiers());
    }

    public function testGetAccessPath()
    {
        $m = new Kint_Object_Method(new ReflectionMethod('TestClass', 'array_hint'));

Avoid variables with short names like $m. Configured minimum length is 3.

        $this->assertNull($m->getAccessPath());
        $m->access_path = '$m->array_hint';
        $this->assertEquals('$m->array_hint(array $x)', $m->getAccessPath());
    }

    public function testGetParams()
    {
        $m = new Kint_Object_Method(new ReflectionFunction('explode'));

Avoid variables with short names like $m. Configured minimum length is 3.

        if (defined('HHVM_VERSION')) {
            $this->assertStringStartsWith('HH\\string $delimiter, HH\\string $str, HH\\int $limit = ', $m->getParams());
        } else {
            $this->assertEquals('$separator, $str, $limit', $m->getParams());
        }

        $m = new Kint_Object_Method(new ReflectionMethod('TestClass', 'array_hint'));
        $this->assertEquals('array $x', $m->getParams());

        $m = new Kint_Object_Method(new ReflectionMethod('TestClass', 'class_hint'));
        $this->assertEquals('TestClass $x', $m->getParams());

        $m = new Kint_Object_Method(new ReflectionMethod('TestClass', 'ref'));
        $this->assertEquals('&$x', $m->getParams());

        $m = new Kint_Object_Method(new ReflectionMethod('TestClass', 'default_method'));
        $this->assertEquals('$x = 1234', $m->getParams());

        $m = new Kint_Object_Method(new ReflectionMethod('TestClass', 'mix'));
        $this->assertEquals(
            'array &$x, TestClass $y = null, $z = array(...), $_ = \'string\'',
            $m->getParams()
        );
    }

    public function testGetPhpDocUrl()
    {
        $m = new Kint_Object_Method(new ReflectionMethod('ReflectionMethod', '__construct'));

Avoid variables with short names like $m. Configured minimum length is 3.

        $this->assertEquals(
            'https://secure.php.net/reflectionmethod.construct',
            $m->getPhpDocUrl()
        );
    }

    public function testGetPhpDocUrlParent()
    {
        $m = new Kint_Object_Method(new ReflectionMethod('ReflectionMethod', '__clone'));

Avoid variables with short names like $m. Configured minimum length is 3.

        $this->assertEquals(
            'https://secure.php.net/reflectionfunctionabstract.clone',
            $m->getPhpDocUrl()
        );
    }

    public function testGetPhpDocUrlUserDefined()
    {
        $m = new Kint_Object_Method(new ReflectionMethod(__CLASS__, __FUNCTION__));

Avoid variables with short names like $m. Configured minimum length is 3.

        $this->assertNull($m->getPhpDocUrl());
    }
}