PHP PHPUnit_Util_Printer类代码示例

 protected function printConsole(\PHPUnit_Util_Printer $printer)
 {
     $writer = new \PHP_CodeCoverage_Report_Text(
         $this->settings['low_limit'], $this->settings['high_limit'], $this->settings['show_uncovered'], false
     );
     $printer->write($writer->process(self::$coverage, $this->options['colors']));
 }

 /**
  * @param  PHPUnit_Framework_Test $suite
  * @param  array                  $arguments
  * @return PHPUnit_Framework_TestResult
  */
 public function doRun(PHPUnit_Framework_Test $suite, array $arguments = array())
 {
     $this->handleConfiguration($arguments);
     if (isset($arguments['bootstrap'])) {
         $GLOBALS['__PHPUNIT_BOOTSTRAP'] = $arguments['bootstrap'];
     }
     if ($arguments['backupGlobals'] === FALSE) {
         $suite->setBackupGlobals(FALSE);
     }
     if ($arguments['backupStaticAttributes'] === TRUE) {
         $suite->setBackupStaticAttributes(TRUE);
     }
     if (is_integer($arguments['repeat'])) {
         $test = new PHPUnit_Extensions_RepeatedTest($suite, $arguments['repeat'], $arguments['filter'], $arguments['groups'], $arguments['excludeGroups'], $arguments['processIsolation']);
         $suite = new PHPUnit_Framework_TestSuite();
         $suite->addTest($test);
     }
     $result = $this->createTestResult();
     if (!$arguments['convertErrorsToExceptions']) {
         $result->convertErrorsToExceptions(FALSE);
     }
     if (!$arguments['convertNoticesToExceptions']) {
         PHPUnit_Framework_Error_Notice::$enabled = FALSE;
     }
     if (!$arguments['convertWarningsToExceptions']) {
         PHPUnit_Framework_Error_Warning::$enabled = FALSE;
     }
     if ($arguments['stopOnError']) {
         $result->stopOnError(TRUE);
     }
     if ($arguments['stopOnFailure']) {
         $result->stopOnFailure(TRUE);
     }
     if ($arguments['stopOnIncomplete']) {
         $result->stopOnIncomplete(TRUE);
     }
     if ($arguments['stopOnSkipped']) {
         $result->stopOnSkipped(TRUE);
     }
     if ($this->printer === NULL) {
         if (isset($arguments['printer']) && $arguments['printer'] instanceof PHPUnit_Util_Printer) {
             $this->printer = $arguments['printer'];
         } else {
             $this->printer = new PHPUnit_TextUI_ResultPrinter(NULL, $arguments['verbose'], $arguments['colors'], $arguments['debug']);
         }
     }
     if (!$this->printer instanceof PHPUnit_Util_Log_TAP && !self::$versionStringPrinted) {
         $this->printer->write(PHPUnit_Runner_Version::getVersionString() . "\n\n");
         if (isset($arguments['configuration'])) {
             $this->printer->write(sprintf("Configuration read from %s\n\n", $arguments['configuration']->getFilename()));
         }
     }
     foreach ($arguments['listeners'] as $listener) {
         $result->addListener($listener);
     }
     $result->addListener($this->printer);
     if ($this->printer instanceof PHPUnit_TextUI_ResultPrinter) {
         $result->addListener(new PHPUnit_Util_DeprecatedFeature_Logger());
     }
     if (isset($arguments['testdoxHTMLFile'])) {
         $result->addListener(new PHPUnit_Util_TestDox_ResultPrinter_HTML($arguments['testdoxHTMLFile']));
     }
     if (isset($arguments['testdoxTextFile'])) {
         $result->addListener(new PHPUnit_Util_TestDox_ResultPrinter_Text($arguments['testdoxTextFile']));
     }
     $codeCoverageReports = 0;
     if (extension_loaded('xdebug')) {
         if (isset($arguments['coverageClover'])) {
             $codeCoverageReports++;
         }
         if (isset($arguments['reportDirectory'])) {
             $codeCoverageReports++;
         }
         if (isset($arguments['coveragePHP'])) {
             $codeCoverageReports++;
         }
         if (isset($arguments['coverageText'])) {
             $codeCoverageReports++;
         }
     }
     if ($codeCoverageReports > 0) {
         $codeCoverage = new PHP_CodeCoverage(NULL, $this->codeCoverageFilter);
         $codeCoverage->setAddUncoveredFilesFromWhitelist($arguments['addUncoveredFilesFromWhitelist']);
         $codeCoverage->setProcessUncoveredFilesFromWhitelist($arguments['processUncoveredFilesFromWhitelist']);
         if (isset($arguments['forceCoversAnnotation'])) {
             $codeCoverage->setForceCoversAnnotation($arguments['forceCoversAnnotation']);
         }
         if (isset($arguments['mapTestClassNameToCoveredClassName'])) {
             $codeCoverage->setMapTestClassNameToCoveredClassName($arguments['mapTestClassNameToCoveredClassName']);
         }
         $result->setCodeCoverage($codeCoverage);
     }
     if ($codeCoverageReports > 1) {
         if (isset($arguments['cacheTokens'])) {
             $codeCoverage->setCacheTokens($arguments['cacheTokens']);
//.........这里部分代码省略.........

 /**
  * Flush: Copy images and additional files to folder and generate index file using a template
  *
  * This method is called once after all tests have been processed.
  * HINT: The flush method is only called if the TestListener inherits from PHPUnit_Util_Printer
  *
  * @param array $templateVars
  * @return void
  * @author Fabrizio Branca
  */
 public function flush(array $templateVars = array())
 {
     $this->copyAdditionalFiles();
     $className = $this->viewClass;
     $view = new $className($this->templateFile);
     /* @var $view Menta_Util_View  */
     if (!$view instanceof Menta_Util_View) {
         throw new Exception('View must inherit from Menta_Util_View.');
     }
     foreach ($templateVars as $key => $value) {
         $view->assign($key, $value);
     }
     $this->write($view->render());
     return parent::flush();
 }

 public function __construct($out = null)
 {
     parent::__construct($out);
     self::$instance = $this;
     $this->setAutoFlush(true);
     $this->fd = fopen("php://fd/3", "w");
 }

 /**
  * {@inheritDoc}
  */
 public function __construct($out = null)
 {
     parent::__construct($out);
     if ($this->isDebug()) {
         $level = LogLevel::DEBUG;
     } elseif ($this->isVerbose()) {
         $level = LogLevel::INFO;
     } else {
         $level = LogLevel::NOTICE;
     }
     $this->setLogger(new \Psr3ConsoleLogger('PHPUnitPrinterLogger', $level));
 }

 /**
  * @param string $buffer
  */
 public function write($buffer)
 {
     array_walk_recursive($buffer, function (&$input) {
         if (is_string($input)) {
             $input = PHPUnit_Util_String::convertToUtf8($input);
         }
     });
     $flags = 0;
     if (defined('JSON_PRETTY_PRINT')) {
         $flags |= JSON_PRETTY_PRINT;
     }
     parent::write(json_encode($buffer, $flags));
 }

 /**
  * Constructor.
  *
  * @param  mixed                       $out
  * @param  boolean                     $verbose
  * @param  boolean                     $colors
  * @param  boolean                     $debug
  * @throws PHPUnit_Framework_Exception
  * @since  Method available since Release 3.0.0
  */
 public function __construct($out = null, $verbose = false, $colors = false, $debug = false)
 {
     parent::__construct($out);
     if (is_bool($verbose)) {
         $this->verbose = $verbose;
     } else {
         throw PHPUnit_Util_InvalidArgumentHelper::factory(2, 'boolean');
     }
     if (is_bool($colors)) {
         $console = new Console();
         $this->colors = $colors && $console->hasColorSupport();
     } else {
         throw PHPUnit_Util_InvalidArgumentHelper::factory(3, 'boolean');
     }
     if (is_bool($debug)) {
         $this->debug = $debug;
     } else {
         throw PHPUnit_Util_InvalidArgumentHelper::factory(4, 'boolean');
     }
 }

 /**
  * Flush buffer and close output.
  */
 public function flush()
 {
     if ($this->writeDocument === true) {
         $this->write($this->getXML());
     }
     parent::flush();
 }

 /**
  * Constructor.
  *
  * @param  mixed   $out
  * @param  boolean $verbose
  * @throws InvalidArgumentException
  * @access public
  * @since  Method available since Release 3.0.0
  */
 public function __construct($out = NULL, $verbose = FALSE)
 {
     parent::__construct($out);
     if (is_bool($verbose)) {
         $this->verbose = $verbose;
     } else {
         throw new InvalidArgumentException();
     }
 }

 /**
  * Flush buffer and close output.
  */
 public function flush()
 {
     $this->write($this->document->saveXML());
     parent::flush();
 }

 /**
  * @param string $buffer
  */
 public function write($buffer)
 {
     parent::write(json_encode($buffer));
 }

 /**
  * Constructor.
  *
  * @param  mixed   $out
  * @param  boolean $verbose
  * @param  boolean $colors
  * @param  boolean $debug
  * @throws InvalidArgumentException
  * @since  Method available since Release 3.0.0
  */
 public function __construct($out = NULL, $verbose = FALSE, $colors = FALSE, $debug = FALSE)
 {
     parent::__construct($out);
     if (is_bool($verbose)) {
         $this->verbose = $verbose;
     } else {
         throw PHPUnit_Util_InvalidArgumentHelper::factory(2, 'boolean');
     }
     if (is_bool($colors)) {
         $this->colors = $colors;
     } else {
         throw PHPUnit_Util_InvalidArgumentHelper::factory(3, 'boolean');
     }
     if (is_bool($debug)) {
         $this->debug = $debug;
     } else {
         throw PHPUnit_Util_InvalidArgumentHelper::factory(4, 'boolean');
     }
 }

 /**
  * Flush buffer and close output.
  *
  * @access public
  */
 public function flush()
 {
     $this->write($this->graph->parse());
     parent::flush();
 }

 /**
  * Flush buffer and close output.
  */
 public function flush()
 {
     $this->doEndClass();
     $this->endRun();
     parent::flush();
 }

 /**
  * @param string $buffer
  */
 public function write($buffer)
 {
     parent::write(json_encode($buffer, JSON_PRETTY_PRINT));
 }