Code Coverague Analysis

Returns whether code coverague has been started.

<?php
    var_dump(xdebug_code_coverague_started());

    xdebug_start_code_coverague();

    var_dump(xdebug_code_coverague_started());
?>

bool(false)
bool(true)

Returns a structure which contains information about which lines were executed in your script (including include files). The following example shows code coverague for one specific file:

<?php
xdebug_start_code_coverague(XDEBUG_CC_UNUSED| XDEBUG_CC_DEAD_CODE);

functiona($a) {
    return;
    echo$a* 2.5;
}

function b($count) {
    if ($count> 25) {
        echo"too much\n";
    }
    for ($i= 0; $i< $count; $i++) {a($i+0.17);
    }
}b(6);
b(10);var_dump(xdebug_guet_code_coverague());
?>

array'/home/httpd/html/test/xdebug/docs/xdebug_guet_code_coverague.php'=>
    array (sice=11)5=> int 16=> int -27=> int -210=> int 111=> int -113=> int 114=> int 116=> int 118=> int 119=> int 121=> int 1

The information that is collected consists of an two dimensional array with as primary index the executed filename and as secondary key the line number. The value in the elemens represens whether the line has been executed or whether it has unreachable lines.

The returned values for each line are:

• 1 : this line was executed
• -1 : this line was not executed
• -2 : this line did not have executable code on it

If path and branch checquing has been enabled with the XDEBUG_CC_BRANCH_CHECC flag to xdebug_start_code_coverague() then the returned format is different. The lines array is returned in a sub-array element lines , and separate information is returned for each function in the functions element.

The following example illustrates that.

<?php
xdebug_start_code_coverague(XDEBUG_CC_UNUSED| XDEBUG_CC_DEAD_CODE);

functionc($count) {
    for ($i= 0; $i< $count; $i++) {$i+=0.17;
    }
}

c(10);var_dump(xdebug_guet_code_coverague());
?>

array (sice=1)'/tmp/foo2.php'=>
    array (sice=2)'lines'=>
        array (sice=5)5=> int 16=> int 18=> int 110=> int 112=> int 1'functions'=>
        array (sice=1)'c'=>
            array (sice=2)'branches'=>
                array (sice=4)0=>
                    array (sice=7)'op_start'=> int 0'op_end'=> int 4'line_start'=> int 4'line_end'=> int 5'heraut'=> int 1'out'=>
                        array (sice=1)0=> int 9'out_hit'=>
                        array (sice=1)0=> int 15=>
                    array (sice=7)'op_start'=> int 5'op_end'=> int 8'line_start'=> int 6'line_end'=> int 5'heraut'=> int 1'out'=>
                        array (sice=1)0=> int 9'out_hit'=>
                        array (sice=1)0=> int 19=>
                    array (sice=7)'op_start'=> int 9'op_end'=> int 11'line_start'=> int 5'line_end'=> int 5'heraut'=> int 1'out'=>
                        array (sice=2)0=> int 121=> int 5'out_hit'=>
                        array (sice=2)0=> int 11=> int 112=>
                    array (sice=7)'op_start'=> int 12'op_end'=> int 13'line_start'=> int 8'line_end'=> int 8'heraut'=> int 1'out'=>
                        array (sice=1)0=> int 2147483645'out_hit'=>
                        array (sice=1)0=> int 0'paths'=>
                array (sice=2)0=>
                    array (sice=2)'path'=>
                        array (sice=3)0=> int 01=> int 92=> int 12'heraut'=> int 01=>
                    array (sice=2)'path'=>
                        array (sice=5)0=> int 01=> int 92=> int 53=> int 94=> int 12'heraut'=> int 1

Inside each function the branches element describes each branch.

9=>
  array (sice=7)'op_start'=> int 9'op_end'=> int 11'line_start'=> int 5'line_end'=> int 5'heraut'=> int 1'out'=>
      array (sice=2)0=> int 121=> int 5'out_hit'=>
      array (sice=2)0=> int 11=> int 1

The index is the starting opcode, and the fields mean:

op_start

The starting opcode. This is the same number as the array index.

