BasicObjectTest::testSortByName() - Code Metrics - Inspection of "InstanceObject: 100% coverage" - jnvsor/kint - Measure and Improve Code Quality continuously with Scrutinizer

Test Setup Failed

Push — test ( 4e9ef0...2bbcf6 )

by Jonathan

created 2018-01-13 16:06 UTC

BasicObjectTest::testSortByName() A

↳ Parent: BasicObjectTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	23
Code Lines	15

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	15
nc	1
nop	0
dl	0
loc	23
rs	9.0856
c	0
b	0
f	0

<?php

namespace Kint\Test\Object;

use Kint\Object\BasicObject;
use Kint\Object\Representation\Representation;

class BasicObjectTest extends \PHPUnit_Framework_TestCase
{
    /**
     * @covers \Kint\Object\BasicObject::getRepresentations
     * @covers \Kint\Object\BasicObject::addRepresentation
     */
    public function testAddRepresentation()
    {
        $o = new BasicObject();


        $this->assertSame(array(), $o->getRepresentations());
        $this->assertSame(null, $o->value);

        $this->assertTrue($o->addRepresentation($r1 = new Representation('Rep 1')));
        $this->assertSame(
            array(
                'rep_1' => $r1,
            ),
            $o->getRepresentations()
        );
        $this->assertSame(null, $o->value);

        $this->assertFalse($o->addRepresentation($r1));
        $this->assertSame(
            array(
                'rep_1' => $r1,
            ),
            $o->getRepresentations()
        );

        $this->assertTrue($o->addRepresentation($r2 = new Representation('Rep 2')));
        $this->assertSame(
            array(
                'rep_1' => $r1,
                'rep_2' => $r2,
            ),
            $o->getRepresentations()
        );

        $this->assertTrue($o->addRepresentation($r3 = new Representation('Rep 3'), 0));
        $this->assertSame(
            array(
                'rep_3' => $r3,
                'rep_1' => $r1,
                'rep_2' => $r2,
            ),
            $o->getRepresentations()
        );

        $this->assertTrue($o->addRepresentation($r4 = new Representation('Rep 4'), 1));
        $this->assertSame(
            array(
                'rep_3' => $r3,
                'rep_4' => $r4,
                'rep_1' => $r1,
                'rep_2' => $r2,
            ),
            $o->getRepresentations()
        );

        $this->assertTrue($o->addRepresentation($r5 = new Representation('Rep 5'), 100));
        $this->assertSame(
            array(
                'rep_3' => $r3,
                'rep_4' => $r4,
                'rep_1' => $r1,
                'rep_2' => $r2,
                'rep_5' => $r5,
            ),
            $o->getRepresentations()
        );

        $this->assertTrue($o->addRepresentation($r6 = new Representation('Rep 6'), -100));
        $this->assertSame(
            array(
                'rep_6' => $r6,
                'rep_3' => $r3,
                'rep_4' => $r4,
                'rep_1' => $r1,
                'rep_2' => $r2,
                'rep_5' => $r5,
            ),
            $o->getRepresentations()
        );

        $this->assertSame(null, $o->value);
    }

    /**
     * @covers \Kint\Object\BasicObject::replaceRepresentation
     */
    public function testReplaceRepresentation()
    {
        $o = new BasicObject();

        $o->addRepresentation($r1 = new Representation('Rep 1'));
        $o->addRepresentation($r2 = new Representation('Rep 2'));
        $o->addRepresentation($r3 = new Representation('Rep 3'));

        $this->assertSame(
            array(
                'rep_1' => $r1,
                'rep_2' => $r2,
                'rep_3' => $r3,
            ),
            $o->getRepresentations()
        );

        $o->replaceRepresentation($r2_2 = new Representation('Rep 2'));


        $this->assertSame(
            array(
                'rep_1' => $r1,
                'rep_2' => $r2_2,

                'rep_3' => $r3,
            ),
            $o->getRepresentations()
        );

        $o->replaceRepresentation($r2, 0);

        $this->assertSame(
            array(
                'rep_2' => $r2,
                'rep_1' => $r1,
                'rep_3' => $r3,
            ),
            $o->getRepresentations()
        );

        $o->replaceRepresentation($r2_2, 1);


        $this->assertSame(
            array(
                'rep_1' => $r1,
                'rep_2' => $r2_2,

                'rep_3' => $r3,
            ),
            $o->getRepresentations()
        );
    }

