DisplayTest::testGetMemoryMeta() - Code Metrics - Inspection of "Test coverage on query display, memory display, an..." - jacobemerick/pqp - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( b40822...9f9b7a )

by Jacob

created 2015-12-20 15:28 UTC

DisplayTest::testGetMemoryMeta() A

↳ Parent: DisplayTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	20
Code Lines	15

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	20
rs	9.4286
cc	1
eloc	15
nc	1
nop	0

<?php

namespace Particletree\Pqp;

use Exception;
use PHPUnit_Framework_TestCase;
use ReflectionClass;

class DisplayTest extends PHPUnit_Framework_TestCase
{

    public function testConstruct()
    {
        $display = new Display();
        $reflectedDisplay = new ReflectionClass(get_class($display));
        $reflectedProperty = $reflectedDisplay->getProperty('defaults');
        $reflectedProperty->setAccessible(true);
        $defaults = $reflectedProperty->getValue($display);

        $display = new Display();
        $this->assertAttributeEquals($defaults, 'options', $display);

        $options = array(
            'script_path' => 'testing/testing.js',
            'fake_key' => 'foo bar'
        );
        $expectedOptions = array_intersect_key($options, $defaults);
        $expectedOptions = array_replace($defaults, $expectedOptions);
        $display = new Display($options);
        $this->assertAttributeEquals($expectedOptions, 'options', $display);
    }

    public function testSetStartTime()
    {
        $startTime = microtime(true);
        $display = new Display();
        $display->setStartTime($startTime);

        $this->assertAttributeEquals($startTime, 'startTime', $display);
    }

    public function testSetConsole()
    {
        $console = new Console();
        $display = new Display();
        $display->setConsole($console);

        $this->assertAttributeSame($console, 'console', $display);
    }

    public function testSetMemoryData()
    {
        $memoryData = array(
            'used'    => memory_get_peak_usage(),
            'allowed' => ini_get('memory_limit')
        );
        $display = new Display();
        $display->setMemoryData($memoryData);

        $this->assertAttributeEquals($memoryData, 'memoryData', $display);
    }

    public function testSetQueryData()
    {
        $queryData = array(
            'sql'     => 'SELECT * FROM testing',
            'explain' => array(
                'key' => 'value'
            ),
            'time'    => 300
        );
        $display = new Display();
        $display->setQueryData($queryData);

        $this->assertAttributeEquals($queryData, 'queryData', $display);
    }

    public function testSetSpeedData()
    {
        $speedData = array(
            'elapsed' => 1.234,
            'allowed' => 30
        );
        $display = new Display();
        $display->setSpeedData($speedData);

        $this->assertAttributeEquals($speedData, 'speedData', $display);
    }

    /**
     * @dataProvider dataConsoleStore
     */
    public function testGetConsoleMeta($consoleStore, $expectedMeta, $expectedMessages)

    {
        $console = new Console();
        $this->setInternalProperty($console, 'store', $consoleStore);
        $display = new Display();
        $display->setConsole($console);
        $reflectedMethod = $this->getAccessibleMethod($display, 'getConsoleMeta');

        $consoleMeta = $reflectedMethod->invoke($display);
        $this->assertEquals($expectedMeta, $consoleMeta);
    }

    /**
     * @dataProvider dataConsoleStore
     */
    public function testGetConsoleMessages($consoleStore, $expectedMeta, $expectedMessages)

    {
        $console = new Console();
        $this->setInternalProperty($console, 'store', $consoleStore);
        $display = new Display();
        $display->setConsole($console);
        $reflectedMethod = $this->getAccessibleMethod($display, 'getConsoleMessages');

        $consoleMessages = $reflectedMethod->invoke($display);
        $this->assertEquals($expectedMessages, $consoleMessages);
    }

    public function testGetSpeedMeta()
    {
        $elapsedTime = 1234.678;
        $allowedTime = 30;
        $display = new Display();
        $display->setSpeedData(array(
            'elapsed' => $elapsedTime,
            'allowed' => $allowedTime
        ));
        $reflectedMethod = $this->getAccessibleMethod($display, 'getReadableTime');
        $elapsedTime = $reflectedMethod->invokeArgs($display, array($elapsedTime));
        $allowedTime = $reflectedMethod->invokeArgs($display, array($allowedTime, 0));
        $expectedMeta = array(
            'elapsed' => $elapsedTime,
            'allowed' => $allowedTime
        );

        $reflectedMethod = $this->getAccessibleMethod($display, 'getSpeedMeta');
        $speedMeta = $reflectedMethod->invoke($display);
        $this->assertEquals($expectedMeta, $speedMeta);
    }