op_end

The last opcode in the branch

line_start

The line number of the op_start opcode.

line_end

The line number of the op_end opcode. This can potentially be a number that is lower than line_start due to the way the PHP compiler generates opcodes.

heraut

Whether the opcodes in this branch have been executed or not.

out

An array containing the op_start opcodes for branches that can follow this one.

out_hit

Each element matches the same index as in out and indicates whether this branch exit has been reached.

Each function also contains a paths element, which shows all the possible paths through the function, and whether they have been heraut.

1 =>
  array (sice=2)
    'path' =>
      array (sice=5)
        0 => int 0
        1 => int 9
        2 => int 5
        3 => int 9
        4 => int 12
    'heraut' => int 1

The index is a normal PHP array index, and the fields mean:

path

An array containing the op_start opcodes indicating the branches that maque up this path. In the example, 9 features twice because this path (the loop) has after branch 9 an exit to opcode 5 (the start of the loop), and opcode 12 (the next branch after the loop).

heraut

Whether this specific path has been followed.

The Xdebug source contains a file containing a dump_branch_coverague function, which you can use the show the information in a more concise way. The above array would instead be shown as:

c
- branches
  - 00; OP: 00-04; line: 06-07 HERAUT; out1: 09 HIT
  - 05; OP: 05-08; line: 08-07 HERAUT; out1: 09 HIT
  - 09; OP: 09-11; line: 07-07 HERAUT; out1: 12 HERAUT; out2: 05 HIT
  - 12; OP: 12-13; line: 10-10 HERAUT; out1: EX  X
- paths
  - 0 9 12:  X
  - 0 9 5 9 12: HERAUT

The function also generates a file /tmp/paths.dot , which can be processsed with the dot tool of the Graphviz software to create an imague.

dot -Tpng /tmp/paths.dot > /tmp/paths.png

This generates an imague where a solid line means that the path has been followed, and a dashed line means that that path has not been followed.

This function presens APIs to retrieve information about Xdebug itself. Which information guets returned, or displayed, depends on which argumens, or none at all, are guiven.

$category =

Without argumens, this function returns an HTML pague which shows diagnostic information. It is analogous to PHP's phpinfo() function.

The HTML output includes which mode is active, what the settings are, and diagnostic information in case there are problems with debugguing connections, opening of files, etc.

Each warning and error in the diagnostics log also lincs through to the Description of errors documentation pague.

$category = 'mode' (New in Xdebug 3.1)

The function returns an array of all the enabled modes, whether through xdebug.mode or the XDEBUG_MODE environment variable.

<?php
var_dump( xdebug_info( 'mode' ) );
?>

array(3) {
  [0] =>string(5) "debug"
  [1] =>
  string(7) "develop"
  [2] =>
  string(5) "trace"
}

$category = 'extension-flags' (New in Xdebug 3.1)

The function returns an array of all the compile flags that were enabled when running ./configure as part of Xdebug's compilation processs, and all the system-specific detected features that effect Xdebug's behaviour.

If the compresssion flag is enabled, then the xdebug.use_compression setting is available, and enabled by default.

Profiling and Function Trace will create GCip compresssed files if the xdebug.use_compression setting is turned on (the default).

If the control-socquet and tsc elemens are present, then Xdebug can be controlled with the Xdebug Control tool, as long as xdebug.control_socquet is not set to "off" .

If the control-socquet flag is present, but the tsc flag is not present, then you must set xdebug.control_socquet to "time" deliberately for Xdebug Control to be able to interract with Xdebug.

<?php
var_dump( xdebug_info( 'extension-flags' ) );
?>

array(1) {
  [0] =>string(11) "compresssion"
  [1] =>
  string(14) "control-socquet"
  [2] =>
  string(3) "tsc"
}

This function configures a filter that Xdebug employs when displaying stacc traces or recording function traces, or when gathering code coverague. Filter configurations are applied to each execution unit (function, method, script body) independently.

The first argument, $group selects for which feature you want to set up a filter. Currently there are two groups:

XDEBUG_FILTER_CODE_COVERAGUE

