protected function tearDown()
 {
     xdebug_stop_code_coverage(false);
     $this->clearEntity($this->method);
     xdebug_start_code_coverage(XDEBUG_CC_UNUSED | XDEBUG_CC_DEAD_CODE);
     parent::tearDown();
 }

 /**
  * Stop collection of code coverage information.
  *
  * @return array
  */
 public function stop()
 {
     // @codeCoverageIgnoreStart
     $codeCoverage = xdebug_get_code_coverage();
     xdebug_stop_code_coverage();
     return $codeCoverage;
     // @codeCoverageIgnoreEnd
 }

 public static function stopCodeCoverage()
 {
     if (function_exists('xdebug_stop_code_coverage') && self::$coverageStopped === false) {
         self::$coverageStopped = xdebug_stop_code_coverage(false);
         return self::$coverageStopped;
     }
     return;
 }

 public static function pauseCodeCoverageAnalysis()
 {
     if (false === self::isCodeCoverageAnalysisRunning()) {
         return;
     }
     self::collectCodeCoverageReport();
     xdebug_stop_code_coverage(false);
     self::$m_isCodeCoverageAnalysisRunning = false;
 }

 /**
  * Paints the end of a group test. Will paint the page
  * footer if the stack of tests has unwound.
  * @param string $test_name   Name of test that is ending.
  * @param integer $progress   Number of test cases ending.
  */
 function paintGroupEnd($test_name)
 {
     if (extension_loaded('xdebug')) {
         $this->code_coverage = xdebug_get_code_coverage();
         xdebug_stop_code_coverage();
         ksort($this->code_coverage);
     }
     HtmlReporter::paintGroupEnd($test_name);
 }

function save_coverage_data($test_id)
{
    $data = xdebug_get_code_coverage();
    xdebug_stop_code_coverage();
    if (!is_dir($GLOBALS['PHPUNIT_COVERAGE_DATA_DIRECTORY'])) {
        mkdir($GLOBALS['PHPUNIT_COVERAGE_DATA_DIRECTORY'], 0777, true);
    }
    $file = $GLOBALS['PHPUNIT_COVERAGE_DATA_DIRECTORY'] . '/' . $test_id . '.' . md5(uniqid(rand(), true));
    echo "Saving coverage data to {$file}...\n";
    file_put_contents($file, serialize($data));
}

 public function stopCodeCoverage()
 {
     //echo "stopCodeCoverage called...\n";
     if (extension_loaded('xdebug')) {
         $data = xdebug_get_code_coverage();
         xdebug_stop_code_coverage();
         //echo "xdebug_stop_code_coverage called...\n";
         global $CDASH_COVERAGE_DIR;
         $file = $CDASH_COVERAGE_DIR . DIRECTORY_SEPARATOR . md5($_SERVER['SCRIPT_FILENAME']);
         file_put_contents($file . '.' . md5(uniqid(rand(), true)) . '.' . get_class(), serialize($data));
     }
 }

 /**
  * Stops code coverage.
  *
  * @return array The collected coverage
  */
 public function stop()
 {
     $data = xdebug_get_code_coverage();
     xdebug_stop_code_coverage($this->_config['cleanup']);
     $result = [];
     foreach ($data as $file => $coverage) {
         foreach ($coverage as $line => $value) {
             if ($line && $value !== -2) {
                 $result[$file][$line - 1] = $value === -1 ? 0 : $value;
             }
         }
     }
     return $result;
 }

 public static function stop($reportDir = null)
 {
     if ($reportDir !== null) {
         self::initialize($reportDir);
     }
     if (function_exists('xdebug_start_code_coverage')) {
         $userStory = self::getUserStoryFromFile();
         self::updateCodeCoverageReports($userStory);
         // some session handlers, close() for example, will be called after main script finished executing, so if we call CodeCoverage::stop()
         // and xdebug is stopped then it will be implossible to get code coverage stats for such session handlers.
         xdebug_stop_code_coverage(true);
     }
     self::generateHtmlReports($reportDir);
 }

 /**
  * Stop collection of code coverage information and store it in Sqlite3.
  *
  * @return array
  */
 public function stop()
 {
     $cov = xdebug_get_code_coverage();
     xdebug_stop_code_coverage();
     if (!isset($this->root)) {
         $this->root = getcwd();
     }
     $dataHandler = new DataHandler(self::SQLITE_DB);
     chdir($this->root);
     $dataHandler->write($cov);
     $cleanData = $this->cleanup($dataHandler->read());
     unset($dataHandler);
     // release sqlite connection
     return $cleanData;
 }

 /**
  * Takes an instance of an object (usually a Collection object) containing test
  * instances. Attaches code coverage filtering to test cases.
  *
  * @see lithium\test\filter\Coverage::collect()
  * @param object $report Instance of Report which is calling apply.
  * @param array $tests The test to apply this filter on
  * @param array $options Options for how code coverage should be applied. These options are
  *              also passed to `Coverage::collect()` to determine how to aggregate results. See
  *              the documentation for `collect()` for further options.  Options affecting this
  *              method are:
  *              -'method': The name of method to attach to, defaults to 'run'.
  * @return object|void Returns the instance of `$tests` with code coverage analysis
  *                     triggers applied.
  */
 public static function apply($report, $tests, array $options = array())
 {
     $defaults = array('method' => 'run');
     $options += $defaults;
     $m = $options['method'];
     $filter = function ($self, $params, $chain) use($report, $options) {
         xdebug_start_code_coverage(XDEBUG_CC_UNUSED | XDEBUG_CC_DEAD_CODE);
         $chain->next($self, $params, $chain);
         $results = xdebug_get_code_coverage();
         xdebug_stop_code_coverage();
         $report->collect(__CLASS__, array($self->subject() => $results));
     };
     $tests->invoke('applyFilter', array($m, $filter));
     return $tests;
 }