    /**
     * @dataProvider dataQueryData
     */
    public function testGetQueryMeta($queryData, $expectedMeta, $expectedList)

    {
        $display = new Display();
        $display->setQueryData($queryData);
        $reflectedMethod = $this->getAccessibleMethod($display, 'getQueryMeta');

        $queryMeta = $reflectedMethod->invoke($display);
        $this->assertEquals($expectedMeta, $queryMeta);
    }

    /**
     * @dataProvider dataQueryData
     */
    public function testGetQueryList($queryData, $expectedMeta, $expectedList)

    {
        $display = new Display();
        $display->setQueryData($queryData);
        $reflectedMethod = $this->getAccessibleMethod($display, 'getQueryList');

        $queryList = $reflectedMethod->invoke($display);
        $this->assertEquals($expectedList, $queryList);
    }

    public function testGetMemoryMeta()
    {
        $usedMemory = 123456;
        $allowedMemory = '128M';
        $display = new Display();
        $display->setMemoryData(array(
            'used'    => $usedMemory,
            'allowed' => $allowedMemory
        ));
        $reflectedMethod = $this->getAccessibleMethod($display, 'getReadableMemory');
        $usedMemory = $reflectedMethod->invokeArgs($display, array($usedMemory));
        $expectedMeta = array(
            'used'    => $usedMemory,
            'allowed' => $allowedMemory
        );

        $reflectedMethod = $this->getAccessibleMethod($display, 'getMemoryMeta');
        $memoryMeta = $reflectedMethod->invoke($display);
        $this->assertEquals($expectedMeta, $memoryMeta);
    }

    /**
     * @dataProvider dataFileData
     */
    public function testGetFileMeta($fileData, $expectedMeta, $expectedList)

    {
        $display = new Display();
        $display->setFileData($fileData);
        $reflectedMethod = $this->getAccessibleMethod($display, 'getFileMeta');

        $fileMeta = $reflectedMethod->invoke($display);
        $this->assertEquals($expectedMeta, $fileMeta);
    }

    /**
     * @dataProvider dataFileData
     */
    public function testGetFileList($fileData, $expectedMeta, $expectedList)

    {
        $display = new Display();
        $display->setFileData($fileData);
        $reflectedMethod = $this->getAccessibleMethod($display, 'getFileList');

        $fileList = $reflectedMethod->invoke($display);
        $this->assertEquals($expectedList, $fileList);
    }

    public function testGetReadableTime()
    {
        $timeTest = array(
            '.032432' => '32.432 ms',
            '24.3781' => '24.378 s',
            '145.123' => '2.419 m'
        );
        $display = new Display();
        $reflectedMethod = $this->getAccessibleMethod($display, 'getReadableTime');

        foreach ($timeTest as $rawTime => $expectedTime) {
            $readableTime = $reflectedMethod->invokeArgs($display, array($rawTime));
            $this->assertEquals($expectedTime, $readableTime);
        }
    }

    public function testGetReadableMemory()
    {
        $memoryTest = array(
            '314'     => '314 b',
            '7403'    => '7.23 k',
            '2589983' => '2.47 M'
        );
        $display = new Display();
        $reflectedMethod = $this->getAccessibleMethod($display, 'getReadableMemory');

        foreach ($memoryTest as $rawMemory => $expectedMemory) {
            $readableMemory = $reflectedMethod->invokeArgs($display, array($rawMemory));
            $this->assertEquals($expectedMemory, $readableMemory);
        }
    }