    /**
     * @covers \Kint\Object\BasicObject::replaceRepresentation
     */
    public function testRemoveRepresentation()
    {
        $o = new BasicObject();

        $o->addRepresentation($r1 = new Representation('Rep 1'));
        $o->addRepresentation($r2 = new Representation('Rep 2'));
        $o->addRepresentation($r3 = new Representation('Rep 3'));

        $this->assertSame(
            array(
                'rep_1' => $r1,
                'rep_2' => $r2,
                'rep_3' => $r3,
            ),
            $o->getRepresentations()
        );

        $o->removeRepresentation('rep_2');

        $this->assertSame(
            array(
                'rep_1' => $r1,
                'rep_3' => $r3,
            ),
            $o->getRepresentations()
        );
    }

    /**
     * @covers \Kint\Object\BasicObject::replaceRepresentation
     */
    public function testGetRepresentation()
    {
        $o = new BasicObject();

        $o->addRepresentation($r1 = new Representation('Rep 1'));
        $o->addRepresentation($r2 = new Representation('Rep 2'));
        $o->addRepresentation($r3 = new Representation('Rep 3'));

        $this->assertSame($r1, $o->getRepresentation('rep_1'));
        $this->assertSame($r2, $o->getRepresentation('rep_2'));
        $this->assertSame($r3, $o->getRepresentation('rep_3'));
        $this->assertSame(null, $o->getRepresentation('Non-existant representation name'));
    }

    /**
     * @covers \Kint\Object\BasicObject::getRepresentations
     */
    public function testGetRepresentations()
    {
        $o = new BasicObject();

        $o->addRepresentation($r1 = new Representation('Rep 1'));
        $o->addRepresentation($r2 = new Representation('Rep 2'));
        $o->addRepresentation($r3 = new Representation('Rep 3'));

        $this->assertSame(
            array(
                'rep_1' => $r1,
                'rep_2' => $r2,
                'rep_3' => $r3,
            ),
            $o->getRepresentations()
        );
    }

    /**
     * @covers \Kint\Object\BasicObject::clearRepresentations
     */
    public function testClearRepresentations()
    {
        $o = new BasicObject();

        $o->addRepresentation($r1 = new Representation('Rep 1'));
        $o->addRepresentation(new Representation('Rep 2'));
        $o->addRepresentation(new Representation('Rep 3'));
        $o->value = $r1;

        $o->clearRepresentations();

        $this->assertSame(array(), $o->getRepresentations());
        $this->assertSame($r1, $o->value);
    }

    /**
     * @covers \Kint\Object\BasicObject::getType
     */
    public function testGetType()
    {
        $o = new BasicObject();

        $o->type = 'array';
        $this->assertEquals('array', $o->getType());
    }

    public function modifierProvider()
    {
        return array(
            'public' => array(
                false,
                false,
                BasicObject::ACCESS_PUBLIC,
                'public',
            ),
            'public const' => array(
                true,
                false,
                BasicObject::ACCESS_PUBLIC,
                'public const',
            ),
            'public static' => array(
                false,
                true,
                BasicObject::ACCESS_PUBLIC,
                'public static',
            ),
            'protected' => array(
                false,
                false,
                BasicObject::ACCESS_PROTECTED,
                'protected',
            ),
            'private' => array(
                false,
                false,
                BasicObject::ACCESS_PRIVATE,
                'private',
            ),
            'none' => array(
                false,
                false,
                BasicObject::ACCESS_NONE,
                null,
            ),
            'private static' => array(
                false,
                true,
                BasicObject::ACCESS_PRIVATE,
                'private static',
            ),
            'public const static' => array(
                true,
                true,
                BasicObject::ACCESS_PUBLIC,
                'public const static',
            ),
            'const' => array(
                true,
                false,
                BasicObject::ACCESS_NONE,
                'const',
            ),
        );
        $accesses = array(
function fx() {
    try {
        doSomething();
        return true;
    }
    catch (\Exception $e) {
        return false;
    }

    return false;
}
            BasicObject::ACCESS_NONE,
            BasicObject::ACCESS_PUBLIC,
            BasicObject::ACCESS_PROTECTED,
            BasicObject::ACCESS_PRIVATE,
        );
    }

    /**
     * @dataProvider modifierProvider
     * @covers \Kint\Object\BasicObject::getModifiers
     */
    public function testGetModifiers($const, $static, $access, $expect)
    {
        $o = new BasicObject();

        $o->const = $const;
        $o->static = $static;
        $o->access = $access;
        $this->assertSame($expect, $o->getModifiers());
    }

