KintTest::getCallInfoProvider() - Code Metrics - Inspection of "The great Kint\Kint refactor" - jnvsor/kint - Measure and Improve Code Quality continuously with Scrutinizer

Test Setup Failed
Push — test ( dd7d7c...b3915a )

by Jonathan
created 2018-04-22 14:34 UTC
KintTest::getCallInfoProvider() B

↳ Parent: KintTest
Complexity

Conditions	3
Paths	2
Size

Total Lines	319
Code Lines	222
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	3
eloc	222
nc	2
nop	0
dl	0
loc	319
rs	8.2857
c	0
b	0
f	0
How to fix Long Method

<?php

namespace Kint\Test;

use Kint\Kint;
use Kint\Object\BasicObject;
use Kint\Parser\Parser;
use Kint\Parser\TimestampPlugin;
use Kint\Renderer\TextRenderer;
use Kint\Test\Fixtures\Php56TestClass;
use Kint\Test\Fixtures\TestClass;
use Prophecy\Argument;
use ReflectionClass;
use ReflectionProperty;

class KintTest extends KintTestCase
{
    /**
     * @covers \Kint\Kint::__construct
     * @covers \Kint\Kint::getParser
     * @covers \Kint\Kint::getRenderer
     */
    public function testConstruct()
    {
        $p = new Parser();

        $r = new TextRenderer();


        $k = new Kint($p, $r);


        $this->assertSame($p, $k->getParser());
        $this->assertSame($r, $k->getRenderer());
    }

    /**
     * @covers \Kint\Kint::setParser
     * @covers \Kint\Kint::getParser
     */
    public function testGetSetParser()

    {
        $p = new Parser();

        $p2 = new Parser();


        $k = new Kint($p, new TextRenderer());


        $this->assertSame($p, $k->getParser());
        $k->setParser($p2);
        $this->assertSame($p2, $k->getParser());
        $this->assertNotSame($p, $p2);
    }

    /**
     * @covers \Kint\Kint::setRenderer
     * @covers \Kint\Kint::getRenderer
     */
    public function testGetSetRenderer()

    {
        $r = new TextRenderer();

        $r2 = new TextRenderer();


        $k = new Kint(new Parser(), $r);


        $this->assertSame($r, $k->getRenderer());
        $k->setRenderer($r2);
        $this->assertSame($r2, $k->getRenderer());
        $this->assertNotSame($r, $r2);
    }

    /**
     * @covers \Kint\Kint::setStatesFromStatics
     */
    public function testSetStatesFromStatics()
    {
        $p1 = new TimestampPlugin();

        $p2 = new TimestampPlugin();

        $p3 = new TimestampPlugin();

        $p4 = new TimestampPlugin();


        $parser = $this->prophesize('Kint\\Parser\\Parser');
        $renderer = $this->prophesize('Kint\\Renderer\\TextRenderer');
        $k = new Kint($parser->reveal(), $renderer->reveal());


        $renderer->setExpand(true)->shouldBeCalledTimes(1);
        $renderer->setReturnMode(true)->shouldBeCalledTimes(1);
        $renderer->setShowTrace(true)->shouldBeCalledTimes(1);

        $parser->setDepthLimit(42)->shouldBeCalledTimes(1);
        $parser->clearPlugins()->shouldBeCalledTimes(1);

        $renderer->filterParserPlugins(array($p1, $p2, $p3, $p4))->shouldBeCalledTimes(1)->willReturn(array($p1, $p3, $p4));

        // Argument::that is a workaround for a bug in prophet's Argument::is
        $parser->addPlugin(
            Argument::that(function ($arg) use ($p1) {
                return $arg === $p1;
            })
        )->shouldBeCalledTimes(1);
        $parser->addPlugin(
            Argument::that(function ($arg) use ($p3) {
                return $arg === $p3;
            })
        )->shouldBeCalledTimes(1);
        $parser->addPlugin(
            Argument::that(function ($arg) use ($p4) {
                return $arg === $p4;
            })
        )->shouldBeCalledTimes(1);

        $k->setStatesFromStatics(array(
            'expanded' => true,
            'return' => true,
            'display_called_from' => true,
            'max_depth' => 42,
            'plugins' => array($p1, $p2, $p3, $p4),
        ));
    }