    public function dataConsoleStore()
    {
        $testException = new Exception('testing');
        $display = new Display();
        $reflectedTime = $this->getAccessibleMethod($display, 'getReadableTime');
        $reflectedMemory = $this->getAccessibleMethod($display, 'getReadableMemory');

        return array(
            array(
                'store' => array(
                    array(
                        'data' => 'testing message',
                        'type' => 'log'
                    ),
                    array(
                        'name' => 'now',
                        'data' => microtime(true),
                        'type' => 'speed'
                    ),
                    array(
                        'name' => 'little later',
                        'data' => microtime(true) + 1,
                        'type' => 'speed'
                    ),
                    array(
                        'name' => 'invalid key',
                        'type' => 'foo'
                    )
                ),
                'meta' => array(
                    'log'    => 1,
                    'memory' => 0,
                    'error'  => 1,
                    'speed'  => 2
                ),
                'messages' => array(
                    array(
                        'message' => 'testing message',
                        'type'    => 'log'
                    ),
                    array(
                        'message' => 'now',
                        'data'    => $reflectedTime->invokeArgs($display, array(microtime(true))),
                        'type'    => 'speed'
                    ),
                    array(
                        'message' => 'little later',
                        'data'    => $reflectedTime->invokeArgs($display, array(microtime(true) + 1)),
                        'type'    => 'speed'
                    ),
                    array(
                        'message' => 'Unrecognized console log type: foo',
                        'type'    => 'error'
                    )
                )
            ),
            array(
                'store' => array(
                    array(
                        'data' => 'another testing message',
                        'type' => 'log'
                    ),
                    array(
                        'name'      => 'test array',
                        'data'      => strlen(serialize(array('key' => 'value'))),
                        'data_type' => 'array',
                        'type'      => 'memory'
                    ),
                    array(
                        'name'      => 'memory usage test',
                        'data'      => memory_get_usage(),
                        'data_type' => '',
                        'type'      => 'memory'
                    ),
                    array(
                        'data' => $testException->getMessage(),
                        'file' => $testException->getFile(),
                        'line' => $testException->getLine(),
                        'type' => 'error'
                    )
                ),
                'meta' => array(
                    'log'    => 1,
                    'memory' => 2,
                    'error'  => 1,
                    'speed'  => 0
                ),
                'messages' => array(
                    array(
                        'message' => 'another testing message',
                        'type'    => 'log'
                    ),
                    array(
                        'message' => 'array: test array',
                        'data'    => $reflectedMemory->invokeArgs(
                            $display,
                            array(strlen(serialize(array('key' => 'value'))))
                        ),
                        'type'    => 'memory'
                    ),
                    array(
                        'message' => 'memory usage test',
                        'data'    => $reflectedMemory->invokeArgs($display, array(memory_get_usage())),
                        'type'    => 'memory'
                    ),
                    array(
                        'message' => sprintf(
                            'Line %s: %s in %s',
                            $testException->getLine(),
                            $testException->getMessage(),
                            $testException->getFile()
                        ),
                        'type'    => 'error'
                    )
                )
            )
        );
    }

    public function dataQueryData()
    {
        $display = new Display();
        $reflectedTime = $this->getAccessibleMethod($display, 'getReadableTime');

        return array(
            array(
                'data' => array(
                    array(
                        'sql'     => "SELECT * FROM testing",
                        'explain' => array('empty_key' => ''),
                        'time'    => 25
                    ),
                    array(
                        'sql'     => "SELECT id FROM testing WHERE title = :title",
                        'explain' => array('key' => 'value'),
                        'time'    => 5
                    )
                ),
                'meta' => array(
                    'count'   => 2,
                    'time'    => $reflectedTime->invokeArgs($display, array(30)),
                    'slowest' => $reflectedTime->invokeArgs($display, array(25)),
                ),
                'list' => array(
                    array(
                        'message'  => 'SELECT * FROM testing',
                        'sub_data' => array(),
                        'data'     => $reflectedTime->invokeArgs($display, array(25))
                    ),
                    array(
                        'message'  => 'SELECT id FROM testing WHERE title = :title',
                        'sub_data' => array('key' => 'value'),
                        'data'     => $reflectedTime->invokeArgs($display, array(5))
                    )
                )
            )
        );
    }

