MethodObjectTest - Code Metrics - Inspection of "Merge coverage improvements" - jnvsor/kint - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — next ( 3fc9f0...5d2fc6 )

by Jonathan

created 2018-01-15 21:56 UTC

MethodObjectTest A

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	271
Duplicated Lines	6.64 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
dl	18
loc	271
rs	10
c	1
b	0
f	0
wmc	17
lcom	1
cbo	4

13 Methods

Rating	Name	Duplication	Size	Complexity
B	testConstruct()	0	40	1
A	testConstructWrongType()	0	9	2
A	testSetAccessPathFrom()	0	51	1
A	testGetValueShort()	0	14	1
A	testGetModifiers()	0	17	1
A	testGetAccessPath()	0	7	1
B	testGetParams()	0	31	2
A	testGetParamsPhp7()	9	9	2
A	testReturnType()	9	9	2
A	testGetPhpDocUrl()	0	8	1
A	testGetPhpDocUrlParent()	0	8	1
A	testGetPhpDocUrlUserDefined()	0	5	1
A	testGetPhpDocUrlFunction()	0	8	1

How to fix Duplicated Code

<?php

namespace Kint\Test\Object;

use Kint\Object\BasicObject;
use Kint\Object\InstanceObject;
use Kint\Object\MethodObject;
use PHPUnit_Framework_TestCase;
use ReflectionFunction;
use ReflectionMethod;
use stdClass;