    /**
     * @covers \Kint\Kint::setStatesFromStatics
     */
    public function testSetStatesFromStaticsStringPlugins()
    {
        $r = new ReflectionProperty('Kint\\Kint', 'plugin_pool');

        $r->setAccessible(true);
        $r->setValue(array());

        $parser = $this->prophesize('Kint\\Parser\\Parser');
        $renderer = $this->prophesize('Kint\\Renderer\\TextRenderer');
        $k = new Kint($parser->reveal(), $renderer->reveal());


        $renderer->setExpand(false)->shouldBeCalledTimes(1);
        $renderer->setReturnMode(false)->shouldBeCalledTimes(1);
        $renderer->setShowTrace(false)->shouldBeCalledTimes(1);

        $parser->setDepthLimit(false)->shouldBeCalledTimes(1);
        $parser->clearPlugins()->shouldBeCalledTimes(1);

        $renderer->filterParserPlugins(Argument::any())->shouldBeCalledTimes(1)->will(function ($args) {
            $out = array();

            foreach ($args[0] as $plugin) {
                if ($plugin instanceof TimestampPlugin) {
                    $out[] = $plugin;
                }
            }

            return $out;
        });

        $parser->addPlugin(Argument::type('Kint\\Parser\\TimestampPlugin'))->shouldBeCalledTimes(1);

        $k->setStatesFromStatics(array(
            'plugins' => array(
                'Kint\\Parser\\TimestampPlugin',
                'Kint\\Parser\\MicrotimePlugin',
            ),
        ));
    }

    /**
     * @covers \Kint\Kint::setStatesFromStatics
     */
    public function testSetStatesFromStaticsEmpty()
    {
        $parser = $this->prophesize('Kint\\Parser\\Parser');
        $renderer = $this->prophesize('Kint\\Renderer\\TextRenderer');
        $k = new Kint($parser->reveal(), $renderer->reveal());


        $renderer->setExpand(false)->shouldBeCalledTimes(1);
        $renderer->setReturnMode(false)->shouldBeCalledTimes(1);
        $renderer->setShowTrace(false)->shouldBeCalledTimes(1);

        $parser->setDepthLimit(false)->shouldBeCalledTimes(1);
        $parser->clearPlugins()->shouldBeCalledTimes(1);

        $k->setStatesFromStatics(array());
    }

    /**
     * @covers \Kint\Kint::setStatesFromCallInfo
     */
    public function testSetStatesFromCallInfo()
    {
        $r = new TextRenderer();

        $p = new Parser();

        $k = new Kint($p, $r);


        // Set up defaults
        $k->setStatesFromStatics(array(
            'max_depth' => 42,
        ));

        $k->setStatesFromCallInfo(array('foo' => 'bar'));

        $this->assertSame(array('foo' => 'bar'), $r->getCallInfo());
        $this->assertFalse($r->getExpand());
        $this->assertFalse($r->getReturnMode());
        $this->assertSame(42, $p->getDepthLimit());
        $this->assertNull($p->getCallerClass());

        $k->setStatesFromCallInfo(array(
            'modifiers' => array('!', '@', '+'),
            'caller' => array(
                'class' => 'test1234',
            ),
        ));

        $this->assertTrue($r->getExpand());
        $this->assertTrue($r->getReturnMode());
        $this->assertFalse($p->getDepthLimit());
        $this->assertSame('test1234', $p->getCallerClass());
    }

