IntegrationTest::testBasicDumps() - Code Metrics - Inspection of "t" - jnvsor/kint - Measure and Improve Code Quality continuously with Scrutinizer

Test Setup Failed

Push — test ( 24878d...6ecee8 )

by Jonathan

created 2018-01-13 16:55 UTC

IntegrationTest::testBasicDumps() B

↳ Parent: Project

Complexity

Conditions	1
Paths	1

Size

Total Lines	106
Code Lines	75

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	75
nc	1
nop	0
dl	0
loc	106
rs	8.2857
c	0
b	0
f	0

How to fix Long Method

<?php

namespace Kint\Test;

use Kint;
use Kint\Object\BlobObject;
use PHPUnit_Framework_AssertionFailedError;
use PHPUnit_Framework_Exception;

class IntegrationTest extends KintTestCase
{
    /**
     * @covers \d
     * @covers \s
     * @covers \Kint::dump
     */
    public function testBasicDumps()
    {
        $testdata = array(
            1234,
            (object) array('abc' => 'def'),
            1234.5678,
            'Good news everyone! I\'ve got some bad news!',
            null,
        );

        $testdata[] = &$testdata;

        $array_structure = array(
            '0', 'integer', '1234',
            '1', 'stdClass', '1',
            'public', 'abc', 'string', '3', 'def',
            '2', 'double', '1234.5678',
            '3', 'string', '43', 'Good news everyone! I\'ve got some bad news!',
            '4', 'null',
        );

        Kint::$return = true;
        Kint::$cli_detection = false;
        Kint::$display_called_from = false;

        Kint::$enabled_mode = Kint::MODE_RICH;
        $richbase = d($testdata);

        $this->assertLike(
            array_merge(
                $array_structure,
                array('&amp;array', '6'),
                $array_structure,
                array('&amp;array', 'Recursion')
            ),
            $richbase
        );

        Kint::$enabled_mode = true;
        $this->assertSame($richbase, d($testdata));
        $this->assertSame($richbase, Kint::dump($testdata));

        Kint::$enabled_mode = Kint::MODE_PLAIN;
        $plainbase = d($testdata);

        $this->assertLike(
            array_merge(
                $array_structure,
                array('&amp;array', '6'),
                $array_structure,
                array('&amp;array', 'RECURSION')
            ),
            $plainbase
        );

        $this->assertSame($plainbase, Kint::dump($testdata));

        Kint::$enabled_mode = true;
        $this->assertSame($plainbase, s($testdata));

        Kint::$enabled_mode = Kint::MODE_CLI;
        $clibase = d($testdata);

        $this->assertLike(
            array_merge(
                $array_structure,
                array('&array', '6'),
                $array_structure,
                array('&array', 'RECURSION')
            ),
            $clibase
        );

        $this->assertSame($clibase, Kint::dump($testdata));

        Kint::$enabled_mode = true;
        Kint::$cli_detection = true;
        $this->assertSame($clibase, d($testdata));
        $this->assertSame($clibase, s($testdata));
        Kint::$cli_detection = false;

        Kint::$enabled_mode = Kint::MODE_TEXT;
        $textbase = d($testdata);

        $this->assertLike(
            array_merge(
                $array_structure,
                array('&array', '6'),
                $array_structure,
                array('&array', 'RECURSION')
            ),
            $textbase
        );

        $this->assertSame($textbase, Kint::dump($testdata));

        Kint::$return = false;
        Kint::$enabled_mode = true;
        ob_start();
        ~d($testdata);
        $this->assertSame($textbase, ob_get_clean());

        Kint::$enabled_mode = false;
        $this->assertSame(0, d($testdata));
        $this->assertSame(0, s($testdata));
    }

    /**
     * Test this test suite's restore after test.
     *
     * @covers \Kint\Test\KintTestCase::setUp
     * @covers \Kint\Test\KintTestCase::tearDown
     */
    public function testStore()
    {
        Kint::$file_link_format = 'test_store';
        $this->assertEquals('test_store', Kint::$file_link_format);
        BlobObject::$char_encodings[] = 'this_is_not_a_real_encoding';
        $this->assertContains('this_is_not_a_real_encoding', BlobObject::$char_encodings);
    }

    /**
     * @covers \Kint\Test\KintTestCase::setUp
     * @covers \Kint\Test\KintTestCase::tearDown
     */
    public function testRestore()
    {
        $this->assertNotEquals('test_store', Kint::$file_link_format);
        $this->assertNotContains('this_is_not_a_real_encoding', BlobObject::$char_encodings);
    }

    /**
     * @covers \Kint\Test\KintTestCase::assertLike
     */
    public function testLike()
    {
        $this->assertLike(array('a', 'b', 'c'), 'foo a bar baz c buzz');
    }

    /**
     * @covers \Kint\Test\KintTestCase::assertLike
     */
    public function testNotLike()
    {
        try {
            $this->assertLike(array('a', 'b', 'c', 'o'), 'foo a bar baz c buzz');
        } catch (PHPUnit_Framework_AssertionFailedError $e) {
            return;
        }

        self::fail('Failed to mismatch');
    }

    /**
     * @covers \Kint\Test\KintTestCase::assertLike
     */
    public function testLikeNonString()
    {
        try {
            $this->assertLike(array('a', 'b', 'c'), array('a', 'b', 'c'));
        } catch (PHPUnit_Framework_Exception $e) {
            return;
        }

        self::fail('Failed to throw');
    }
}


