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 1723 2008-04-08 00:34:10Z lastcraft $
  7.  */
  8.  
  9. /**#@+*/
  10. require_once(dirname(__FILE__) . '/invoker.php');
  11. /**#@-*/
  12.  
  13.  *    Can receive test events and display them. Display
  14.  *    is achieved by making display methods available
  15.  *    and visiting the incoming event.
  16.  *    @package SimpleTest
  17.  *    @subpackage UnitTester
  18.  *    @abstract
  19.  */
  20. class SimpleScorer {
  21.     var $_passes;
  22.     var $_fails;
  23.     var $_exceptions;
  24.     var $_is_dry_run;
  25.  
  26.     /**
  27.      *    Starts the test run with no results.
  28.      *    @access public
  29.      */
  30.     function SimpleScorer() {
  31.         $this->_passes = 0;
  32.         $this->_fails = 0;
  33.         $this->_exceptions = 0;
  34.         $this->_is_dry_run = false;
  35.     }
  36.  
  37.     /**
  38.      *    Signals that the next evaluation will be a dry
  39.      *    run. That is, the structure events will be
  40.      *    recorded, but no tests will be run.
  41.      *    @param boolean $is_dry        Dry run if true.
  42.      *    @access public
  43.      */
  44.     function makeDry($is_dry = true) {
  45.         $this->_is_dry_run = $is_dry;
  46.     }
  47.  
  48.     /**
  49.      *    The reporter has a veto on what should be run.
  50.      *    @param string $test_case_name  name of test case.
  51.      *    @param string $method          Name of test method.
  52.      *    @access public
  53.      */
  54.     function shouldInvoke($test_case_name, $method) {
  55.         return ! $this->_is_dry_run;
  56.     }
  57.  
  58.     /**
  59.      *    Can wrap the invoker in preperation for running
  60.      *    a test.
  61.      *    @param SimpleInvoker $invoker   Individual test runner.
  62.      *    @return SimpleInvoker           Wrapped test runner.
  63.      *    @access public
  64.      */
  65.     function &createInvoker(&$invoker) {
  66.         return $invoker;
  67.     }
  68.  
  69.     /**
  70.      *    Accessor for current status. Will be false
  71.      *    if there have been any failures or exceptions.
  72.      *    Used for command line tools.
  73.      *    @return boolean        True if no failures.
  74.      *    @access public
  75.      */
  76.     function getStatus() {
  77.         if ($this->_exceptions + $this->_fails > 0) {
  78.             return false;
  79.         }
  80.         return true;
  81.     }
  82.  
  83.     /**
  84.      *    Paints the start of a group test.
  85.      *    @param string $test_name     Name of test or other label.
  86.      *    @param integer $size         Number of test cases starting.
  87.      *    @access public
  88.      */
  89.     function paintGroupStart($test_name, $size) {
  90.     }
  91.  
  92.     /**
  93.      *    Paints the end of a group test.
  94.      *    @param string $test_name     Name of test or other label.
  95.      *    @access public
  96.      */
  97.     function paintGroupEnd($test_name) {
  98.     }
  99.  
  100.     /**
  101.      *    Paints the start of a test case.
  102.      *    @param string $test_name     Name of test or other label.
  103.      *    @access public
  104.      */
  105.     function paintCaseStart($test_name) {
  106.     }
  107.  
  108.     /**
  109.      *    Paints the end of a test case.
  110.      *    @param string $test_name     Name of test or other label.
  111.      *    @access public
  112.      */
  113.     function paintCaseEnd($test_name) {
  114.     }
  115.  
  116.     /**
  117.      *    Paints the start of a test method.
  118.      *    @param string $test_name     Name of test or other label.
  119.      *    @access public
  120.      */
  121.     function paintMethodStart($test_name) {
  122.     }
  123.  
  124.     /**
  125.      *    Paints the end of a test method.
  126.      *    @param string $test_name     Name of test or other label.
  127.      *    @access public
  128.      */
  129.     function paintMethodEnd($test_name) {
  130.     }
  131.  
  132.     /**
  133.      *    Increments the pass count.
  134.      *    @param string $message        Message is ignored.
  135.      *    @access public
  136.      */
  137.     function paintPass($message) {
  138.         $this->_passes++;
  139.     }
  140.  
  141.     /**
  142.      *    Increments the fail count.
  143.      *    @param string $message        Message is ignored.
  144.      *    @access public
  145.      */
  146.     function paintFail($message) {
  147.         $this->_fails++;
  148.     }
  149.  
  150.     /**
  151.      *    Deals with PHP 4 throwing an error.
  152.      *    @param string $message    Text of error formatted by
  153.      *                               the test case.
  154.      *    @access public
  155.      */
  156.     function paintError($message) {
  157.         $this->_exceptions++;
  158.     }
  159.  
  160.     /**
  161.      *    Deals with PHP 5 throwing an exception.
  162.      *    @param Exception $exception    The actual exception thrown.
  163.      *    @access public
  164.      */
  165.     function paintException($exception) {
  166.         $this->_exceptions++;
  167.     }
  168.     
  169.     /**
  170.      *    Prints the message for skipping tests.
  171.      *    @param string $message    Text of skip condition.
  172.      *    @access public
  173.      */
  174.     function paintSkip($message) {
  175.     }
  176.  
  177.     /**
  178.      *    Accessor for the number of passes so far.
  179.      *    @return integer       Number of passes.
  180.      *    @access public
  181.      */
  182.     function getPassCount() {
  183.         return $this->_passes;
  184.     }
  185.  
  186.     /**
  187.      *    Accessor for the number of fails so far.
  188.      *    @return integer       Number of fails.
  189.      *    @access public
  190.      */
  191.     function getFailCount() {
  192.         return $this->_fails;
  193.     }
  194.  
  195.     /**
  196.      *    Accessor for the number of untrapped errors
  197.      *    so far.
  198.      *    @return integer       Number of exceptions.
  199.      *    @access public
  200.      */
  201.     function getExceptionCount() {
  202.         return $this->_exceptions;
  203.     }
  204.  
  205.     /**
  206.      *    Paints a simple supplementary message.
  207.      *    @param string $message        Text to display.
  208.      *    @access public
  209.      */
  210.     function paintMessage($message) {
  211.     }
  212.  
  213.     /**
  214.      *    Paints a formatted ASCII message such as a
  215.      *    variable dump.
  216.      *    @param string $message        Text to display.
  217.      *    @access public
  218.      */
  219.     function paintFormattedMessage($message) {
  220.     }
  221.  
  222.     /**
  223.      *    By default just ignores user generated events.
  224.      *    @param string $type        Event type as text.
  225.      *    @param mixed $payload      Message or object.
  226.      *    @access public
  227.      */
  228.     function paintSignal($type, $payload) {
  229.     }
  230. }
  231.  
  232. /**
  233.  *    Recipient of generated test messages that can display
  234.  *    page footers and headers. Also keeps track of the
  235.  *    test nesting. This is the main base class on which
  236.  *    to build the finished test (page based) displays.
  237.  *    @package SimpleTest
  238.  *    @subpackage UnitTester
  239.  */
  240. class SimpleReporter extends SimpleScorer {
  241.     var $_test_stack;
  242.     var $_size;
  243.     var $_progress;
  244.  
  245.     /**
  246.      *    Starts the display with no results in.
  247.      *    @access public
  248.      */
  249.     function SimpleReporter() {
  250.         $this->SimpleScorer();
  251.         $this->_test_stack = array();
  252.         $this->_size = null;
  253.         $this->_progress = 0;
  254.     }
  255.     
  256.     /**
  257.      *    Gets the formatter for variables and other small
  258.      *    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.      *    @static
  406.      */
  407.     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.     var $_reporter;
  419.  
  420.     /**
  421.      *    Mediates between the reporter and the test case.
  422.      *    @param SimpleScorer $reporter       Reporter to receive events.
  423.      */
  424.     function SimpleReporterDecorator(&$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 variables 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.     var $_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 variables 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 Sun, 04 May 2008 09:22:04 -0500 by phpDocumentor 1.3.0