    /**
     * @covers \Kint\Kint::dumpAll
     */
    public function testDumpAll()
    {
        $parser = $this->prophesize('Kint\\Parser\\Parser');
        $renderer = $this->prophesize('Kint\\Renderer\\TextRenderer');
        $k = new Kint($parser->reveal(), $renderer->reveal());


        $dumpee = $k;
        $base = BasicObject::blank();

        $renderer->preRender()->shouldBeCalledTimes(1)->willReturn('pre.');

        $parser->parse(Argument::is($dumpee), Argument::is($base))->shouldBeCalledTimes(2)->willReturn($base);
        $renderer->render(Argument::is($base))->shouldBeCalledTimes(2)->willReturn('render.');

        $renderer->postRender()->shouldBeCalledTimes(1)->willReturn('post');

        $this->assertSame('pre.render.render.post', $k->dumpAll(array($dumpee, $dumpee), array($base, $base)));
    }

    /**
     * @covers \Kint\Kint::dumpAll
     */
    public function testDumpNothing()
    {
        $parser = $this->prophesize('Kint\\Parser\\Parser');
        $renderer = $this->prophesize('Kint\\Renderer\\TextRenderer');
        $k = new Kint($parser->reveal(), $renderer->reveal());


        $renderer->preRender()->shouldBeCalledTimes(1)->willReturn('pre.');
        $renderer->renderNothing()->shouldBeCalledTimes(1)->willReturn('nothing.');
        $renderer->postRender()->shouldBeCalledTimes(1)->willReturn('post');

        $parser->parse()->shouldNotBeCalled();

        $this->assertSame('pre.nothing.post', $k->dumpAll(array(), array()));
    }

    /**
     * @covers \Kint\Kint::dumpAll
     * @expectedException \InvalidArgumentException
     */
    public function testDumpAllUnmatchingArgs()

