Kint\Test\KintTest::getCalleeInfoProvider()

Complexity

Conditions	3
Paths	2

Size

Total Lines	179
Code Lines	122

Duplication

Lines	0
Ratio	0 %

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
B	KintTest::testSetStatesFromStaticsStringPlugins()	0	38	3
A	KintTest::testSetStatesFromStaticsEmpty()	0	15	1
B	KintTest::testSetStatesFromCallInfo()	0	31	1
A	KintTest::testDumpAll()	0	18	1
A	KintTest::testDumpNothing()	0	14	1
A	KintTest::testDumpAllUnmatchingArgs()	8	8	1
A	KintTest::testDumpAllIncorrectBase()	8	8	1

<?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();

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

        $r = new TextRenderer();

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

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

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

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

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

This method seems to be duplicated in your project.

    {
        $p = new Parser();

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

        $p2 = new Parser();

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

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

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

        $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()

This method seems to be duplicated in your project.

    {
        $r = new TextRenderer();

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

        $r2 = new TextRenderer();

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

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

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

        $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();

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

        $p2 = new TimestampPlugin();

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

        $p3 = new TimestampPlugin();

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

        $p4 = new TimestampPlugin();

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

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

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

        $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');

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

        $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());

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

        $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());

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

        $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();

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

        $p = new Parser();

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

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

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

        // 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());

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

        $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());

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

        $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()

This method seems to be duplicated in your project.

    {
        $p = new Parser();

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

        $r = new TextRenderer();

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

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

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

        $k->dumpAll(array($k), array(BasicObject::blank(), 'bar' => 'baz'));

array(\Kint\Object\BasicObject::blank(), 'bar' => 'baz') is of type array<integer|string,object<Kint\Object\BasicObject>|string,{"0":"object<Kint\\Object\\BasicObject>","bar":"string"}>, but the function expects a array<integer,object<Kint\Object\BasicObject>>.

    }

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

This method seems to be duplicated in your project.

    {
        $p = new Parser();

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

        $r = new TextRenderer();

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

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

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

        $k->dumpAll(array($k), array('foo'));

array('foo') is of type array<integer,string,{"0":"string"}>, but the function expects a array<integer,object<Kint\Object\BasicObject>>.

    }

    /**
     * @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());

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

        $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');

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

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

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

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

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

            }
        }

        ksort($props_array);

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

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

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

    }

    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)

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

The parameter $renderer_class is not named in camelCase.

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

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

        if ($renderer_class) {

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

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

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

        } 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(

$data was never initialized. Although not strictly required by PHP, it is generally a good practice to add $data = array(); before regardless.

            '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)

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

The parameter $param_count is not named in camelCase.

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

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

    }

    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));
    }
}