function endDebug()
{
    if (defined('SH_DEBUG_VERIFY_FOLDER') && is_dir(SH_DEBUG_VERIFY_FOLDER)) {
        if (defined('SH_DEBUG_COVERAGE_PAGE')) {
            $linker = sh_linker::getInstance();
            if (file_exists(SH_DEBUG_COVERAGE_PAGE)) {
                include SH_DEBUG_COVERAGE_PAGE;
            } else {
                $coverage = array();
            }
            $all_elements = debug_get_coverage($coverage);
            $linker->helper->writeArrayInFile(SH_DEBUG_COVERAGE_PAGE, "coverage", $all_elements);
            xdebug_stop_code_coverage();
        }
    }
}

 /**
  * Takes an instance of an object (usually a Collection object) containing test
  * instances. Attaches code coverage filtering to test cases.
  *
  * @see lithium\test\filter\Coverage::collect()
  * @param object $report Instance of Report which is calling apply.
  * @param array $tests The test to apply this filter on
  * @param array $options Options for how code coverage should be applied. These options are
  *              also passed to `Coverage::collect()` to determine how to aggregate results. See
  *              the documentation for `collect()` for further options.  Options affecting this
  *              method are:
  *              -'method': The name of method to attach to, defaults to 'run'.
  * @return object Returns the instance of `$tests` with code coverage analysis
  *                     triggers applied.
  */
 public static function apply($report, $tests, array $options = array())
 {
     $defaults = array('method' => 'run');
     $options += $defaults;
     if (!function_exists('xdebug_start_code_coverage')) {
         $msg = "Xdebug not installed. Please install Xdebug before running code coverage.";
         throw new RuntimeException($msg);
     }
     $filter = function ($self, $params, $chain) use($report, $options) {
         xdebug_start_code_coverage(XDEBUG_CC_UNUSED | XDEBUG_CC_DEAD_CODE);
         $chain->next($self, $params, $chain);
         $results = xdebug_get_code_coverage();
         xdebug_stop_code_coverage();
         $report->collect(__CLASS__, array($self->subject() => $results));
     };
     $tests->invoke('applyFilter', array($options['method'], $filter));
     return $tests;
 }

 function paintFooter($test_name)
 {
     if (extension_loaded('xdebug')) {
         $this->coverage = xdebug_get_code_coverage();
         xdebug_stop_code_coverage();
     }
     $colour = $this->getFailCount() + $this->getExceptionCount() > 0 ? "red" : "green";
     print "<div style=\"";
     print "padding: 8px; margin-top: 1em; background-color: {$colour}; color: white;";
     print "\">";
     print $this->getTestCaseProgress() . "/" . $this->getTestCaseCount();
     print " test cases complete:\n";
     print "<strong>" . $this->getPassCount() . "</strong> passes, ";
     print "<strong>" . $this->getFailCount() . "</strong> fails and ";
     print "<strong>" . $this->getExceptionCount() . "</strong> exceptions.";
     print "</div>\n";
     $this->paintCoverage();
     print "</body>\n</html>\n";
 }