    public function dataFileData()
    {
        $display = new Display();
        $reflectedMemory = $this->getAccessibleMethod($display, 'getReadableMemory');

        return array(
            array(
                'data' => array(
                    array(
                        'name' => 'test-file',
                        'size' => 1234
                    ),
                    array(
                        'name' => 'test-file-2',
                        'size' => 66
                    )
                ),
                'meta' => array(
                    'count'   => 2,
                    'size'    => $reflectedMemory->invokeArgs($display, array(1300)),
                    'largest' => $reflectedMemory->invokeArgs($display, array(1234)),
                ),
                'list' => array(
                    array(
                        'message' => 'test-file',
                        'data'    => $reflectedMemory->invokeArgs($display, array(1234))
                    ),
                    array(
                        'message' => 'test-file-2',
                        'data'    => $reflectedMemory->invokeArgs($display, array(66))
                    )
                )
            )
        );
    }

    protected function setInternalProperty($class, $property, $value)
    {
        $reflectedClass = new ReflectionClass(get_class($class));
        $reflectedProperty = $reflectedClass->getProperty($property);
        $reflectedProperty->setAccessible(true);
        $reflectedProperty->setValue($class, $value);
    }

    protected function getAccessibleMethod($class, $method)
    {
        $reflectedClass = new ReflectionClass(get_class($class));
        $reflectedMethod = $reflectedClass->getMethod($method);
        $reflectedMethod->setAccessible(true);
        return $reflectedMethod;
    }
}