class MethodObjectTest extends PHPUnit_Framework_TestCase
{
    /**
     * @covers \Kint\Object\MethodObject::__construct
     */
    public function testConstruct()
    {
        $reflection = new ReflectionMethod('Kint\\Test\\Fixtures\\TestClass', 'mix');
        $m = new MethodObject($reflection);

        $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(true, $m->return_reference);
        $this->assertEquals($reflection->getDocComment(), $m->docstring);
        $this->assertEquals(BasicObject::OPERATOR_STATIC, $m->operator);
        $this->assertEquals(BasicObject::ACCESS_PROTECTED, $m->access);
        $this->assertEquals('Kint\\Test\\Fixtures\\TestClass', $m->owner_class);
        $this->assertTrue($m->static);
        $this->assertTrue($m->final);
        $this->assertFalse($m->abstract);
        $this->assertFalse($m->internal);

        $reflection = new ReflectionMethod('Kint\\Test\\Fixtures\\ChildTestClass', '__construct');
        $parent_reflection = new ReflectionMethod('Kint\\Test\\Fixtures\\TestClass', '__construct');

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

        $this->assertEquals(BasicObject::OPERATOR_OBJECT, $m->operator);
        $this->assertEquals(BasicObject::ACCESS_PUBLIC, $m->access);
        $this->assertEquals('Kint\\Test\\Fixtures\\TestClass', $m->owner_class);

        $reflection = new ReflectionMethod('Kint\\Test\\Fixtures\\ChildTestClass', 'classHint');
        $m = new MethodObject($reflection);
        $this->assertEquals(BasicObject::OPERATOR_OBJECT, $m->operator);
        $this->assertEquals(BasicObject::ACCESS_PRIVATE, $m->access);
        $this->assertEquals('Kint\\Test\\Fixtures\\TestClass', $m->owner_class);

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

    /**
     * @covers \Kint\Object\MethodObject::__construct
     */
    public function testConstructWrongType()
    {
        if (KINT_PHP70) {
            $this->setExpectedException('TypeError');
        } else {
            $this->setExpectedException('PHPUnit_Framework_Error');
        }
        $m = new MethodObject(new stdClass());
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }

    /**
     * @covers \Kint\Object\MethodObject::setAccessPathFrom
     * @covers \Kint\Object\MethodObject::getAccessPath
     */
    public function testSetAccessPathFrom()
    {
        $o = BasicObject::blank('$tc');

        $o = $o->transplant(new InstanceObject());
        $o->classname = 'Kint\\Test\\Fixtures\\TestClass';


        $m = new MethodObject(new ReflectionMethod('Kint\\Test\\Fixtures\\TestClass', '__construct'));

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

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

        $m = new MethodObject(new ReflectionMethod('Kint\\Test\\Fixtures\\TestClass', 'staticMethod'));
        $this->assertNull($m->getAccessPath());
        $m->setAccessPathFrom($o);

        $this->assertEquals('\\Kint\\Test\\Fixtures\\TestClass::staticMethod()', $m->getAccessPath());

        $m = new MethodObject(new ReflectionMethod('Kint\\Test\\Fixtures\\TestClass', 'finalMethod'));
        $this->assertNull($m->getAccessPath());
        $m->setAccessPathFrom($o);

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

        $m = new MethodObject(new ReflectionMethod('Kint\\Test\\Fixtures\\TestClass', 'mix'));
        $this->assertNull($m->getAccessPath());
        $m->setAccessPathFrom($o);

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

        $m = new MethodObject(new ReflectionMethod('Kint\\Test\\Fixtures\\TestClass', '__clone'));
        $this->assertNull($m->getAccessPath());
        $m->setAccessPathFrom($o);

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

        $m = new MethodObject(new ReflectionMethod('Kint\\Test\\Fixtures\\TestClass', '__invoke'));
        $this->assertNull($m->getAccessPath());
        $m->setAccessPathFrom($o);

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

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

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

        $m = new MethodObject(new ReflectionMethod('Kint\\Test\\Fixtures\\TestClass', '__get'));
        $this->assertNull($m->getAccessPath());
        $m->setAccessPathFrom($o);

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

    /**
     * @covers \Kint\Object\MethodObject::getValueShort
     */
    public function testGetValueShort()
    {
        $m = new MethodObject(new ReflectionMethod('Kint\\Test\\Fixtures\\TestClass', '__construct'));

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

        $m = new MethodObject(new ReflectionFunction('explode'));
        $this->assertNull($m->getValueShort());

        $m = new MethodObject(new ReflectionMethod('Kint\\Test\\Fixtures\\TestClass', 'arrayHint'));
        $this->assertNull($m->getValueShort());
    }

    /**
     * @covers \Kint\Object\MethodObject::getModifiers
     */
    public function testGetModifiers()
    {
        $m = new MethodObject(new ReflectionMethod('Kint\\Test\\Fixtures\\TestClass', 'staticMethod'));

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

        $m = new MethodObject(new ReflectionMethod('Kint\\Test\\Fixtures\\TestClass', 'finalMethod'));
        $this->assertEquals('final public', $m->getModifiers());

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

        $m = new MethodObject(new ReflectionMethod('Kint\\Test\\Fixtures\\TestClass', 'mix'));
        $this->assertEquals('final protected static', $m->getModifiers());

        $m = new MethodObject(new ReflectionFunction('explode'));
        $this->assertNull($m->getModifiers());
    }

    /**
     * @covers \Kint\Object\MethodObject::getAccessPath
     */
    public function testGetAccessPath()
    {
        $m = new MethodObject(new ReflectionMethod('Kint\\Test\\Fixtures\\TestClass', 'arrayHint'));

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

    /**
     * @covers \Kint\Object\MethodObject::getParams
     */
    public function testGetParams()
    {
        $m = new MethodObject(new ReflectionFunction('explode'));

        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 MethodObject(new ReflectionMethod('Kint\\Test\\Fixtures\\TestClass', 'arrayHint'));
        $this->assertEquals('array $x', $m->getParams());

        // Testing cache
        $m->parameters = array();
        $this->assertEquals('array $x', $m->getParams());

        $m = new MethodObject(new ReflectionMethod('Kint\\Test\\Fixtures\\TestClass', 'classHint'));
        $this->assertEquals('Kint\\Test\\Fixtures\\TestClass $x', $m->getParams());

        $m = new MethodObject(new ReflectionMethod('Kint\\Test\\Fixtures\\TestClass', 'ref'));
        $this->assertEquals('&$x', $m->getParams());

        $m = new MethodObject(new ReflectionMethod('Kint\\Test\\Fixtures\\TestClass', 'defaultMethod'));
        $this->assertEquals('$x = 1234', $m->getParams());

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

    /**
     * @covers \Kint\Object\MethodObject::getParams
     */
    public function testGetParamsPhp7()

    {
        if (!KINT_PHP70) {
            $this->markTestSkipped('Not testing PHP7+ parameter type hints on PHP5');
        }

        $m = new MethodObject(new ReflectionMethod('Kint\\Test\\Fixtures\\Php7TestClass', 'typeHints'));

        $this->assertEquals('string $p1, int $p2, bool $p3 = false', $m->getParams());
    }

    /**
     * @covers \Kint\Object\MethodObject::__construct
     */
    public function testReturnType()

    {
        if (!KINT_PHP70) {
            $this->markTestSkipped('Not testing PHP7+ return type hints on PHP5');
        }

        $m = new MethodObject(new ReflectionMethod('Kint\\Test\\Fixtures\\Php7TestClass', 'typeHints'));

        $this->assertEquals('self', $m->returntype);
    }

    /**
     * @covers \Kint\Object\MethodObject::getPhpDocUrl
     */
    public function testGetPhpDocUrl()
    {
        $m = new MethodObject(new ReflectionMethod('ReflectionMethod', '__construct'));

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

    /**
     * @covers \Kint\Object\MethodObject::getPhpDocUrl
     */
    public function testGetPhpDocUrlParent()
    {
        $m = new MethodObject(new ReflectionMethod('ReflectionMethod', '__clone'));

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

    /**
     * @covers \Kint\Object\MethodObject::getPhpDocUrl
     */
    public function testGetPhpDocUrlUserDefined()
    {
        $m = new MethodObject(new ReflectionMethod(__CLASS__, __FUNCTION__));

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

    /**
     * @covers \Kint\Object\MethodObject::getPhpDocUrl
     */
    public function testGetPhpDocUrlFunction()
    {
        $m = new MethodObject(new ReflectionFunction('explode'));

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


1			<?php
2
3			namespace Kint\Test\Object;
4
5			use Kint\Object\BasicObject;
6			use Kint\Object\InstanceObject;
7			use Kint\Object\MethodObject;
8			use PHPUnit_Framework_TestCase;
9			use ReflectionFunction;
10			use ReflectionMethod;
11			use stdClass;
12
13			class MethodObjectTest extends PHPUnit_Framework_TestCase
14			{
15			/**
16			* @covers \Kint\Object\MethodObject::__construct
17			*/
18			public function testConstruct()
19			{
20			$reflection = new ReflectionMethod('Kint\\Test\\Fixtures\\TestClass', 'mix');
21			$m = new MethodObject($reflection);
			0 ignored issues – show Comprehensibility introduced 2018-01-13 16:08 UTC by Report Bug Copy Issue Report Avoid variables with short names like $m. Configured minimum length is 3. Short variable names may make your code harder to understand. Variable names should be self-descriptive. This check looks for variable names who are shorter than a configured minimum. Loading history...
22			$this->assertEquals('mix', $m->name);
23			$this->assertEquals($reflection->getFileName(), $m->filename);
24			$this->assertEquals($reflection->getStartLine(), $m->startline);
25			$this->assertEquals($reflection->getEndLine(), $m->endline);
26			$this->assertEquals(false, $m->internal);
27			$this->assertEquals(true, $m->return_reference);
28			$this->assertEquals($reflection->getDocComment(), $m->docstring);
29			$this->assertEquals(BasicObject::OPERATOR_STATIC, $m->operator);
30			$this->assertEquals(BasicObject::ACCESS_PROTECTED, $m->access);
31			$this->assertEquals('Kint\\Test\\Fixtures\\TestClass', $m->owner_class);
32			$this->assertTrue($m->static);
33			$this->assertTrue($m->final);
34			$this->assertFalse($m->abstract);
35			$this->assertFalse($m->internal);
36
37			$reflection = new ReflectionMethod('Kint\\Test\\Fixtures\\ChildTestClass', '__construct');
38			$parent_reflection = new ReflectionMethod('Kint\\Test\\Fixtures\\TestClass', '__construct');
			0 ignored issues – show Coding Style introduced 2018-01-13 16:08 UTC by Report Bug Copy Issue Report `$parent_reflection` does not seem to conform to the naming convention (`^[a-z][a-zA-Z0-9]*$`). This check examines a number of code elements and verifies that they conform to the given naming conventions. You can set conventions for local variables, abstract classes, utility classes, constant, properties, methods, parameters, interfaces, classes, exceptions and special methods. Loading history...

jnvsor / kint

Push — next ( 3fc9f0...5d2fc6 )

MethodObjectTest A

Complexity

Size/Duplication

Coupling/Cohesion

Importance

13 Methods

How to fix Duplicated Code

Duplicated Code

Duplication Side-by-Side

Filter issues like