XhprofDataTest.php

Go to the documentation of this file.

<?php
class XhprofDataTest extends PHPUnit\Framework\TestCase {
 
    use MediaWikiCoversValidator;
 
    public function testSplitKey( $key, $expect ) {
        $this->assertSame( $expect, XhprofData::splitKey( $key ) );
    }
 
    public function provideSplitKey() {
        return [
            [ 'main()', [ null, 'main()' ] ],
            [ 'foo==>bar', [ 'foo', 'bar' ] ],
            [ 'bar@1==>bar@2', [ 'bar@1', 'bar@2' ] ],
            [ 'foo==>bar==>baz', [ 'foo', 'bar==>baz' ] ],
            [ '==>bar', [ '', 'bar' ] ],
            [ '', [ null, '' ] ],
        ];
    }
 
    public function testInclude() {
        $xhprofData = $this->getXhprofDataFixture( [
            'include' => [ 'main()' ],
        ] );
        $raw = $xhprofData->getRawData();
        $this->assertArrayHasKey( 'main()', $raw );
        $this->assertArrayHasKey( 'main()==>foo', $raw );
        $this->assertArrayHasKey( 'main()==>xhprof_disable', $raw );
        $this->assertSame( 3, count( $raw ) );
    }
 
    public function testInclusiveMetricsStructure() {
        $metricStruct = [
            'ct' => 'int',
            'wt' => 'array',
            'cpu' => 'array',
            'mu' => 'array',
            'pmu' => 'array',
        ];
        $statStruct = [
            'total' => 'numeric',
            'min' => 'numeric',
            'mean' => 'numeric',
            'max' => 'numeric',
            'variance' => 'numeric',
            'percent' => 'numeric',
        ];
 
        $xhprofData = $this->getXhprofDataFixture();
        $metrics = $xhprofData->getInclusiveMetrics();
 
        foreach ( $metrics as $name => $metric ) {
            $this->assertArrayStructure( $metricStruct, $metric );
 
            foreach ( $metricStruct as $key => $type ) {
                if ( $type === 'array' ) {
                    $this->assertArrayStructure( $statStruct, $metric[$key] );
                    if ( $name === 'main()' ) {
                        $this->assertEquals( 100, $metric[$key]['percent'] );
                    }
                }
            }
        }
    }
 
    public function testCompleteMetricsStructure() {
        $metricStruct = [
            'ct' => 'int',
            'wt' => 'array',
            'cpu' => 'array',
            'mu' => 'array',
            'pmu' => 'array',
            'calls' => 'array',
            'subcalls' => 'array',
        ];
        $statsMetrics = [ 'wt', 'cpu', 'mu', 'pmu' ];
        $statStruct = [
            'total' => 'numeric',
            'min' => 'numeric',
            'mean' => 'numeric',
            'max' => 'numeric',
            'variance' => 'numeric',
            'percent' => 'numeric',
            'exclusive' => 'numeric',
        ];
 
        $xhprofData = $this->getXhprofDataFixture();
        $metrics = $xhprofData->getCompleteMetrics();
 
        foreach ( $metrics as $name => $metric ) {
            $this->assertArrayStructure( $metricStruct, $metric, $name );
 
            foreach ( $metricStruct as $key => $type ) {
                if ( in_array( $key, $statsMetrics ) ) {
                    $this->assertArrayStructure(
                        $statStruct, $metric[$key], $key
                    );
                    $this->assertLessThanOrEqual(
                        $metric[$key]['total'], $metric[$key]['exclusive']
                    );
                }
            }
        }
    }
 
    public function testEdges() {
        $xhprofData = $this->getXhprofDataFixture();
        $this->assertSame( [], $xhprofData->getCallers( 'main()' ) );
        $this->assertSame( [ 'foo', 'xhprof_disable' ],
            $xhprofData->getCallees( 'main()' )
        );
        $this->assertSame( [ 'main()' ],
            $xhprofData->getCallers( 'foo' )
        );
        $this->assertSame( [], $xhprofData->getCallees( 'strlen' ) );
    }
 
    public function testCriticalPath() {
        $xhprofData = $this->getXhprofDataFixture();
        $path = $xhprofData->getCriticalPath();
 
        $last = null;
        foreach ( $path as $key => $value ) {
            list( $func, $call ) = XhprofData::splitKey( $key );
            $this->assertSame( $last, $func );
            $last = $call;
        }
        $this->assertSame( $last, 'bar@1' );
    }
 
    protected function getXhprofDataFixture( array $opts = [] ) {
        return new XhprofData( [
            'foo==>bar' => [
                'ct' => 2,
                'wt' => 57,
                'cpu' => 92,
                'mu' => 1896,
                'pmu' => 0,
            ],
            'foo==>strlen' => [
                'ct' => 2,
                'wt' => 21,
                'cpu' => 141,
                'mu' => 752,
                'pmu' => 0,
            ],
            'bar==>bar@1' => [
                'ct' => 1,
                'wt' => 18,
                'cpu' => 19,
                'mu' => 752,
                'pmu' => 0,
            ],
            'main()==>foo' => [
                'ct' => 1,
                'wt' => 304,
                'cpu' => 307,
                'mu' => 4008,
                'pmu' => 0,
            ],
            'main()==>xhprof_disable' => [
                'ct' => 1,
                'wt' => 8,
                'cpu' => 10,
                'mu' => 768,
                'pmu' => 392,
            ],
            'main()' => [
                'ct' => 1,
                'wt' => 353,
                'cpu' => 351,
                'mu' => 6112,
                'pmu' => 1424,
            ],
        ], $opts );
    }
 
    protected function assertArrayStructure( $struct, $actual, $label = null ) {
        $this->assertInternalType( 'array', $actual, $label );
        $this->assertCount( count( $struct ), $actual, $label );
        foreach ( $struct as $key => $type ) {
            $this->assertArrayHasKey( $key, $actual );
            $this->assertInternalType( $type, $actual[$key] );
        }
    }
}