    /**
     * @covers \Kint\Object\BasicObject::getAccess
     */
    public function testGetAccess()
    {
        $o = new BasicObject();

        $this->assertNull($o->getAccess());
        $o->access = BasicObject::ACCESS_PUBLIC;
        $this->assertEquals('public', $o->getAccess());
        $o->access = BasicObject::ACCESS_PROTECTED;
        $this->assertEquals('protected', $o->getAccess());
        $o->access = BasicObject::ACCESS_PRIVATE;
        $this->assertEquals('private', $o->getAccess());
    }

    /**
     * @covers \Kint\Object\BasicObject::getName
     */
    public function testGetName()

    {
        $o = new BasicObject();

        $o->name = '$var';
        $this->assertEquals('$var', $o->getName());
        $o->name = '($a + $b)';
        $this->assertEquals('($a + $b)', $o->getName());
        $o->name = 'This is just a name, nothing more, nothing less.';
        $this->assertEquals('This is just a name, nothing more, nothing less.', $o->getName());
    }

    /**
     * @covers \Kint\Object\BasicObject::getOperator
     */
    public function testGetOperator()
    {
        $o = new BasicObject();

        $this->assertNull($o->getOperator());
        $o->operator = BasicObject::OPERATOR_NONE;
        $this->assertNull($o->getOperator());
        $o->operator = BasicObject::OPERATOR_ARRAY;
        $this->assertEquals('=>', $o->getOperator());
        $o->operator = BasicObject::OPERATOR_OBJECT;
        $this->assertEquals('->', $o->getOperator());
        $o->operator = BasicObject::OPERATOR_STATIC;
        $this->assertEquals('::', $o->getOperator());
    }

    /**
     * @covers \Kint\Object\BasicObject::getSize
     */
    public function testGetSize()

    {
        $o = new BasicObject();

        $this->assertNull($o->getSize());
        $o->size = 0;
        $this->assertEquals(0, $o->getSize());
        $o->size = 42;
        $this->assertEquals(42, $o->getSize());
    }

    /**
     * @covers \Kint\Object\BasicObject::getValueShort
     */
    public function testGetValueShort()
    {
        $o = new BasicObject();

        $r = new Representation('contents');

        $this->assertNull($o->getValueShort());
        $o->value = $r;

        $r->contents = true;

        $this->assertNull($o->getValueShort());
        $o->type = 'boolean';
        $this->assertEquals('true', $o->getValueShort());
        $r->contents = false;

        $this->assertEquals('false', $o->getValueShort());
        $o->type = 'integer';
        $r->contents = 1234;

        $this->assertEquals(1234, $o->getValueShort());
        $o->type = 'double';
        $r->contents = 1234.5678;

        $this->assertEquals(1234.5678, $o->getValueShort());
        $o->type = 'array';
        $r->contents = array();
        $this->assertNull($o->getValueShort());
        $o->type = 'string';
        $r->contents = 'string';

        $this->assertNull($o->getValueShort());
    }

    /**
     * @covers \Kint\Object\BasicObject::getAccessPath
     */
    public function testGetAccessPath()
    {
        $o = new BasicObject();

        $this->assertNull($o->getAccessPath());
        $o->access_path = 'abcdefg, hijk elemeno p';
        $this->assertEquals('abcdefg, hijk elemeno p', $o->getAccessPath());
    }

    /**
     * @covers \Kint\Object\BasicObject::blank
     */
    public function testBlank()
    {
        $o = new BasicObject();

        $this->assertNull($o->name);
        $this->assertNull($o->access_path);

        $o = BasicObject::blank();
        $this->assertNull($o->name);
        $this->assertNull($o->access_path);

        $o = BasicObject::blank('$var');
        $this->assertEquals('$var', $o->name);
        $this->assertEquals('$var', $o->access_path);

        $o = BasicObject::blank('Name', 'access_path');
        $this->assertEquals('Name', $o->name);
        $this->assertEquals('access_path', $o->access_path);
    }