function save_code_coverage()
{
    $coverage_directory = "/home/alice/twfy-coverage/";
    if (!file_exists($coverage_directory)) {
        mkdir($coverage_directory, 0777, TRUE);
    }
    global $coverage_identifier;
    $output_filename = $coverage_directory . $coverage_identifier;
    $coverage_data = xdebug_get_code_coverage();
    $fp = fopen($output_filename, "w");
    fwrite($fp, $output_filename . "\n");
    foreach ($coverage_data as $filename => $line_map) {
        fwrite($fp, $filename . "\n");
        foreach ($line_map as $line_number => $number_of_uses) {
            fwrite($fp, "  " . $line_number . ": " . $number_of_uses . "\n");
        }
    }
    fclose($fp);
    xdebug_stop_code_coverage();
}

 /**
  *    Paints coverage report if enabled.
  *    @param string $group     Name of test or other label.
  *    @access public
  */
 function paintGroupEnd($group)
 {
     $this->group = "";
     $cc = "";
     if ($this->cc) {
         if (extension_loaded('xdebug')) {
             $arrfiles = xdebug_get_code_coverage();
             xdebug_stop_code_coverage();
             $thisdir = dirname(__FILE__);
             $thisdirlen = strlen($thisdir);
             foreach ($arrfiles as $index => $file) {
                 if (substr($index, 0, $thisdirlen) === $thisdir) {
                     continue;
                 }
                 $lcnt = 0;
                 $ccnt = 0;
                 foreach ($file as $line) {
                     if ($line == -2) {
                         continue;
                     }
                     $lcnt++;
                     if ($line == 1) {
                         $ccnt++;
                     }
                 }
                 if ($lcnt > 0) {
                     $cc .= round($ccnt / $lcnt * 100, 2) . '%';
                 } else {
                     $cc .= "0.00%";
                 }
                 $cc .= "\t" . $index . "\n";
             }
         }
     }
     $this->listener->write('{status:"coverage",message:"' . EclipseReporter::escapeVal($cc) . '"}');
 }

 /**
  * Runs a TestCase.
  *
  * @param  PHPUnit_Framework_Test $test
  */
 public function run(PHPUnit_Framework_Test $test)
 {
     PHPUnit_Framework_Assert::resetCount();
     $error = FALSE;
     $failure = FALSE;
     $this->startTest($test);
     $errorHandlerSet = FALSE;
     if ($this->convertErrorsToExceptions) {
         $oldErrorHandler = set_error_handler(array('PHPUnit_Util_ErrorHandler', 'handleError'), E_ALL | E_STRICT);
         if ($oldErrorHandler === NULL) {
             $errorHandlerSet = TRUE;
         } else {
             restore_error_handler();
         }
     }
     if (self::$xdebugLoaded === NULL) {
         self::$xdebugLoaded = extension_loaded('xdebug');
         self::$useXdebug = self::$xdebugLoaded;
     }
     $useXdebug = self::$useXdebug && $this->collectCodeCoverageInformation && !$test instanceof PHPUnit_Extensions_SeleniumTestCase;
     if ($useXdebug) {
         xdebug_start_code_coverage(XDEBUG_CC_UNUSED | XDEBUG_CC_DEAD_CODE);
     }
     PHPUnit_Util_Timer::start();
     try {
         $test->runBare();
     } catch (PHPUnit_Framework_AssertionFailedError $e) {
         $failure = TRUE;
     } catch (Exception $e) {
         $error = TRUE;
     }
     $time = PHPUnit_Util_Timer::stop();
     if ($useXdebug) {
         $codeCoverage = xdebug_get_code_coverage();
         xdebug_stop_code_coverage();
         $this->appendCodeCoverageInformation($test, $codeCoverage);
     }
     if ($errorHandlerSet === TRUE) {
         restore_error_handler();
     }
     $test->addToAssertionCount(PHPUnit_Framework_Assert::getCount());
     if ($error === TRUE) {
         $this->addError($test, $e, $time);
     } else {
         if ($failure === TRUE) {
             $this->addFailure($test, $e, $time);
         }
     }
     $this->endTest($test, $time);
 }

 /**
  * Stop collection of code coverage information.
  *
  * @return array
  */
 public function stop()
 {
     $data = xdebug_get_code_coverage();
     xdebug_stop_code_coverage();
     return $this->cleanup($data);
 }

                    $data[$file] = $lines;
                } else {
                    foreach ($lines as $line => $flag) {
                        if (!isset($data[$file][$line]) || $flag > $data[$file][$line]) {
                            $data[$file][$line] = $flag;
                        }
                    }
                }
            }
        }
    }
    echo serialize($data);
    exit;
}
if (isset($_SERVER['HTTP_X_ENABLE_COVERAGE']) && isset($_SERVER['HTTP_X_TEST_SESSION_ID']) && extension_loaded('xdebug')) {
    // Register a shutdown function that stops code coverage and stores the coverage of the current
    // request
    register_shutdown_function(function () {
        $data = xdebug_get_code_coverage();
        xdebug_stop_code_coverage();
        $coverageDir = sys_get_temp_dir() . '/behat-coverage';
        if (is_dir($coverageDir) || mkdir($coverageDir, 0775, true)) {
            $filename = sprintf('%s/%s.%s.cov', $coverageDir, md5(uniqid('', true)), $_SERVER['HTTP_X_TEST_SESSION_ID']);
            file_put_contents($filename, serialize($data));
        }
    });
    // Start code coverage
    xdebug_start_code_coverage(XDEBUG_CC_UNUSED | XDEBUG_CC_DEAD_CODE);
}
// Return false from the router to serve the requested file as is
return false;

 function main()
 {
     $files = $this->getFilenames();
     $this->log("Setting up coverage database for " . count($files) . " files");
     $props = new Properties();
     foreach ($files as $file) {
         $fullname = $file['fullname'];
         $filename = $file['key'];
         $props->setProperty($filename, serialize(array('fullname' => $fullname, 'coverage' => array())));
     }
     $dbfile = new PhingFile($this->database);
     $props->store($dbfile);
     $this->project->setProperty('coverage.database', $dbfile->getAbsolutePath());
     foreach ($files as $file) {
         $fullname = $file['fullname'];
         xdebug_start_code_coverage(XDEBUG_CC_UNUSED);
         Phing::__import($fullname, $this->classpath);
         $coverage = xdebug_get_code_coverage();
         xdebug_stop_code_coverage();
         CoverageMerger::merge($this->project, array($coverage));
     }
 }