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 1788 2008-04-27 11:01:59Z pp11 $
  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 privateiables and other small
  259.      *    generic data items.
  260.      *    @return SimpleDumper          Formatter.
  261.      *    @access public
  262.      */
  263.     function getDumper() {
  264.         return new SimpleDumper();
  265.     }
  266.  
  267.     /**
  268.      *    Paints the start of a group test. Will also paint
  269.      *    the page header and footer if this is the
  270.      *    first test. Will stash the size if the first
  271.      *    start.
  272.      *    @param string $test_name   Name of test that is starting.
  273.      *    @param integer $size       Number of test cases starting.
  274.      *    @access public
  275.      */
  276.     function paintGroupStart($test_name, $size) {
  277.         if (! isset($this->size)) {
  278.             $this->size = $size;
  279.         }
  280.         if (count($this->test_stack) == 0) {
  281.             $this->paintHeader($test_name);
  282.         }
  283.         $this->test_stack[] = $test_name;
  284.     }
  285.  
  286.     /**
  287.      *    Paints the end of a group test. Will paint the page
  288.      *    footer if the stack of tests has unwound.
  289.      *    @param string $test_name   Name of test that is ending.
  290.      *    @param integer $progress   Number of test cases ending.
  291.      *    @access public
  292.      */
  293.     function paintGroupEnd($test_name) {
  294.         array_pop($this->test_stack);
  295.         if (count($this->test_stack) == 0) {
  296.             $this->paintFooter($test_name);
  297.         }
  298.     }
  299.  
  300.     /**
  301.      *    Paints the start of a test case. Will also paint
  302.      *    the page header and footer if this is the
  303.      *    first test. Will stash the size if the first
  304.      *    start.
  305.      *    @param string $test_name   Name of test that is starting.
  306.      *    @access public
  307.      */
  308.     function paintCaseStart($test_name) {
  309.         if (! isset($this->size)) {
  310.             $this->size = 1;
  311.         }
  312.         if (count($this->test_stack) == 0) {
  313.             $this->paintHeader($test_name);
  314.         }
  315.         $this->test_stack[] = $test_name;
  316.     }
  317.  
  318.     /**
  319.      *    Paints the end of a test case. Will paint the page
  320.      *    footer if the stack of tests has unwound.
  321.      *    @param string $test_name   Name of test that is ending.
  322.      *    @access public
  323.      */
  324.     function paintCaseEnd($test_name) {
  325.         $this->progress++;
  326.         array_pop($this->test_stack);
  327.         if (count($this->test_stack) == 0) {
  328.             $this->paintFooter($test_name);
  329.         }
  330.     }
  331.  
  332.     /**
  333.      *    Paints the start of a test method.
  334.      *    @param string $test_name   Name of test that is starting.
  335.      *    @access public
  336.      */
  337.     function paintMethodStart($test_name) {
  338.         $this->test_stack[] = $test_name;
  339.     }
  340.  
  341.     /**
  342.      *    Paints the end of a test method. Will paint the page
  343.      *    footer if the stack of tests has unwound.
  344.      *    @param string $test_name   Name of test that is ending.
  345.      *    @access public
  346.      */
  347.     function paintMethodEnd($test_name) {
  348.         array_pop($this->test_stack);
  349.     }
  350.  
  351.     /**
  352.      *    Paints the test document header.
  353.      *    @param string $test_name     First test top level
  354.      *                                  to start.
  355.      *    @access public
  356.      *    @abstract
  357.      */
  358.     function paintHeader($test_name) {
  359.     }
  360.  
  361.     /**
  362.      *    Paints the test document footer.
  363.      *    @param string $test_name        The top level test.
  364.      *    @access public
  365.      *    @abstract
  366.      */
  367.     function paintFooter($test_name) {
  368.     }
  369.  
  370.     /**
  371.      *    Accessor for internal test stack. For
  372.      *    subclasses that need to see the whole test
  373.      *    history for display purposes.
  374.      *    @return array     List of methods in nesting order.
  375.      *    @access public
  376.      */
  377.     function getTestList() {
  378.         return $this->test_stack;
  379.     }
  380.  
  381.     /**
  382.      *    Accessor for total test size in number
  383.      *    of test cases. Null until the first
  384.      *    test is started.
  385.      *    @return integer   Total number of cases at start.
  386.      *    @access public
  387.      */
  388.     function getTestCaseCount() {
  389.         return $this->size;
  390.     }
  391.  
  392.     /**
  393.      *    Accessor for the number of test cases
  394.      *    completed so far.
  395.      *    @return integer   Number of ended cases.
  396.      *    @access public
  397.      */
  398.     function getTestCaseProgress() {
  399.         return $this->progress;
  400.     }
  401.  
  402.     /**
  403.      *    Static check for running in the comand line.
  404.      *    @return boolean        True if CLI.
  405.      *    @access public
  406.      */
  407.     static function inCli() {
  408.         return php_sapi_name() == 'cli';
  409.     }
  410. }
  411.  
  412. /**
  413.  *    For modifying the behaviour of the visual reporters.
  414.  *    @package SimpleTest
  415.  *    @subpackage UnitTester
  416.  */
  417. class SimpleReporterDecorator {
  418.     protected $reporter;
  419.  
  420.     /**
  421.      *    Mediates between the reporter and the test case.
  422.      *    @param SimpleScorer $reporter       Reporter to receive events.
  423.      */
  424.     function __construct($reporter) {
  425.         $this->reporter = $reporter;
  426.     }
  427.  
  428.     /**
  429.      *    Signals that the next evaluation will be a dry
  430.      *    run. That is, the structure events will be
  431.      *    recorded, but no tests will be run.
  432.      *    @param boolean $is_dry        Dry run if true.
  433.      *    @access public
  434.      */
  435.     function makeDry($is_dry = true) {
  436.         $this->reporter->makeDry($is_dry);
  437.     }
  438.  
  439.     /**
  440.      *    Accessor for current status. Will be false
  441.      *    if there have been any failures or exceptions.
  442.      *    Used for command line tools.
  443.      *    @return boolean        True if no failures.
  444.      *    @access public
  445.      */
  446.     function getStatus() {
  447.         return $this->reporter->getStatus();
  448.     }
  449.  
  450.     /**
  451.      *    The reporter has a veto on what should be run.
  452.      *    @param string $test_case_name  name of test case.
  453.      *    @param string $method          Name of test method.
  454.      *    @return boolean                True if test should be run.
  455.      *    @access public
  456.      */
  457.     function shouldInvoke($test_case_name, $method) {
  458.         return $this->reporter->shouldInvoke($test_case_name, $method);
  459.     }
  460.  
  461.     /**
  462.      *    Can wrap the invoker in preperation for running
  463.      *    a test.
  464.      *    @param SimpleInvoker $invoker   Individual test runner.
  465.      *    @return SimpleInvoker           Wrapped test runner.
  466.      *    @access public
  467.      */
  468.     function createInvoker($invoker) {
  469.         return $this->reporter->createInvoker($invoker);
  470.     }
  471.     
  472.     /**
  473.      *    Gets the formatter for privateiables and other small
  474.      *    generic data items.
  475.      *    @return SimpleDumper          Formatter.
  476.      *    @access public
  477.      */
  478.     function getDumper() {
  479.         return $this->reporter->getDumper();
  480.     }
  481.  
  482.     /**
  483.      *    Paints the start of a group test.
  484.      *    @param string $test_name     Name of test or other label.
  485.      *    @param integer $size         Number of test cases starting.
  486.      *    @access public
  487.      */
  488.     function paintGroupStart($test_name, $size) {
  489.         $this->reporter->paintGroupStart($test_name, $size);
  490.     }
  491.  
  492.     /**
  493.      *    Paints the end of a group test.
  494.      *    @param string $test_name     Name of test or other label.
  495.      *    @access public
  496.      */
  497.     function paintGroupEnd($test_name) {
  498.         $this->reporter->paintGroupEnd($test_name);
  499.     }
  500.  
  501.     /**
  502.      *    Paints the start of a test case.
  503.      *    @param string $test_name     Name of test or other label.
  504.      *    @access public
  505.      */
  506.     function paintCaseStart($test_name) {
  507.         $this->reporter->paintCaseStart($test_name);
  508.     }
  509.  
  510.     /**
  511.      *    Paints the end of a test case.
  512.      *    @param string $test_name     Name of test or other label.
  513.      *    @access public
  514.      */
  515.     function paintCaseEnd($test_name) {
  516.         $this->reporter->paintCaseEnd($test_name);
  517.     }
  518.  
  519.     /**
  520.      *    Paints the start of a test method.
  521.      *    @param string $test_name     Name of test or other label.
  522.      *    @access public
  523.      */
  524.     function paintMethodStart($test_name) {
  525.         $this->reporter->paintMethodStart($test_name);
  526.     }
  527.  
  528.     /**
  529.      *    Paints the end of a test method.
  530.      *    @param string $test_name     Name of test or other label.
  531.      *    @access public
  532.      */
  533.     function paintMethodEnd($test_name) {
  534.         $this->reporter->paintMethodEnd($test_name);
  535.     }
  536.  
  537.     /**
  538.      *    Chains to the wrapped reporter.
  539.      *    @param string $message        Message is ignored.
  540.      *    @access public
  541.      */
  542.     function paintPass($message) {
  543.         $this->reporter->paintPass($message);
  544.     }
  545.  
  546.     /**
  547.      *    Chains to the wrapped reporter.
  548.      *    @param string $message        Message is ignored.
  549.      *    @access public
  550.      */
  551.     function paintFail($message) {
  552.         $this->reporter->paintFail($message);
  553.     }
  554.  
  555.     /**
  556.      *    Chains to the wrapped reporter.
  557.      *    @param string $message    Text of error formatted by
  558.      *                               the test case.
  559.      *    @access public
  560.      */
  561.     function paintError($message) {
  562.         $this->reporter->paintError($message);
  563.     }
  564.  
  565.     /**
  566.      *    Chains to the wrapped reporter.
  567.      *    @param Exception $exception        Exception to show.
  568.      *    @access public
  569.      */
  570.     function paintException($exception) {
  571.         $this->reporter->paintException($exception);
  572.     }
  573.     
  574.     /**
  575.      *    Prints the message for skipping tests.
  576.      *    @param string $message    Text of skip condition.
  577.      *    @access public
  578.      */
  579.     function paintSkip($message) {
  580.         $this->reporter->paintSkip($message);
  581.     }
  582.  
  583.     /**
  584.      *    Chains to the wrapped reporter.
  585.      *    @param string $message        Text to display.
  586.      *    @access public
  587.      */
  588.     function paintMessage($message) {
  589.         $this->reporter->paintMessage($message);
  590.     }
  591.  
  592.     /**
  593.      *    Chains to the wrapped reporter.
  594.      *    @param string $message        Text to display.
  595.      *    @access public
  596.      */
  597.     function paintFormattedMessage($message) {
  598.         $this->reporter->paintFormattedMessage($message);
  599.     }
  600.  
  601.     /**
  602.      *    Chains to the wrapped reporter.
  603.      *    @param string $type        Event type as text.
  604.      *    @param mixed $payload      Message or object.
  605.      *    @return boolean            Should return false if this
  606.      *                                type of signal should fail the
  607.      *                                test suite.
  608.      *    @access public
  609.      */
  610.     function paintSignal($type, $payload) {
  611.         $this->reporter->paintSignal($type, $payload);
  612.     }
  613. }
  614.  
  615. /**
  616.  *    For sending messages to multiple reporters at
  617.  *    the same time.
  618.  *    @package SimpleTest
  619.  *    @subpackage UnitTester
  620.  */
  621. class MultipleReporter {
  622.     private $reporters = array();
  623.  
  624.     /**
  625.      *    Adds a reporter to the subscriber list.
  626.      *    @param SimpleScorer $reporter     Reporter to receive events.
  627.      *    @access public
  628.      */
  629.     function attachReporter($reporter) {
  630.         $this->reporters[] = $reporter;
  631.     }
  632.  
  633.     /**
  634.      *    Signals that the next evaluation will be a dry
  635.      *    run. That is, the structure events will be
  636.      *    recorded, but no tests will be run.
  637.      *    @param boolean $is_dry        Dry run if true.
  638.      *    @access public
  639.      */
  640.     function makeDry($is_dry = true) {
  641.         for ($i = 0; $i < count($this->reporters); $i++) {
  642.             $this->reporters[$i]->makeDry($is_dry);
  643.         }
  644.     }
  645.  
  646.     /**
  647.      *    Accessor for current status. Will be false
  648.      *    if there have been any failures or exceptions.
  649.      *    If any reporter reports a failure, the whole
  650.      *    suite fails.
  651.      *    @return boolean        True if no failures.
  652.      *    @access public
  653.      */
  654.     function getStatus() {
  655.         for ($i = 0; $i < count($this->reporters); $i++) {
  656.             if (! $this->reporters[$i]->getStatus()) {
  657.                 return false;
  658.             }
  659.         }
  660.         return true;
  661.     }
  662.  
  663.     /**
  664.      *    The reporter has a veto on what should be run.
  665.      *    It requires all reporters to want to run the method.
  666.      *    @param string $test_case_name  name of test case.
  667.      *    @param string $method          Name of test method.
  668.      *    @access public
  669.      */
  670.     function shouldInvoke($test_case_name, $method) {
  671.         for ($i = 0; $i < count($this->reporters); $i++) {
  672.             if (! $this->reporters[$i]->shouldInvoke($test_case_name, $method)) {
  673.                 return false;
  674.             }
  675.         }
  676.         return true;
  677.     }
  678.  
  679.     /**
  680.      *    Every reporter gets a chance to wrap the invoker.
  681.      *    @param SimpleInvoker $invoker   Individual test runner.
  682.      *    @return SimpleInvoker           Wrapped test runner.
  683.      *    @access public
  684.      */
  685.     function createInvoker($invoker) {
  686.         for ($i = 0; $i < count($this->reporters); $i++) {
  687.             $invoker = $this->reporters[$i]->createInvoker($invoker);
  688.         }
  689.         return $invoker;
  690.     }
  691.     
  692.     /**
  693.      *    Gets the formatter for privateiables and other small
  694.      *    generic data items.
  695.      *    @return SimpleDumper          Formatter.
  696.      *    @access public
  697.      */
  698.     function getDumper() {
  699.         return new SimpleDumper();
  700.     }
  701.  
  702.     /**
  703.      *    Paints the start of a group test.
  704.      *    @param string $test_name     Name of test or other label.
  705.      *    @param integer $size         Number of test cases starting.
  706.      *    @access public
  707.      */
  708.     function paintGroupStart($test_name, $size) {
  709.         for ($i = 0; $i < count($this->reporters); $i++) {
  710.             $this->reporters[$i]->paintGroupStart($test_name, $size);
  711.         }
  712.     }
  713.  
  714.     /**
  715.      *    Paints the end of a group test.
  716.      *    @param string $test_name     Name of test or other label.
  717.      *    @access public
  718.      */
  719.     function paintGroupEnd($test_name) {
  720.         for ($i = 0; $i < count($this->reporters); $i++) {
  721.             $this->reporters[$i]->paintGroupEnd($test_name);
  722.         }
  723.     }
  724.  
  725.     /**
  726.      *    Paints the start of a test case.
  727.      *    @param string $test_name     Name of test or other label.
  728.      *    @access public
  729.      */
  730.     function paintCaseStart($test_name) {
  731.         for ($i = 0; $i < count($this->reporters); $i++) {
  732.             $this->reporters[$i]->paintCaseStart($test_name);
  733.         }
  734.     }
  735.  
  736.     /**
  737.      *    Paints the end of a test case.
  738.      *    @param string $test_name     Name of test or other label.
  739.      *    @access public
  740.      */
  741.     function paintCaseEnd($test_name) {
  742.         for ($i = 0; $i < count($this->reporters); $i++) {
  743.             $this->reporters[$i]->paintCaseEnd($test_name);
  744.         }
  745.     }
  746.  
  747.     /**
  748.      *    Paints the start of a test method.
  749.      *    @param string $test_name     Name of test or other label.
  750.      *    @access public
  751.      */
  752.     function paintMethodStart($test_name) {
  753.         for ($i = 0; $i < count($this->reporters); $i++) {
  754.             $this->reporters[$i]->paintMethodStart($test_name);
  755.         }
  756.     }
  757.  
  758.     /**
  759.      *    Paints the end of a test method.
  760.      *    @param string $test_name     Name of test or other label.
  761.      *    @access public
  762.      */
  763.     function paintMethodEnd($test_name) {
  764.         for ($i = 0; $i < count($this->reporters); $i++) {
  765.             $this->reporters[$i]->paintMethodEnd($test_name);
  766.         }
  767.     }
  768.  
  769.     /**
  770.      *    Chains to the wrapped reporter.
  771.      *    @param string $message        Message is ignored.
  772.      *    @access public
  773.      */
  774.     function paintPass($message) {
  775.         for ($i = 0; $i < count($this->reporters); $i++) {
  776.             $this->reporters[$i]->paintPass($message);
  777.         }
  778.     }
  779.  
  780.     /**
  781.      *    Chains to the wrapped reporter.
  782.      *    @param string $message        Message is ignored.
  783.      *    @access public
  784.      */
  785.     function paintFail($message) {
  786.         for ($i = 0; $i < count($this->reporters); $i++) {
  787.             $this->reporters[$i]->paintFail($message);
  788.         }
  789.     }
  790.  
  791.     /**
  792.      *    Chains to the wrapped reporter.
  793.      *    @param string $message    Text of error formatted by
  794.      *                               the test case.
  795.      *    @access public
  796.      */
  797.     function paintError($message) {
  798.         for ($i = 0; $i < count($this->reporters); $i++) {
  799.             $this->reporters[$i]->paintError($message);
  800.         }
  801.     }
  802.     
  803.     /**
  804.      *    Chains to the wrapped reporter.
  805.      *    @param Exception $exception    Exception to display.
  806.      *    @access public
  807.      */
  808.     function paintException($exception) {
  809.         for ($i = 0; $i < count($this->reporters); $i++) {
  810.             $this->reporters[$i]->paintException($exception);
  811.         }
  812.     }
  813.  
  814.     /**
  815.      *    Prints the message for skipping tests.
  816.      *    @param string $message    Text of skip condition.
  817.      *    @access public
  818.      */
  819.     function paintSkip($message) {
  820.         for ($i = 0; $i < count($this->reporters); $i++) {
  821.             $this->reporters[$i]->paintSkip($message);
  822.         }
  823.     }
  824.  
  825.     /**
  826.      *    Chains to the wrapped reporter.
  827.      *    @param string $message        Text to display.
  828.      *    @access public
  829.      */
  830.     function paintMessage($message) {
  831.         for ($i = 0; $i < count($this->reporters); $i++) {
  832.             $this->reporters[$i]->paintMessage($message);
  833.         }
  834.     }
  835.  
  836.     /**
  837.      *    Chains to the wrapped reporter.
  838.      *    @param string $message        Text to display.
  839.      *    @access public
  840.      */
  841.     function paintFormattedMessage($message) {
  842.         for ($i = 0; $i < count($this->reporters); $i++) {
  843.             $this->reporters[$i]->paintFormattedMessage($message);
  844.         }
  845.     }
  846.  
  847.     /**
  848.      *    Chains to the wrapped reporter.
  849.      *    @param string $type        Event type as text.
  850.      *    @param mixed $payload      Message or object.
  851.      *    @return boolean            Should return false if this
  852.      *                                type of signal should fail the
  853.      *                                test suite.
  854.      *    @access public
  855.      */
  856.     function paintSignal($type, $payload) {
  857.         for ($i = 0; $i < count($this->reporters); $i++) {
  858.             $this->reporters[$i]->paintSignal($type, $payload);
  859.         }
  860.     }
  861. }
  862. ?>

Documentation generated on Thu, 01 Oct 2009 20:55:43 -0500 by phpDocumentor 1.4.2