1			<?php
2
3			namespace Kint\Test;
4
5			use Kint;
6			use Kint\Object\BlobObject;
7			use PHPUnit_Framework_AssertionFailedError;
8			use PHPUnit_Framework_Exception;
9
10			class IntegrationTest extends KintTestCase
11			{
12			/**
13			* @covers \d
14			* @covers \s
15			* @covers \Kint::dump
16			*/
17			public function testBasicDumps()
18			{
19			$testdata = array(
20			1234,
21			(object) array('abc' => 'def'),
22			1234.5678,
23			'Good news everyone! I\'ve got some bad news!',
24			null,
25			);
26
27			$testdata[] = &$testdata;
28
29			$array_structure = array(
30			'0', 'integer', '1234',
31			'1', 'stdClass', '1',
32			'public', 'abc', 'string', '3', 'def',
33			'2', 'double', '1234.5678',
34			'3', 'string', '43', 'Good news everyone! I\'ve got some bad news!',
35			'4', 'null',
36			);
37
38			Kint::$return = true;
39			Kint::$cli_detection = false;
40			Kint::$display_called_from = false;
41
42			Kint::$enabled_mode = Kint::MODE_RICH;
43			$richbase = d($testdata);
44
45			$this->assertLike(
46			array_merge(
47			$array_structure,
48			array('&array', '6'),
49			$array_structure,
50			array('&array', 'Recursion')
51			),
52			$richbase
53			);
54
55			Kint::$enabled_mode = true;
56			$this->assertSame($richbase, d($testdata));
57			$this->assertSame($richbase, Kint::dump($testdata));
58
59			Kint::$enabled_mode = Kint::MODE_PLAIN;
60			$plainbase = d($testdata);
61
62			$this->assertLike(
63			array_merge(
64			$array_structure,
65			array('&array', '6'),
66			$array_structure,
67			array('&array', 'RECURSION')
68			),
69			$plainbase
70			);
71
72			$this->assertSame($plainbase, Kint::dump($testdata));
73
74			Kint::$enabled_mode = true;
75			$this->assertSame($plainbase, s($testdata));
76
77			Kint::$enabled_mode = Kint::MODE_CLI;
78			$clibase = d($testdata);
79
80			$this->assertLike(
81			array_merge(
82			$array_structure,
83			array('&array', '6'),
84			$array_structure,
85			array('&array', 'RECURSION')
86			),
87			$clibase
88			);
89
90			$this->assertSame($clibase, Kint::dump($testdata));
91
92			Kint::$enabled_mode = true;
93			Kint::$cli_detection = true;
94			$this->assertSame($clibase, d($testdata));
95			$this->assertSame($clibase, s($testdata));
96			Kint::$cli_detection = false;
97
98			Kint::$enabled_mode = Kint::MODE_TEXT;
99			$textbase = d($testdata);
100
101			$this->assertLike(
102			array_merge(
103			$array_structure,
104			array('&array', '6'),
105			$array_structure,
106			array('&array', 'RECURSION')
107			),
108			$textbase
109			);
110
111			$this->assertSame($textbase, Kint::dump($testdata));
112
113			Kint::$return = false;
114			Kint::$enabled_mode = true;
115			ob_start();
116			~d($testdata);
117			$this->assertSame($textbase, ob_get_clean());
118
119			Kint::$enabled_mode = false;
120			$this->assertSame(0, d($testdata));
121			$this->assertSame(0, s($testdata));
122			}
123
124			/**
125			* Test this test suite's restore after test.
126			*
127			* @covers \Kint\Test\KintTestCase::setUp
128			* @covers \Kint\Test\KintTestCase::tearDown
129			*/
130			public function testStore()
131			{
132			Kint::$file_link_format = 'test_store';
133			$this->assertEquals('test_store', Kint::$file_link_format);
134			BlobObject::$char_encodings[] = 'this_is_not_a_real_encoding';
135			$this->assertContains('this_is_not_a_real_encoding', BlobObject::$char_encodings);
136			}
137
138			/**
139			* @covers \Kint\Test\KintTestCase::setUp
140			* @covers \Kint\Test\KintTestCase::tearDown
141			*/
142			public function testRestore()
143			{
144			$this->assertNotEquals('test_store', Kint::$file_link_format);
145			$this->assertNotContains('this_is_not_a_real_encoding', BlobObject::$char_encodings);
146			}
147
148			/**
149			* @covers \Kint\Test\KintTestCase::assertLike
150			*/
151			public function testLike()
152			{
153			$this->assertLike(array('a', 'b', 'c'), 'foo a bar baz c buzz');
154			}
155
156			/**
157			* @covers \Kint\Test\KintTestCase::assertLike
158			*/
159			public function testNotLike()
160			{
161			try {
162			$this->assertLike(array('a', 'b', 'c', 'o'), 'foo a bar baz c buzz');
163			} catch (PHPUnit_Framework_AssertionFailedError $e) {
164			return;
165			}
166
167			self::fail('Failed to mismatch');
168			}
169
170			/**
171			* @covers \Kint\Test\KintTestCase::assertLike
172			*/
173			public function testLikeNonString()
174			{
175			try {
176			$this->assertLike(array('a', 'b', 'c'), array('a', 'b', 'c'));
177			} catch (PHPUnit_Framework_Exception $e) {
178			return;
179			}
180
181			self::fail('Failed to throw');
182			}
183			}
184

jnvsor / kint

Push — test ( 24878d...6ecee8 )

IntegrationTest::testBasicDumps() B

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like