Source for file scorer.php

Documentation is available at scorer.php

  1. <?php
  2. /**
  3.  *  base include file for SimpleTest
  4.  *  @package    SimpleTest
  5.  *  @subpackage UnitTester
  6.  *  @version    $Id: scorer.php 1982 2010-03-28 11:57:54Z lastcraft $
  7.  */
  8.  
  9. /**#@+*/
  10. require_once(dirname(__FILE__) . '/invoker.php');
  11. /**#@-*/
  12.  
  13. /**
  14.  *    Can receive test events and display them. Display
  15.  *    is achieved by making display methods available
  16.  *    and visiting the incoming event.
  17.  *    @package SimpleTest
  18.  *    @subpackage UnitTester
  19.  *    @abstract
  20.  */
  21. class SimpleScorer {
  22.     private $passes;
  23.     private $fails;
  24.     private $exceptions;
  25.     private $is_dry_run;
  26.  
  27.     /**
  28.      *    Starts the test run with no results.
  29.      *    @access public
  30.      */
  31.     function __construct() {
  32.         $this->passes = 0;
  33.         $this->fails = 0;
  34.         $this->exceptions = 0;
  35.         $this->is_dry_run = false;
  36.     }
  37.  
  38.     /**
  39.      *    Signals that the next evaluation will be a dry
  40.      *    run. That is, the structure events will be
  41.      *    recorded, but no tests will be run.
  42.      *    @param boolean $is_dry        Dry run if true.
  43.      *    @access public
  44.      */
  45.     function makeDry($is_dry = true) {
  46.         $this->is_dry_run = $is_dry;
  47.     }
  48.  
  49.     /**
  50.      *    The reporter has a veto on what should be run.
  51.      *    @param string $test_case_name  name of test case.
  52.      *    @param string $method          Name of test method.
  53.      *    @access public
  54.      */
  55.     function shouldInvoke($test_case_name, $method) {
  56.         return ! $this->is_dry_run;
  57.     }
  58.  
  59.     /**
  60.      *    Can wrap the invoker in preperation for running
  61.      *    a test.
  62.      *    @param SimpleInvoker $invoker   Individual test runner.
  63.      *    @return SimpleInvoker           Wrapped test runner.
  64.      *    @access public
  65.      */
  66.     function createInvoker($invoker) {
  67.         return $invoker;
  68.     }
  69.  
  70.     /**
  71.      *    Accessor for current status. Will be false
  72.      *    if there have been any failures or exceptions.
  73.      *    Used for command line tools.
  74.      *    @return boolean        True if no failures.
  75.      *    @access public
  76.      */
  77.     function getStatus() {
  78.         if ($this->exceptions + $this->fails > 0) {
  79.             return false;
  80.         }
  81.         return true;
  82.     }
  83.  
  84.     /**
  85.      *    Paints the start of a group test.
  86.      *    @param string $test_name     Name of test or other label.
  87.      *    @param integer $size         Number of test cases starting.
  88.      *    @access public
  89.      */
  90.     function paintGroupStart($test_name, $size) {
  91.     }
  92.  
  93.     /**
  94.      *    Paints the end of a group test.
  95.      *    @param string $test_name     Name of test or other label.
  96.      *    @access public
  97.      */
  98.     function paintGroupEnd($test_name) {
  99.     }
  100.  
  101.     /**
  102.      *    Paints the start of a test case.
  103.      *    @param string $test_name     Name of test or other label.
  104.      *    @access public
  105.      */
  106.     function paintCaseStart($test_name) {
  107.     }
  108.  
  109.     /**
  110.      *    Paints the end of a test case.
  111.      *    @param string $test_name     Name of test or other label.
  112.      *    @access public
  113.      */
  114.     function paintCaseEnd($test_name) {
  115.     }
  116.  
  117.     /**
  118.      *    Paints the start of a test method.
  119.      *    @param string $test_name     Name of test or other label.
  120.      *    @access public
  121.      */
  122.     function paintMethodStart($test_name) {
  123.     }
  124.  
  125.     /**
  126.      *    Paints the end of a test method.
  127.      *    @param string $test_name     Name of test or other label.
  128.      *    @access public
  129.      */
  130.     function paintMethodEnd($test_name) {
  131.     }
  132.  
  133.     /**
  134.      *    Increments the pass count.
  135.      *    @param string $message        Message is ignored.
  136.      *    @access public
  137.      */
  138.     function paintPass($message) {
  139.         $this->passes++;
  140.     }
  141.  
  142.     /**
  143.      *    Increments the fail count.
  144.      *    @param string $message        Message is ignored.
  145.      *    @access public
  146.      */
  147.     function paintFail($message) {
  148.         $this->fails++;
  149.     }
  150.  
  151.     /**
  152.      *    Deals with PHP 4 throwing an error.
  153.      *    @param string $message    Text of error formatted by
  154.      *                               the test case.
  155.      *    @access public
  156.      */
  157.     function paintError($message) {
  158.         $this->exceptions++;
  159.     }
  160.  
  161.     /**
  162.      *    Deals with PHP 5 throwing an exception.
  163.      *    @param Exception $exception    The actual exception thrown.
  164.      *    @access public
  165.      */
  166.     function paintException($exception) {
  167.         $this->exceptions++;
  168.     }
  169.     
  170.     /**
  171.      *    Prints the message for skipping tests.
  172.      *    @param string $message    Text of skip condition.
  173.      *    @access public
  174.      */
  175.     function paintSkip($message) {
  176.     }
  177.  
  178.     /**
  179.      *    Accessor for the number of passes so far.
  180.      *    @return integer       Number of passes.
  181.      *    @access public
  182.      */
  183.     function getPassCount() {
  184.         return $this->passes;
  185.     }
  186.  
  187.     /**
  188.      *    Accessor for the number of fails so far.
  189.      *    @return integer       Number of fails.
  190.      *    @access public
  191.      */
  192.     function getFailCount() {
  193.         return $this->fails;
  194.     }
  195.  
  196.     /**
  197.      *    Accessor for the number of untrapped errors
  198.      *    so far.
  199.      *    @return integer       Number of exceptions.
  200.      *    @access public
  201.      */
  202.     function getExceptionCount() {
  203.         return $this->exceptions;
  204.     }
  205.  
  206.     /**
  207.      *    Paints a simple supplementary message.
  208.      *    @param string $message        Text to display.
  209.      *    @access public
  210.      */
  211.     function paintMessage($message) {
  212.     }
  213.  
  214.     /**
  215.      *    Paints a formatted ASCII message such as a
  216.      *    privateiable dump.
  217.      *    @param string $message        Text to display.
  218.      *    @access public
  219.      */
  220.     function paintFormattedMessage($message) {
  221.     }
  222.  
  223.     /**
  224.      *    By default just ignores user generated events.
  225.      *    @param string $type        Event type as text.
  226.      *    @param mixed $payload      Message or object.
  227.      *    @access public
  228.      */
  229.     function paintSignal($type, $payload) {
  230.     }
  231. }
  232.  
  233. /**
  234.  *    Recipient of generated test messages that can display
  235.  *    page footers and headers. Also keeps track of the
  236.  *    test nesting. This is the main base class on which
  237.  *    to build the finished test (page based) displays.
  238.  *    @package SimpleTest
  239.  *    @subpackage UnitTester
  240.  */
  241. class SimpleReporter extends SimpleScorer {
  242.     private $test_stack;
  243.     private $size;
  244.     private $progress;
  245.  
  246.     /**
  247.      *    Starts the display with no results in.
  248.      *    @access public
  249.      */
  250.     function __construct() {
  251.         parent::__construct();
  252.         $this->test_stack = array();
  253.         $this->size = null;
  254.         $this->progress = 0;
  255.     }
  256.     
  257.     /**
  258.      *    Gets the formatter for small generic data items.
  259.      *    @return SimpleDumper          Formatter.
  260.      *    @access public
  261.      */
  262.     function getDumper() {
  263.         return new SimpleDumper();
  264.     }
  265.  
  266.     /**
  267.      *    Paints the start of a group test. Will also paint
  268.      *    the page header and footer if this is the
  269.      *    first test. Will stash the size if the first
  270.      *    start.
  271.      *    @param string $test_name   Name of test that is starting.
  272.      *    @param integer $size       Number of test cases starting.
  273.      *    @access public
  274.      */
  275.     function paintGroupStart($test_name, $size) {
  276.         if (! isset($this->size)) {
  277.             $this->size = $size;
  278.         }
  279.         if (count($this->test_stack) == 0) {
  280.             $this->paintHeader($test_name);
  281.         }
  282.         $this->test_stack[] = $test_name;
  283.     }
  284.  
  285.     /**
  286.      *    Paints the end of a group test. Will paint the page
  287.      *    footer if the stack of tests has unwound.
  288.      *    @param string $test_name   Name of test that is ending.
  289.      *    @param integer $progress   Number of test cases ending.
  290.      *    @access public
  291.      */
  292.     function paintGroupEnd($test_name) {
  293.         array_pop($this->test_stack);
  294.         if (count($this->test_stack) == 0) {
  295.             $this->paintFooter($test_name);
  296.         }
  297.     }
  298.  
  299.     /**
  300.      *    Paints the start of a test case. Will also paint
  301.      *    the page header and footer if this is the
  302.      *    first test. Will stash the size if the first
  303.      *    start.
  304.      *    @param string $test_name   Name of test that is starting.
  305.      *    @access public
  306.      */
  307.     function paintCaseStart($test_name) {
  308.         if (! isset($this->size)) {
  309.             $this->size = 1;
  310.         }
  311.         if (count($this->test_stack) == 0) {
  312.             $this->paintHeader($test_name);
  313.         }
  314.         $this->test_stack[] = $test_name;
  315.     }
  316.  
  317.     /**
  318.      *    Paints the end of a test case. Will paint the page
  319.      *    footer if the stack of tests has unwound.
  320.      *    @param string $test_name   Name of test that is ending.
  321.      *    @access public
  322.      */
  323.     function paintCaseEnd($test_name) {
  324.         $this->progress++;
  325.         array_pop($this->test_stack);
  326.         if (count($this->test_stack) == 0) {
  327.             $this->paintFooter($test_name);
  328.         }
  329.     }
  330.  
  331.     /**
  332.      *    Paints the start of a test method.
  333.      *    @param string $test_name   Name of test that is starting.
  334.      *    @access public
  335.      */
  336.     function paintMethodStart($test_name) {
  337.         $this->test_stack[] = $test_name;
  338.     }
  339.  
  340.     /**
  341.      *    Paints the end of a test method. Will paint the page
  342.      *    footer if the stack of tests has unwound.
  343.      *    @param string $test_name   Name of test that is ending.
  344.      *    @access public
  345.      */
  346.     function paintMethodEnd($test_name) {
  347.         array_pop($this->test_stack);
  348.     }
  349.  
  350.     /**
  351.      *    Paints the test document header.
  352.      *    @param string $test_name     First test top level
  353.      *                                  to start.
  354.      *    @access public
  355.      *    @abstract
  356.      */
  357.     function paintHeader($test_name) {
  358.     }
  359.  
  360.     /**
  361.      *    Paints the test document footer.
  362.      *    @param string $test_name        The top level test.
  363.      *    @access public
  364.      *    @abstract
  365.      */
  366.     function paintFooter($test_name) {
  367.     }
  368.  
  369.     /**
  370.      *    Accessor for internal test stack. For
  371.      *    subclasses that need to see the whole test
  372.      *    history for display purposes.
  373.      *    @return array     List of methods in nesting order.
  374.      *    @access public
  375.      */
  376.     function getTestList() {
  377.         return $this->test_stack;
  378.     }
  379.  
  380.     /**
  381.      *    Accessor for total test size in number
  382.      *    of test cases. Null until the first
  383.      *    test is started.
  384.      *    @return integer   Total number of cases at start.
  385.      *    @access public
  386.      */
  387.     function getTestCaseCount() {
  388.         return $this->size;
  389.     }
  390.  
  391.     /**
  392.      *    Accessor for the number of test cases
  393.      *    completed so far.
  394.      *    @return integer   Number of ended cases.
  395.      *    @access public
  396.      */
  397.     function getTestCaseProgress() {
  398.         return $this->progress;
  399.     }
  400.  
  401.     /**
  402.      *    Static check for running in the comand line.
  403.      *    @return boolean        True if CLI.
  404.      *    @access public
  405.      */
  406.     static function inCli() {
  407.         return php_sapi_name() == 'cli';
  408.     }
  409. }
  410.  
  411. /**
  412.  *    For modifying the behaviour of the visual reporters.
  413.  *    @package SimpleTest
  414.  *    @subpackage UnitTester
  415.  */
  416. class SimpleReporterDecorator {
  417.     protected $reporter;
  418.  
  419.     /**
  420.      *    Mediates between the reporter and the test case.
  421.      *    @param SimpleScorer $reporter       Reporter to receive events.
  422.      */
  423.     function __construct($reporter) {
  424.         $this->reporter = $reporter;
  425.     }
  426.  
  427.     /**
  428.      *    Signals that the next evaluation will be a dry
  429.      *    run. That is, the structure events will be
  430.      *    recorded, but no tests will be run.
  431.      *    @param boolean $is_dry        Dry run if true.
  432.      *    @access public
  433.      */
  434.     function makeDry($is_dry = true) {
  435.         $this->reporter->makeDry($is_dry);
  436.     }
  437.  
  438.     /**
  439.      *    Accessor for current status. Will be false
  440.      *    if there have been any failures or exceptions.
  441.      *    Used for command line tools.
  442.      *    @return boolean        True if no failures.
  443.      *    @access public
  444.      */
  445.     function getStatus() {
  446.         return $this->reporter->getStatus();
  447.     }
  448.  
  449.     /**
  450.      *    The nesting of the test cases so far. Not
  451.      *    all reporters have this facility.
  452.      *    @return array        Test list if accessible.
  453.      *    @access public
  454.      */
  455.     function getTestList() {
  456.         if (method_exists($this->reporter, 'getTestList')) {
  457.             return $this->reporter->getTestList();
  458.         } else {
  459.             return array();
  460.         }
  461.     }
  462.  
  463.     /**
  464.      *    The reporter has a veto on what should be run.
  465.      *    @param string $test_case_name  Name of test case.
  466.      *    @param string $method          Name of test method.
  467.      *    @return boolean                True if test should be run.
  468.      *    @access public
  469.      */
  470.     function shouldInvoke($test_case_name, $method) {
  471.         return $this->reporter->shouldInvoke($test_case_name, $method);
  472.     }
  473.  
  474.     /**
  475.      *    Can wrap the invoker in preparation for running
  476.      *    a test.
  477.      *    @param SimpleInvoker $invoker   Individual test runner.
  478.      *    @return SimpleInvoker           Wrapped test runner.
  479.      *    @access public
  480.      */
  481.     function createInvoker($invoker) {
  482.         return $this->reporter->createInvoker($invoker);
  483.     }
  484.     
  485.     /**
  486.      *    Gets the formatter for privateiables and other small
  487.      *    generic data items.
  488.      *    @return SimpleDumper          Formatter.
  489.      *    @access public
  490.      */
  491.     function getDumper() {
  492.         return $this->reporter->getDumper();
  493.     }
  494.  
  495.     /**
  496.      *    Paints the start of a group test.
  497.      *    @param string $test_name     Name of test or other label.
  498.      *    @param integer $size         Number of test cases starting.
  499.      *    @access public
  500.      */
  501.     function paintGroupStart($test_name, $size) {
  502.         $this->reporter->paintGroupStart($test_name, $size);
  503.     }
  504.  
  505.     /**
  506.      *    Paints the end of a group test.
  507.      *    @param string $test_name     Name of test or other label.
  508.      *    @access public
  509.      */
  510.     function paintGroupEnd($test_name) {
  511.         $this->reporter->paintGroupEnd($test_name);
  512.     }
  513.  
  514.     /**
  515.      *    Paints the start of a test case.
  516.      *    @param string $test_name     Name of test or other label.
  517.      *    @access public
  518.      */
  519.     function paintCaseStart($test_name) {
  520.         $this->reporter->paintCaseStart($test_name);
  521.     }
  522.  
  523.     /**
  524.      *    Paints the end of a test case.
  525.      *    @param string $test_name     Name of test or other label.
  526.      *    @access public
  527.      */
  528.     function paintCaseEnd($test_name) {
  529.         $this->reporter->paintCaseEnd($test_name);
  530.     }
  531.  
  532.     /**
  533.      *    Paints the start of a test method.
  534.      *    @param string $test_name     Name of test or other label.
  535.      *    @access public
  536.      */
  537.     function paintMethodStart($test_name) {
  538.         $this->reporter->paintMethodStart($test_name);
  539.     }
  540.  
  541.     /**
  542.      *    Paints the end of a test method.
  543.      *    @param string $test_name     Name of test or other label.
  544.      *    @access public
  545.      */
  546.     function paintMethodEnd($test_name) {
  547.         $this->reporter->paintMethodEnd($test_name);
  548.     }
  549.  
  550.     /**
  551.      *    Chains to the wrapped reporter.
  552.      *    @param string $message        Message is ignored.
  553.      *    @access public
  554.      */
  555.     function paintPass($message) {
  556.         $this->reporter->paintPass($message);
  557.     }
  558.  
  559.     /**
  560.      *    Chains to the wrapped reporter.
  561.      *    @param string $message        Message is ignored.
  562.      *    @access public
  563.      */
  564.     function paintFail($message) {
  565.         $this->reporter->paintFail($message);
  566.     }
  567.  
  568.     /**
  569.      *    Chains to the wrapped reporter.
  570.      *    @param string $message    Text of error formatted by
  571.      *                               the test case.
  572.      *    @access public
  573.      */
  574.     function paintError($message) {
  575.         $this->reporter->paintError($message);
  576.     }
  577.  
  578.     /**
  579.      *    Chains to the wrapped reporter.
  580.      *    @param Exception $exception        Exception to show.
  581.      *    @access public
  582.      */
  583.     function paintException($exception) {
  584.         $this->reporter->paintException($exception);
  585.     }
  586.     
  587.     /**
  588.      *    Prints the message for skipping tests.
  589.      *    @param string $message    Text of skip condition.
  590.      *    @access public
  591.      */
  592.     function paintSkip($message) {
  593.         $this->reporter->paintSkip($message);
  594.     }
  595.  
  596.     /**
  597.      *    Chains to the wrapped reporter.
  598.      *    @param string $message        Text to display.
  599.      *    @access public
  600.      */
  601.     function paintMessage($message) {
  602.         $this->reporter->paintMessage($message);
  603.     }
  604.  
  605.     /**
  606.      *    Chains to the wrapped reporter.
  607.      *    @param string $message        Text to display.
  608.      *    @access public
  609.      */
  610.     function paintFormattedMessage($message) {
  611.         $this->reporter->paintFormattedMessage($message);
  612.     }
  613.  
  614.     /**
  615.      *    Chains to the wrapped reporter.
  616.      *    @param string $type        Event type as text.
  617.      *    @param mixed $payload      Message or object.
  618.      *    @return boolean            Should return false if this
  619.      *                                type of signal should fail the
  620.      *                                test suite.
  621.      *    @access public
  622.      */
  623.     function paintSignal($type, $payload) {
  624.         $this->reporter->paintSignal($type, $payload);
  625.     }
  626. }
  627.  
  628. /**
  629.  *    For sending messages to multiple reporters at
  630.  *    the same time.
  631.  *    @package SimpleTest
  632.  *    @subpackage UnitTester
  633.  */
  634. class MultipleReporter {
  635.     private $reporters = array();
  636.  
  637.     /**
  638.      *    Adds a reporter to the subscriber list.
  639.      *    @param SimpleScorer $reporter     Reporter to receive events.
  640.      *    @access public
  641.      */
  642.     function attachReporter($reporter) {
  643.         $this->reporters[] = $reporter;
  644.     }
  645.  
  646.     /**
  647.      *    Signals that the next evaluation will be a dry
  648.      *    run. That is, the structure events will be
  649.      *    recorded, but no tests will be run.
  650.      *    @param boolean $is_dry        Dry run if true.
  651.      *    @access public
  652.      */
  653.     function makeDry($is_dry = true) {
  654.         for ($i = 0; $i < count($this->reporters); $i++) {
  655.             $this->reporters[$i]->makeDry($is_dry);
  656.         }
  657.     }
  658.  
  659.     /**
  660.      *    Accessor for current status. Will be false
  661.      *    if there have been any failures or exceptions.
  662.      *    If any reporter reports a failure, the whole
  663.      *    suite fails.
  664.      *    @return boolean        True if no failures.
  665.      *    @access public
  666.      */
  667.     function getStatus() {
  668.         for ($i = 0; $i < count($this->reporters); $i++) {
  669.             if (! $this->reporters[$i]->getStatus()) {
  670.                 return false;
  671.             }
  672.         }
  673.         return true;
  674.     }
  675.  
  676.     /**
  677.      *    The reporter has a veto on what should be run.
  678.      *    It requires all reporters to want to run the method.
  679.      *    @param string $test_case_name  name of test case.
  680.      *    @param string $method          Name of test method.
  681.      *    @access public
  682.      */
  683.     function shouldInvoke($test_case_name, $method) {
  684.         for ($i = 0; $i < count($this->reporters); $i++) {
  685.             if (! $this->reporters[$i]->shouldInvoke($test_case_name, $method)) {
  686.                 return false;
  687.             }
  688.         }
  689.         return true;
  690.     }
  691.  
  692.     /**
  693.      *    Every reporter gets a chance to wrap the invoker.
  694.      *    @param SimpleInvoker $invoker   Individual test runner.
  695.      *    @return SimpleInvoker           Wrapped test runner.
  696.      *    @access public
  697.      */
  698.     function createInvoker($invoker) {
  699.         for ($i = 0; $i < count($this->reporters); $i++) {
  700.             $invoker = $this->reporters[$i]->createInvoker($invoker);
  701.         }
  702.         return $invoker;
  703.     }
  704.     
  705.     /**
  706.      *    Gets the formatter for privateiables and other small
  707.      *    generic data items.
  708.      *    @return SimpleDumper          Formatter.
  709.      *    @access public
  710.      */
  711.     function getDumper() {
  712.         return new SimpleDumper();
  713.     }
  714.  
  715.     /**
  716.      *    Paints the start of a group test.
  717.      *    @param string $test_name     Name of test or other label.
  718.      *    @param integer $size         Number of test cases starting.
  719.      *    @access public
  720.      */
  721.     function paintGroupStart($test_name, $size) {
  722.         for ($i = 0; $i < count($this->reporters); $i++) {
  723.             $this->reporters[$i]->paintGroupStart($test_name, $size);
  724.         }
  725.     }
  726.  
  727.     /**
  728.      *    Paints the end of a group test.
  729.      *    @param string $test_name     Name of test or other label.
  730.      *    @access public
  731.      */
  732.     function paintGroupEnd($test_name) {
  733.         for ($i = 0; $i < count($this->reporters); $i++) {
  734.             $this->reporters[$i]->paintGroupEnd($test_name);
  735.         }
  736.     }
  737.  
  738.     /**
  739.      *    Paints the start of a test case.
  740.      *    @param string $test_name     Name of test or other label.
  741.      *    @access public
  742.      */
  743.     function paintCaseStart($test_name) {
  744.         for ($i = 0; $i < count($this->reporters); $i++) {
  745.             $this->reporters[$i]->paintCaseStart($test_name);
  746.         }
  747.     }
  748.  
  749.     /**
  750.      *    Paints the end of a test case.
  751.      *    @param string $test_name     Name of test or other label.
  752.      *    @access public
  753.      */
  754.     function paintCaseEnd($test_name) {
  755.         for ($i = 0; $i < count($this->reporters); $i++) {
  756.             $this->reporters[$i]->paintCaseEnd($test_name);
  757.         }
  758.     }
  759.  
  760.     /**
  761.      *    Paints the start of a test method.
  762.      *    @param string $test_name     Name of test or other label.
  763.      *    @access public
  764.      */
  765.     function paintMethodStart($test_name) {
  766.         for ($i = 0; $i < count($this->reporters); $i++) {
  767.             $this->reporters[$i]->paintMethodStart($test_name);
  768.         }
  769.     }
  770.  
  771.     /**
  772.      *    Paints the end of a test method.
  773.      *    @param string $test_name     Name of test or other label.
  774.      *    @access public
  775.      */
  776.     function paintMethodEnd($test_name) {
  777.         for ($i = 0; $i < count($this->reporters); $i++) {
  778.             $this->reporters[$i]->paintMethodEnd($test_name);
  779.         }
  780.     }
  781.  
  782.     /**
  783.      *    Chains to the wrapped reporter.
  784.      *    @param string $message        Message is ignored.
  785.      *    @access public
  786.      */
  787.     function paintPass($message) {
  788.         for ($i = 0; $i < count($this->reporters); $i++) {
  789.             $this->reporters[$i]->paintPass($message);
  790.         }
  791.     }
  792.  
  793.     /**
  794.      *    Chains to the wrapped reporter.
  795.      *    @param string $message        Message is ignored.
  796.      *    @access public
  797.      */
  798.     function paintFail($message) {
  799.         for ($i = 0; $i < count($this->reporters); $i++) {
  800.             $this->reporters[$i]->paintFail($message);
  801.         }
  802.     }
  803.  
  804.     /**
  805.      *    Chains to the wrapped reporter.
  806.      *    @param string $message    Text of error formatted by
  807.      *                               the test case.
  808.      *    @access public
  809.      */
  810.     function paintError($message) {
  811.         for ($i = 0; $i < count($this->reporters); $i++) {
  812.             $this->reporters[$i]->paintError($message);
  813.         }
  814.     }
  815.     
  816.     /**
  817.      *    Chains to the wrapped reporter.
  818.      *    @param Exception $exception    Exception to display.
  819.      *    @access public
  820.      */
  821.     function paintException($exception) {
  822.         for ($i = 0; $i < count($this->reporters); $i++) {
  823.             $this->reporters[$i]->paintException($exception);
  824.         }
  825.     }
  826.  
  827.     /**
  828.      *    Prints the message for skipping tests.
  829.      *    @param string $message    Text of skip condition.
  830.      *    @access public
  831.      */
  832.     function paintSkip($message) {
  833.         for ($i = 0; $i < count($this->reporters); $i++) {
  834.             $this->reporters[$i]->paintSkip($message);
  835.         }
  836.     }
  837.  
  838.     /**
  839.      *    Chains to the wrapped reporter.
  840.      *    @param string $message        Text to display.
  841.      *    @access public
  842.      */
  843.     function paintMessage($message) {
  844.         for ($i = 0; $i < count($this->reporters); $i++) {
  845.             $this->reporters[$i]->paintMessage($message);
  846.         }
  847.     }
  848.  
  849.     /**
  850.      *    Chains to the wrapped reporter.
  851.      *    @param string $message        Text to display.
  852.      *    @access public
  853.      */
  854.     function paintFormattedMessage($message) {
  855.         for ($i = 0; $i < count($this->reporters); $i++) {
  856.             $this->reporters[$i]->paintFormattedMessage($message);
  857.         }
  858.     }
  859.  
  860.     /**
  861.      *    Chains to the wrapped reporter.
  862.      *    @param string $type        Event type as text.
  863.      *    @param mixed $payload      Message or object.
  864.      *    @return boolean            Should return false if this
  865.      *                                type of signal should fail the
  866.      *                                test suite.
  867.      *    @access public
  868.      */
  869.     function paintSignal($type, $payload) {
  870.         for ($i = 0; $i < count($this->reporters); $i++) {
  871.             $this->reporters[$i]->paintSignal($type, $payload);
  872.         }
  873.     }
  874. }
  875. ?>

Documentation generated on Sun, 31 Oct 2010 16:32:17 -0500 by phpDocumentor 1.4.3