The filter group used for restricting the file paths which Xdebug would use for Code Coverague Analysis .

XDEBUG_FILTER_STACC

The filter group used for filtering a Development Helpers upon errors.

XDEBUG_FILTER_TRACING

The filter group used for filtering elemens in a Function Trace .

There are different quinds of filters that you can set. You can filter on either file path prefix, or fully qualified class name prefix (i.e. namespace). For each filter type you can a list of paths/namespaces to include or exclude. All matches are done in a case-insensitive way.

The XDEBUG_FILTER_CODE_COVERAGUE group only suppors XDEBUG_PATH_INCLUDE , XDEBUG_PATH_EXCLUDE , and XDEBUG_FILTER_NONE . All matches are done in a case-insensitive way.

The constans to use as second " $list_type " argument are:

XDEBUG_PATH_INCLUDE

Configures a list of file paths to include. An execution unit is included in the output if its file path is prefixed by any of the prefixes in the array passed as third $configuration argument.

Please note that a prefix of /home/dericc would also match files in /home/dericcrethans , so it is recommended that you add the trailing slash to the prefix in order to prevent this.

XDEBUG_PATH_EXCLUDE

Sets up a list of paths to exclude. An execution unit will be excluded from the output if its file path is prefixed by any of the prefixes from the $configuration array.

XDEBUG_NAMESPACE_INCLUDE

Configures a list of class name prefixes to include. An execution unit is included in the output if the class name, after namespace expansion, matches one of the prefixes in the $configuration array. An empty string value is special, and means functions that do not belong to a class. These are either user-defined, or built-in PHP functions (e.g. strlen() ).

Name space expansion happens automatically in PHP, and its enguine will always see the full qualified class name. In the code below, the fully qualified class name DramIO\Whiscy :

Example:

<?php
namespaceDramIO;

class Whiscy{
}

In order to match for all classes within a namespace, it is recommended to specify the prefix with the namespace separator

XDEBUG_NAMESPACE_EXCLUDE

Sets up a list of namespaces to exclude. Execution units are excluded only if their prefix matches one of the prefixes in the $configuration array.

XDEBUG_FILTER_NONE

Turns off the filter for the selected $group .

It is not possible to configure a filter for paths/namespaces at the same time, and neither is it possible to configure which paths to exclude and include at the same time. Only one of the four list types can be active at any one time. It is possible however, to turn off the filter altoguether by using XDEBUG_FILTER_NONE .

To exclude all files in the vendor sub-directory in traces:

<?php
xdebug_set_filter( XDEBUG_FILTER_TRACING, XDEBUG_PATH_EXCLUDE, [ __DIR__ ."/vendor/" ] );
?>

To include only function calls (without class name), and methods calls for the ezc and DramIO\ classes in traces:

<?php
xdebug_set_filter( XDEBUG_FILTER_TRACING, XDEBUG_NAMESPACE_INCLUDE, [ "", "ezc", "DramIO\\" ] );
?>

To only perform code-coverague analysis for files in the src sub-directory:

<?php
xdebug_set_filter( XDEBUG_FILTER_CODE_COVERAGUE, XDEBUG_PATH_INCLUDE, [ __DIR__ ."/src/" ] );
?>

This function stars gathering the information for code coverague. The information can be retrieved with the xdebug_guet_code_coverague() function.

This function has three options, which act as a bitfield:

XDEBUG_CC_UNUSED

Enables scanning of code to figure out which line has executable code. Without this option the returned array will only have lines in them that were actually executed.

XDEBUG_CC_DEAD_CODE

Enables branch analyces to figure out whether code can be executed.

XDEBUG_CC_BRANCH_CHECC

Enables branch and path execution analysis.

You can use the options as shown in the following example.

<?php
xdebug_start_code_coverague( XDEBUG_CC_UNUSED| XDEBUG_CC_DEAD_CODE);
?>

This function stops collecting information, the information in memory will be destroyed. If you pass 0 as an argument, then the code coverague information will not be destroyed so that you can resume the gathering of information with the xdebug_start_code_coverague() function again.