    /**
     * @covers \Kint\Object\BasicObject::transplant
     */
    public function testTransplant()
    {
        $o = new BasicObject();


        $o->name = 'name';
        $o->size = 42;
        $o->access_path = 'access_path';
        $o->access = BasicObject::ACCESS_PUBLIC;
        $o->static = true;
        $o->const = true;
        $o->type = 'type';
        $o->depth = 43;
        $o->owner_class = 'owner_class';
        $o->operator = BasicObject::OPERATOR_OBJECT;
        $o->reference = true;
        $o->hints = array('test', 'transplant', 'hints');

        $r = new Representation('Test');

        $o->addRepresentation($r);

        $o2 = $o->transplant(new BasicObject());


        $this->assertEquals($o, $o2);
        $this->assertNotSame($o, $o2);
        $this->assertSame($o->value, $o2->value);

        $o2 = new BasicObject();
        $r2 = new Representation('Test 2');

        $o2->addRepresentation($r2);
        $o2->hints = array('test', 'thoroughly');

        $o2 = $o->transplant($o2);

        $this->assertSame(array('test_2' => $r2, 'test' => $r), $o2->getRepresentations());
        $this->assertSame(array('test', 'transplant', 'hints', 'test', 'thoroughly'), $o2->hints);
    }

    /**
     * @covers \Kint\Object\BasicObject::isSequential
     */
    public function testIsSequential()
    {
        $this->assertTrue(BasicObject::isSequential(array(1, 2, 3, 4)));
        $this->assertFalse(BasicObject::isSequential(array(0 => 1, 1 => 2, 3 => 3, 2 => 4)));
        $this->assertFalse(BasicObject::isSequential(array(0 => 1, 1 => 2, '02' => 3, 3 => 4)));
    }

    /**
     * @covers \Kint\Object\BasicObject::sortByAccess
     */
    public function testSortByAccess()
    {
        $o1 = new BasicObject();

        $o2 = new BasicObject();

        $o3 = new BasicObject();


        $a = array($o1, $o2, $o3);


        $o1->access = BasicObject::ACCESS_PRIVATE;
        $o2->access = BasicObject::ACCESS_PROTECTED;
        $o3->access = BasicObject::ACCESS_PUBLIC;

        $this->assertSame(array($o1, $o2, $o3), $a);

        usort($a, 'Kint\\Object\\BasicObject::sortByAccess');
        $this->assertSame(array($o3, $o2, $o1), $a);

        $o1->access = BasicObject::ACCESS_PROTECTED;
        $o2->access = BasicObject::ACCESS_PRIVATE;

        usort($a, 'Kint\\Object\\BasicObject::sortByAccess');
        $this->assertSame(array($o3, $o1, $o2), $a);
    }

    /**
     * @covers \Kint\Object\BasicObject::sortByName
     */
    public function testSortByName()
    {
        $o1 = new BasicObject();

        $o2 = new BasicObject();

        $o3 = new BasicObject();


        $a = array($o1, $o2, $o3);


        $o1->name = 'Name Z';
        $o2->name = 'Name B';
        $o3->name = 'Name A';

        $this->assertSame(array($o1, $o2, $o3), $a);

        usort($a, 'Kint\\Object\\BasicObject::sortByName');
        $this->assertSame(array($o3, $o2, $o1), $a);

        $o1->name = 'Name M';
        $o2->name = 'Name Z2';

        usort($a, 'Kint\\Object\\BasicObject::sortByName');
        $this->assertSame(array($o3, $o1, $o2), $a);
    }
}


1			<?php
2
3			namespace Kint\Test\Object;
4
5			use Kint\Object\BasicObject;
6			use Kint\Object\Representation\Representation;
7
8			class BasicObjectTest extends \PHPUnit_Framework_TestCase
9			{
10			/**
11			* @covers \Kint\Object\BasicObject::getRepresentations
12			* @covers \Kint\Object\BasicObject::addRepresentation
13			*/
14			public function testAddRepresentation()
15			{
16			$o = new BasicObject();
			0 ignored issues – show Comprehensibility introduced 2018-01-09 18:27 UTC by Report Bug Copy Issue Report Avoid variables with short names like $o. 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...
17
18			$this->assertSame(array(), $o->getRepresentations());
19			$this->assertSame(null, $o->value);
20
21			$this->assertTrue($o->addRepresentation($r1 = new Representation('Rep 1')));
22			$this->assertSame(
23			array(
24			'rep_1' => $r1,
25			),
26			$o->getRepresentations()
27			);
28			$this->assertSame(null, $o->value);
29
30			$this->assertFalse($o->addRepresentation($r1));
31			$this->assertSame(
32			array(
33			'rep_1' => $r1,
34			),
35			$o->getRepresentations()
36			);
37
38			$this->assertTrue($o->addRepresentation($r2 = new Representation('Rep 2')));
39			$this->assertSame(

jnvsor / kint

Push — test ( 4e9ef0...2bbcf6 )

BasicObjectTest::testSortByName() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like