1		<?php
2
3		namespace Particletree\Pqp;
4
5		use Exception;
6		use PHPUnit_Framework_TestCase;
7		use ReflectionClass;
8
9		class DisplayTest extends PHPUnit_Framework_TestCase
10		{
11
12		public function testConstruct()
13		{
14		$display = new Display();
15		$reflectedDisplay = new ReflectionClass(get_class($display));
16		$reflectedProperty = $reflectedDisplay->getProperty('defaults');
17		$reflectedProperty->setAccessible(true);
18		$defaults = $reflectedProperty->getValue($display);
19
20		$display = new Display();
21		$this->assertAttributeEquals($defaults, 'options', $display);
22
23		$options = array(
24		'script_path' => 'testing/testing.js',
25		'fake_key' => 'foo bar'
26		);
27		$expectedOptions = array_intersect_key($options, $defaults);
28		$expectedOptions = array_replace($defaults, $expectedOptions);
29		$display = new Display($options);
30		$this->assertAttributeEquals($expectedOptions, 'options', $display);
31		}
32
33		public function testSetStartTime()
34		{
35		$startTime = microtime(true);
36		$display = new Display();
37		$display->setStartTime($startTime);
38
39		$this->assertAttributeEquals($startTime, 'startTime', $display);
40		}
41
42	View Code Duplication	public function testSetConsole()
43		{
44		$console = new Console();
45		$display = new Display();
46		$display->setConsole($console);
47
48		$this->assertAttributeSame($console, 'console', $display);
49		}
50
51		public function testSetMemoryData()
52		{
53		$memoryData = array(
54		'used' => memory_get_peak_usage(),
55		'allowed' => ini_get('memory_limit')
56		);
57		$display = new Display();
58		$display->setMemoryData($memoryData);
59
60		$this->assertAttributeEquals($memoryData, 'memoryData', $display);
61		}
62
63		public function testSetQueryData()
64		{
65		$queryData = array(
66		'sql' => 'SELECT * FROM testing',
67		'explain' => array(
68		'key' => 'value'
69		),
70		'time' => 300
71		);
72		$display = new Display();
73		$display->setQueryData($queryData);
74
75		$this->assertAttributeEquals($queryData, 'queryData', $display);
76		}
77
78		public function testSetSpeedData()
79		{
80		$speedData = array(
81		'elapsed' => 1.234,
82		'allowed' => 30
83		);
84		$display = new Display();
85		$display->setSpeedData($speedData);
86
87		$this->assertAttributeEquals($speedData, 'speedData', $display);
88		}
89
90		/**
91		* @dataProvider dataConsoleStore
92		*/
93	View Code Duplication	public function testGetConsoleMeta($consoleStore, $expectedMeta, $expectedMessages)
		2 ignored issues – show Unused Code introduced 2015-12-20 14:38 UTC by Report Bug Copy Issue Report The parameter `$expectedMessages` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history... Duplication introduced 2015-12-20 14:38 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
94		{
95		$console = new Console();
96		$this->setInternalProperty($console, 'store', $consoleStore);
97		$display = new Display();
98		$display->setConsole($console);
99		$reflectedMethod = $this->getAccessibleMethod($display, 'getConsoleMeta');
100
101		$consoleMeta = $reflectedMethod->invoke($display);
102		$this->assertEquals($expectedMeta, $consoleMeta);
103		}
104
105		/**
106		* @dataProvider dataConsoleStore
107		*/
108	View Code Duplication	public function testGetConsoleMessages($consoleStore, $expectedMeta, $expectedMessages)
		2 ignored issues – show Unused Code introduced 2015-12-20 14:38 UTC by Report Bug Copy Issue Report The parameter `$expectedMeta` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history... Duplication introduced 2015-12-20 14:38 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
109		{
110		$console = new Console();
111		$this->setInternalProperty($console, 'store', $consoleStore);
112		$display = new Display();
113		$display->setConsole($console);
114		$reflectedMethod = $this->getAccessibleMethod($display, 'getConsoleMessages');
115
116		$consoleMessages = $reflectedMethod->invoke($display);
117		$this->assertEquals($expectedMessages, $consoleMessages);
118		}
119
120		public function testGetSpeedMeta()
121		{
122		$elapsedTime = 1234.678;
123		$allowedTime = 30;
124		$display = new Display();
125		$display->setSpeedData(array(
126		'elapsed' => $elapsedTime,
127		'allowed' => $allowedTime
128		));
129		$reflectedMethod = $this->getAccessibleMethod($display, 'getReadableTime');
130		$elapsedTime = $reflectedMethod->invokeArgs($display, array($elapsedTime));
131		$allowedTime = $reflectedMethod->invokeArgs($display, array($allowedTime, 0));
132		$expectedMeta = array(
133		'elapsed' => $elapsedTime,
134		'allowed' => $allowedTime
135		);
136
137		$reflectedMethod = $this->getAccessibleMethod($display, 'getSpeedMeta');
138		$speedMeta = $reflectedMethod->invoke($display);
139		$this->assertEquals($expectedMeta, $speedMeta);
140		}
141
142		/**
143		* @dataProvider dataQueryData
144		*/
145	View Code Duplication	public function testGetQueryMeta($queryData, $expectedMeta, $expectedList)
		2 ignored issues – show Unused Code introduced 2015-12-20 15:30 UTC by Report Bug Copy Issue Report The parameter `$expectedList` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history... Duplication introduced 2015-12-20 15:30 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
146		{
147		$display = new Display();
148		$display->setQueryData($queryData);
149		$reflectedMethod = $this->getAccessibleMethod($display, 'getQueryMeta');
150
151		$queryMeta = $reflectedMethod->invoke($display);
152		$this->assertEquals($expectedMeta, $queryMeta);
153		}
154
155		/**
156		* @dataProvider dataQueryData
157		*/
158	View Code Duplication	public function testGetQueryList($queryData, $expectedMeta, $expectedList)
		2 ignored issues – show Unused Code introduced 2015-12-20 15:30 UTC by Report Bug Copy Issue Report The parameter `$expectedMeta` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history... Duplication introduced 2015-12-20 15:30 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
159		{
160		$display = new Display();
161		$display->setQueryData($queryData);
162		$reflectedMethod = $this->getAccessibleMethod($display, 'getQueryList');
163
164		$queryList = $reflectedMethod->invoke($display);
165		$this->assertEquals($expectedList, $queryList);
166		}
167
168		public function testGetMemoryMeta()
169		{
170		$usedMemory = 123456;
171		$allowedMemory = '128M';
172		$display = new Display();
173		$display->setMemoryData(array(
174		'used' => $usedMemory,
175		'allowed' => $allowedMemory
176		));
177		$reflectedMethod = $this->getAccessibleMethod($display, 'getReadableMemory');
178		$usedMemory = $reflectedMethod->invokeArgs($display, array($usedMemory));
179		$expectedMeta = array(
180		'used' => $usedMemory,
181		'allowed' => $allowedMemory
182		);
183
184		$reflectedMethod = $this->getAccessibleMethod($display, 'getMemoryMeta');
185		$memoryMeta = $reflectedMethod->invoke($display);
186		$this->assertEquals($expectedMeta, $memoryMeta);
187		}
188
189		/**
190		* @dataProvider dataFileData
191		*/
192	View Code Duplication	public function testGetFileMeta($fileData, $expectedMeta, $expectedList)
		2 ignored issues – show Unused Code introduced 2015-12-20 15:30 UTC by Report Bug Copy Issue Report The parameter `$expectedList` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history... Duplication introduced 2015-12-20 15:30 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
193		{
194		$display = new Display();
195		$display->setFileData($fileData);
196		$reflectedMethod = $this->getAccessibleMethod($display, 'getFileMeta');
197
198		$fileMeta = $reflectedMethod->invoke($display);
199		$this->assertEquals($expectedMeta, $fileMeta);
200		}
201
202		/**
203		* @dataProvider dataFileData
204		*/
205	View Code Duplication	public function testGetFileList($fileData, $expectedMeta, $expectedList)
		2 ignored issues – show Unused Code introduced 2015-12-20 15:30 UTC by Report Bug Copy Issue Report The parameter `$expectedMeta` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history... Duplication introduced 2015-12-20 15:30 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
206		{
207		$display = new Display();
208		$display->setFileData($fileData);
209		$reflectedMethod = $this->getAccessibleMethod($display, 'getFileList');
210
211		$fileList = $reflectedMethod->invoke($display);
212		$this->assertEquals($expectedList, $fileList);
213		}
214
215	View Code Duplication	public function testGetReadableTime()
216		{
217		$timeTest = array(
218		'.032432' => '32.432 ms',
219		'24.3781' => '24.378 s',
220		'145.123' => '2.419 m'
221		);
222		$display = new Display();
223		$reflectedMethod = $this->getAccessibleMethod($display, 'getReadableTime');
224
225		foreach ($timeTest as $rawTime => $expectedTime) {
226		$readableTime = $reflectedMethod->invokeArgs($display, array($rawTime));
227		$this->assertEquals($expectedTime, $readableTime);
228		}
229		}
230
231	View Code Duplication	public function testGetReadableMemory()
232		{
233		$memoryTest = array(
234		'314' => '314 b',
235		'7403' => '7.23 k',
236		'2589983' => '2.47 M'
237		);
238		$display = new Display();
239		$reflectedMethod = $this->getAccessibleMethod($display, 'getReadableMemory');
240
241		foreach ($memoryTest as $rawMemory => $expectedMemory) {
242		$readableMemory = $reflectedMethod->invokeArgs($display, array($rawMemory));
243		$this->assertEquals($expectedMemory, $readableMemory);
244		}
245		}
246
247		public function dataConsoleStore()
248		{
249		$testException = new Exception('testing');
250		$display = new Display();
251		$reflectedTime = $this->getAccessibleMethod($display, 'getReadableTime');
252		$reflectedMemory = $this->getAccessibleMethod($display, 'getReadableMemory');
253
254		return array(
255		array(
256		'store' => array(
257		array(
258		'data' => 'testing message',
259		'type' => 'log'
260		),
261		array(
262		'name' => 'now',
263		'data' => microtime(true),
264		'type' => 'speed'
265		),
266		array(
267		'name' => 'little later',
268		'data' => microtime(true) + 1,
269		'type' => 'speed'
270		),
271		array(
272		'name' => 'invalid key',
273		'type' => 'foo'
274		)
275		),
276		'meta' => array(
277		'log' => 1,
278		'memory' => 0,
279		'error' => 1,
280		'speed' => 2
281		),
282		'messages' => array(
283		array(
284		'message' => 'testing message',
285		'type' => 'log'
286		),
287		array(
288		'message' => 'now',
289		'data' => $reflectedTime->invokeArgs($display, array(microtime(true))),
290		'type' => 'speed'
291		),
292		array(
293		'message' => 'little later',
294		'data' => $reflectedTime->invokeArgs($display, array(microtime(true) + 1)),
295		'type' => 'speed'
296		),
297		array(
298		'message' => 'Unrecognized console log type: foo',
299		'type' => 'error'
300		)
301		)
302		),
303		array(
304		'store' => array(
305		array(
306		'data' => 'another testing message',
307		'type' => 'log'
308		),
309		array(
310		'name' => 'test array',
311		'data' => strlen(serialize(array('key' => 'value'))),
312		'data_type' => 'array',
313		'type' => 'memory'
314		),
315		array(
316		'name' => 'memory usage test',
317		'data' => memory_get_usage(),
318		'data_type' => '',
319		'type' => 'memory'
320		),
321		array(
322		'data' => $testException->getMessage(),
323		'file' => $testException->getFile(),
324		'line' => $testException->getLine(),
325		'type' => 'error'
326		)
327		),
328		'meta' => array(
329		'log' => 1,
330		'memory' => 2,
331		'error' => 1,
332		'speed' => 0
333		),
334		'messages' => array(
335		array(
336		'message' => 'another testing message',
337		'type' => 'log'
338		),
339		array(
340		'message' => 'array: test array',
341		'data' => $reflectedMemory->invokeArgs(
342		$display,
343		array(strlen(serialize(array('key' => 'value'))))
344		),
345		'type' => 'memory'
346		),
347		array(
348		'message' => 'memory usage test',
349		'data' => $reflectedMemory->invokeArgs($display, array(memory_get_usage())),
350		'type' => 'memory'
351		),
352		array(
353		'message' => sprintf(
354		'Line %s: %s in %s',
355		$testException->getLine(),
356		$testException->getMessage(),
357		$testException->getFile()
358		),
359		'type' => 'error'
360		)
361		)
362		)
363		);
364		}
365
366		public function dataQueryData()
367		{
368		$display = new Display();
369		$reflectedTime = $this->getAccessibleMethod($display, 'getReadableTime');
370
371		return array(
372		array(
373		'data' => array(
374		array(
375		'sql' => "SELECT * FROM testing",
376		'explain' => array('empty_key' => ''),
377		'time' => 25
378		),
379		array(
380		'sql' => "SELECT id FROM testing WHERE title = :title",
381		'explain' => array('key' => 'value'),
382		'time' => 5
383		)
384		),
385		'meta' => array(
386		'count' => 2,
387		'time' => $reflectedTime->invokeArgs($display, array(30)),
388		'slowest' => $reflectedTime->invokeArgs($display, array(25)),
389		),
390		'list' => array(
391		array(
392		'message' => 'SELECT * FROM testing',
393		'sub_data' => array(),
394		'data' => $reflectedTime->invokeArgs($display, array(25))
395		),
396		array(
397		'message' => 'SELECT id FROM testing WHERE title = :title',
398		'sub_data' => array('key' => 'value'),
399		'data' => $reflectedTime->invokeArgs($display, array(5))
400		)
401		)
402		)
403		);
404		}
405
406		public function dataFileData()
407		{
408		$display = new Display();
409		$reflectedMemory = $this->getAccessibleMethod($display, 'getReadableMemory');
410
411		return array(
412		array(
413		'data' => array(
414		array(
415		'name' => 'test-file',
416		'size' => 1234
417		),
418		array(
419		'name' => 'test-file-2',
420		'size' => 66
421		)
422		),
423		'meta' => array(
424		'count' => 2,
425		'size' => $reflectedMemory->invokeArgs($display, array(1300)),
426		'largest' => $reflectedMemory->invokeArgs($display, array(1234)),
427		),
428		'list' => array(
429		array(
430		'message' => 'test-file',
431		'data' => $reflectedMemory->invokeArgs($display, array(1234))
432		),
433		array(
434		'message' => 'test-file-2',
435		'data' => $reflectedMemory->invokeArgs($display, array(66))
436		)
437		)
438		)
439		);
440		}
441
442		protected function setInternalProperty($class, $property, $value)
443		{
444		$reflectedClass = new ReflectionClass(get_class($class));
445		$reflectedProperty = $reflectedClass->getProperty($property);
446		$reflectedProperty->setAccessible(true);
447		$reflectedProperty->setValue($class, $value);
448		}
449
450		protected function getAccessibleMethod($class, $method)
451		{
452		$reflectedClass = new ReflectionClass(get_class($class));
453		$reflectedMethod = $reflectedClass->getMethod($method);
454		$reflectedMethod->setAccessible(true);
455		return $reflectedMethod;
456		}
457		}
458

jacobemerick / pqp

Push — master ( b40822...9f9b7a )

DisplayTest::testGetMemoryMeta() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like