    {
        $p = new Parser();

        $r = new TextRenderer();

        $k = new Kint($p, $r);


        $k->dumpAll(array($k), array(BasicObject::blank(), 'bar' => 'baz'));
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

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

    /**
     * @covers \Kint\Kint::dumpAll
     * @expectedException \InvalidArgumentException
     */
    public function testDumpAllIncorrectBase()

    {
        $p = new Parser();

        $r = new TextRenderer();

        $k = new Kint($p, $r);


        $k->dumpAll(array($k), array('foo'));
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

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

    /**
     * @covers \Kint\Kint::dumpVar
     */
    public function testDumpVar()
    {
        $parser = $this->prophesize('Kint\\Parser\\Parser');
        $renderer = $this->prophesize('Kint\\Renderer\\TextRenderer');
        $k = new Kint($parser->reveal(), $renderer->reveal());


        $dumpee = $k;
        $base = BasicObject::blank();

        $parser->parse(Argument::is($dumpee), Argument::is($base))->shouldBeCalledTimes(1)->willReturn($base);
        $renderer->render(Argument::is($base))->shouldBeCalledTimes(1)->willReturn('render');

        $this->assertSame('render', $k->dumpVar($dumpee, $base));
    }

    /**
     * @covers \Kint\Kint::getStatics
     */
    public function testGetStatics()
    {
        $r = new ReflectionClass('Kint');


        $props = $r->getProperties(ReflectionProperty::IS_STATIC);
        $props_array = array();

        foreach ($props as $prop) {
            if ($prop->isPublic() && $prop->isStatic()) {
                $props_array[$prop->getName()] = $prop->getValue();

            }
        }

        ksort($props_array);


        $this->assertSame($props_array, $stash = Kint::getStatics());

    }

    public function staticModeProvider()
    {
        return array(
            'no options' => array(
                array(),
                false,
            ),
            'auto without cli' => array(
                array(
                    'enabled_mode' => true,
                    'mode_default' => 42,
                    'cli_detection' => false,
                    'mode_default_cli' => 43,
                    'renderers' => array(
                        42 => 'Kint\\Renderer\\RichRenderer',
                        43 => 'Kint\\Renderer\\CliRenderer',
                        44 => 'Kint\\Renderer\\PlainRenderer',
                    ),
                ),
                'Kint\\Renderer\\RichRenderer',
            ),
            'auto with cli' => array(
                array(
                    'enabled_mode' => true,
                    'mode_default' => 42,
                    'cli_detection' => true,
                    'mode_default_cli' => 43,
                    'renderers' => array(
                        42 => 'Kint\\Renderer\\RichRenderer',
                        43 => 'Kint\\Renderer\\CliRenderer',
                        44 => 'Kint\\Renderer\\PlainRenderer',
                    ),
                ),
                'Kint\\Renderer\\CliRenderer',
            ),
            'specific' => array(
                array(
                    'enabled_mode' => 44,
                    'mode_default' => 42,
                    'cli_detection' => true,
                    'mode_default_cli' => 43,
                    'renderers' => array(
                        42 => 'Kint\\Renderer\\RichRenderer',
                        43 => 'Kint\\Renderer\\CliRenderer',
                        44 => 'Kint\\Renderer\\PlainRenderer',
                    ),
                ),
                'Kint\\Renderer\\PlainRenderer',
            ),
            'disabled' => array(
                array('enabled_mode' => false),
                false,
            ),
            'missing renderer' => array(
                array(
                    'enabled_mode' => 45,
                    'mode_default' => 42,
                    'cli_detection' => true,
                    'mode_default_cli' => 43,
                    'renderers' => array(
                        42 => 'Kint\\Renderer\\RichRenderer',
                        43 => 'Kint\\Renderer\\CliRenderer',
                        44 => 'Kint\\Renderer\\PlainRenderer',
                    ),
                ),
                'Kint\\Renderer\\TextRenderer',
            ),
        );
    }

    /**
     * @covers \Kint\Kint::createFromStatics
     * @dataProvider staticModeProvider
     */
    public function testCreateFromStatics($statics, $renderer_class)

    {
        $k = Kint::createFromStatics($statics);


        if ($renderer_class) {

            $this->assertSame($renderer_class, get_class($k->getRenderer()));

        } else {
            $this->assertNull($k);
        }
    }

    public function baseProvider()
    {
        return array(
            'normal params' => array(
                array(
                    array(
                        'name' => '$a',
                        'path' => '$a',
                        'expression' => false,
                    ),
                    array(
                        'name' => '$b[...]',
                        'path' => '$b[$a]',
                        'expression' => false,
                    ),
                ),
                2,
                array(
                    BasicObject::blank('$a'),
                    BasicObject::blank('$b[...]', '$b[$a]'),
                ),
            ),
            'blacklisted params' => array(
                array(
                    array(
                        'name' => 'true',
                        'path' => 'true',
                        'expression' => false,
                    ),
                    array(
                        'name' => '[...]',
                        'path' => '[$a, $b, $c]',
                        'expression' => false,
                    ),
                ),
                2,
                array(
                    BasicObject::blank(null, 'true'),
                    BasicObject::blank(null, '[$a, $b, $c]'),
                ),
            ),
            'expression params' => array(
                array(
                    array(
                        'name' => '$a + $b',
                        'path' => '$a + $b',
                        'expression' => true,
                    ),
                    array(
                        'name' => '[...] + $c[...]',
                        'path' => '[$a, $b] + $c[$d]',
                        'expression' => true,
                    ),
                ),
                2,
                array(
                    BasicObject::blank('$a + $b', '($a + $b)'),
                    BasicObject::blank('[...] + $c[...]', '([$a, $b] + $c[$d])'),
                ),
            ),
            'missing params' => array(
                array(),
                2,
                array(
                    BasicObject::blank(null, '$0'),
                    BasicObject::blank(null, '$1'),
                ),
            ),
            'no params' => array(
                array(),
                0,
                array(),
            ),
        );
    }

    /**
     * @covers \Kint\Kint::getBasesFromParamInfo
     * @dataProvider baseProvider
     */
    public function testGetBasesFromParamInfo(array $paraminfo, $count, array $expect)
    {
        $bases = Kint::getBasesFromParamInfo($paraminfo, $count);

        $this->assertEquals($expect, $bases);
    }

    public function getCallInfoProvider()
    {
        $aliases = array(
            array('kint', 'dump'),
            'd',
            's',
        );

        $basetrace = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS);
        $basetrace[0]['file'] = __FILE__;
        $basetrace[0]['line'] = __LINE__;
        $dumpframe = array(
            'class' => 'Kint',
            'function' => 'dump',
        );

        $data['empty trace'] = array(
foreach ($collection as $item) {
    $myArray['foo'] = $item->getFoo();

    if ($item->hasBar()) {
        $myArray['bar'] = $item->getBar();
    }

    // do something with $myArray
}
            'aliases' => $aliases,
            'trace' => array(
            ),
            'param_count' => 1234,
            'expect' => array(
                'params' => null,
                'modifiers' => array(),
                'callee' => null,
                'caller' => null,
                'trace' => array(),
            ),
        );

        $data['full trace'] = array(
            'aliases' => $aliases,
            'trace' => array_merge(
                $basetrace,
                array(
                    $dumpframe + array(
                        'file' => TestClass::DUMP_FILE,
                        'line' => TestClass::DUMP_LINE,
                    ),
                ),
                array(
                    array(
                        'function' => 'usort',
                    ),
                ),
                $basetrace
            ),
            'param_count' => 1234,
            'expect' => array(
                'params' => null,
                'modifiers' => array(),
                'callee' => $dumpframe + array(
                    'file' => TestClass::DUMP_FILE,
                    'line' => TestClass::DUMP_LINE,
                ),
                'caller' => array(
                    'function' => 'usort',
                ),
                'trace' => array_merge(
                    array(
                        $dumpframe + array(
                            'file' => TestClass::DUMP_FILE,
                            'line' => TestClass::DUMP_LINE,
                        ),
                    ),
                    $basetrace
                ),
            ),
        );

        $data['unmatching trace'] = $data['full trace'];
        $data['unmatching trace']['aliases'] = array();
        $data['unmatching trace']['expect']['callee'] = null;
        $data['unmatching trace']['expect']['caller'] = null;
        $data['unmatching trace']['expect']['trace'] = array_merge(
            $basetrace,
            array(
                $dumpframe + array(
                    'file' => TestClass::DUMP_FILE,
                    'line' => TestClass::DUMP_LINE,
                ),
            ),
            $basetrace
        );

        $data['trace with params'] = array(
            'aliases' => $aliases,
            'trace' => array_merge(
                    array(
                        $dumpframe + array(
                            'file' => TestClass::DUMP_FILE,
                            'line' => TestClass::DUMP_LINE,
                        ),
                    ),
                    $basetrace
                ),
            'param_count' => 3,
            'expect' => array(
                'params' => array(
                    array('name' => '$x', 'path' => '$x', 'expression' => false),
                    array('name' => '$y', 'path' => '$y', 'expression' => false),
                    array('name' => '$z', 'path' => '$z', 'expression' => false),
                ),
                'modifiers' => array(),
                'callee' => $dumpframe + array(
                    'file' => TestClass::DUMP_FILE,
                    'line' => TestClass::DUMP_LINE,
                ),
                'caller' => $basetrace[0],
                'trace' => array_merge(
                    array(
                        $dumpframe + array(
                            'file' => TestClass::DUMP_FILE,
                            'line' => TestClass::DUMP_LINE,
                        ),
                    ),
                    $basetrace
                ),
            ),
        );

        $data['trace with modifiers'] = array(
            'aliases' => $aliases,
            'trace' => array_merge(
                    array(
                        $dumpframe + array(
                            'file' => TestClass::DUMP_FILE,
                            'line' => TestClass::DUMP_LINE + 1,
                        ),
                    ),
                    $basetrace
                ),
            'param_count' => 0,
            'expect' => array(
                'params' => array(),
                'modifiers' => array('!', '+'),
                'callee' => $dumpframe + array(
                    'file' => TestClass::DUMP_FILE,
                    'line' => TestClass::DUMP_LINE + 1,
                ),
                'caller' => $basetrace[0],
                'trace' => array_merge(
                    array(
                        $dumpframe + array(
                            'file' => TestClass::DUMP_FILE,
                            'line' => TestClass::DUMP_LINE + 1,
                        ),
                    ),
                    $basetrace
                ),
            ),
        );

        $data['trace function with modifier'] = array(
            'aliases' => $aliases,
            'trace' => array_merge(
                    array(
                        array(
                            'function' => 'd',
                            'file' => TestClass::DUMP_FILE,
                            'line' => TestClass::DUMP_LINE + 2,
                        ),
                    ),
                    $basetrace
                ),
            'param_count' => 1,
            'expect' => array(
                'params' => array(
                    array(
                        'name' => '$x',
                        'path' => '$x',
                        'expression' => false,
                    ),
                ),
                'modifiers' => array('~'),
                'callee' => array(
                    'function' => 'd',
                    'file' => TestClass::DUMP_FILE,
                    'line' => TestClass::DUMP_LINE + 2,
                ),
                'caller' => $basetrace[0],
                'trace' => array_merge(
                    array(
                        array(
                            'function' => 'd',
                            'file' => TestClass::DUMP_FILE,
                            'line' => TestClass::DUMP_LINE + 2,
                        ),
                    ),
                    $basetrace
                ),
            ),
        );

        $data['trace function with multiple hits'] = array(
            'aliases' => $aliases,
            'trace' => array_merge(
                    array(
                        array(
                            'function' => 'd',
                            'file' => TestClass::DUMP_FILE,
                            'line' => TestClass::DUMP_LINE + 3,
                        ),
                    ),
                    $basetrace
                ),
            'param_count' => 1,
            'expect' => array(
                'params' => null,
                'modifiers' => array(),
                'callee' => array(
                    'function' => 'd',
                    'file' => TestClass::DUMP_FILE,
                    'line' => TestClass::DUMP_LINE + 3,
                ),
                'caller' => $basetrace[0],
                'trace' => array_merge(
                    array(
                        array(
                            'function' => 'd',
                            'file' => TestClass::DUMP_FILE,
                            'line' => TestClass::DUMP_LINE + 3,
                        ),
                    ),
                    $basetrace
                ),
            ),
        );

        // HHVM doesn't support multiple unpack parameters
        if (KINT_PHP56 && !defined('HHVM_VERSION')) {
            $data['trace with unpack'] = array(
                'aliases' => $aliases,
                'trace' => array_merge(
                        array(
                            $dumpframe + array(
                                'file' => Php56TestClass::DUMP_FILE,
                                'line' => Php56TestClass::DUMP_LINE,
                            ),
                        ),
                        $basetrace
                    ),
                'param_count' => 4,
                'expect' => array(
                    'params' => array(
                        array(
                            'name' => '$x',
                            'path' => '$x',
                            'expression' => false,
                        ),
                        array(
                            'name' => '$y',
                            'path' => '$y',
                            'expression' => false,
                        ),
                        array(
                            'name' => 'reset($z)',
                            'path' => 'reset($z)',
                            'expression' => false,
                        ),
                        array(
                            'name' => 'array_values($z)[1]',
                            'path' => 'array_values($z)[1]',
                            'expression' => false,
                        ),
                    ),
                    'modifiers' => array(),
                    'callee' => $dumpframe + array(
                        'file' => Php56TestClass::DUMP_FILE,
                        'line' => Php56TestClass::DUMP_LINE,
                    ),
                    'caller' => $basetrace[0],
                    'trace' => array_merge(
                        array(
                            $dumpframe + array(
                                'file' => Php56TestClass::DUMP_FILE,
                                'line' => Php56TestClass::DUMP_LINE,
                            ),
                        ),
                        $basetrace
                    ),
                ),
            );

            $data['trace with double unpack'] = array(
                'aliases' => $aliases,
                'trace' => array_merge(
                        array(
                            $dumpframe + array(
                                'file' => Php56TestClass::DUMP_FILE,
                                'line' => Php56TestClass::DUMP_LINE + 1,
                            ),
                        ),
                        $basetrace
                    ),
                'param_count' => 10,
                'expect' => array(
                    'params' => array(),
                    'modifiers' => array(),
                    'callee' => $dumpframe + array(
                        'file' => Php56TestClass::DUMP_FILE,
                        'line' => Php56TestClass::DUMP_LINE + 1,
                    ),
                    'caller' => $basetrace[0],
                    'trace' => array_merge(
                        array(
                            $dumpframe + array(
                                'file' => Php56TestClass::DUMP_FILE,
                                'line' => Php56TestClass::DUMP_LINE + 1,
                            ),
                        ),
                        $basetrace
                    ),
                ),
            );
        }

        return $data;
    }

    /**
     * @dataProvider getCallInfoProvider
     * @covers \Kint\Kint::getCallInfo
     */
    public function testGetCallInfo($aliases, $trace, $param_count, $expect)

    {
        $this->assertSame($expect, Kint::getCallInfo($aliases, $trace, $param_count));

    }

    public function pathProvider()
    {
        return array(
            'standard file' => array(
                'path' => __FILE__,
                'expect' => '<tests>/KintTest.php',
            ),
            'standard dir' => array(
                'path' => __DIR__,
                'expect' => '<tests>',
            ),
            'parent dir' => array(
                'path' => KINT_DIR,
                'expect' => '<kint>',
            ),
            'sub file' => array(
                'path' => KINT_DIR.'/src//test',
                'expect' => '<kint>/src/test',
            ),
            'common path' => array(
                'path' => dirname(KINT_DIR).'/test/',
                'expect' => '.../test',
            ),
            'root path' => array(
                'path' => '/',
                'expect' => '/',
            ),
            'no common path' => array(
                'path' => '/asdfasdf/test/',
                'expect' => '/asdfasdf/test',
            ),
        );
    }

    /**
     * @dataProvider pathProvider
     * @covers \Kint\Kint::shortenPath
     */
    public function testShortenPath($path, $expect)
    {
        Kint::$app_root_dirs = array(
            KINT_DIR => '<kint>',
            KINT_DIR.'/test' => '<test>',
            '' => '<Nothing!>',
            __DIR__ => '<tests>',
            KINT_DIR.'/tes' => '<tes>',
        );

        $this->assertEquals($expect, Kint::shortenPath($path));
    }

    /**
     * @covers \Kint\Kint::getIdeLink
     */
    public function testGetIdeLink()
    {
        Kint::$file_link_format = '<a href="%f:%l">%f:%l</a>';

        $file = uniqid('', true);
        $line = uniqid('', true);

        $this->assertEquals('<a href="'.$file.':'.$line.'">'.$file.':'.$line.'</a>', Kint::getIdeLink($file, $line));
    }
}

1			<?php
2
3			namespace Kint\Test;
4
5			use Kint\Kint;
6			use Kint\Object\BasicObject;
7			use Kint\Parser\Parser;
8			use Kint\Parser\TimestampPlugin;
9			use Kint\Renderer\TextRenderer;
10			use Kint\Test\Fixtures\Php56TestClass;
11			use Kint\Test\Fixtures\TestClass;
12			use Prophecy\Argument;
13			use ReflectionClass;
14			use ReflectionProperty;
15
16			class KintTest extends KintTestCase
17			{
18			/**
19			* @covers \Kint\Kint::__construct
20			* @covers \Kint\Kint::getParser
21			* @covers \Kint\Kint::getRenderer
22			*/
23			public function testConstruct()
24			{
25			$p = new Parser();
			0 ignored issues – show Comprehensibility introduced 2018-04-22 14:37 UTC by Report Bug Copy Issue Report Avoid variables with short names like $p. 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...
26			$r = new TextRenderer();
			0 ignored issues – show Comprehensibility introduced 2018-04-22 14:37 UTC by Report Bug Copy Issue Report Avoid variables with short names like $r. 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...
27
28			$k = new Kint($p, $r);
			0 ignored issues – show Comprehensibility introduced 2018-04-22 14:37 UTC by Report Bug Copy Issue Report Avoid variables with short names like $k. 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...
29
30			$this->assertSame($p, $k->getParser());
31			$this->assertSame($r, $k->getRenderer());
32			}
33
34			/**
35			* @covers \Kint\Kint::setParser
36			* @covers \Kint\Kint::getParser
37			*/
jnvsor / kint

Push — test ( dd7d7c...b3915a )

KintTest::getCallInfoProvider() B

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like
