Source for file exceptions.php

Documentation is available at exceptions.php

  1. <?php
  2. /**
  3.  *  base include file for SimpleTest
  4.  *  @package    SimpleTest
  5.  *  @subpackage UnitTester
  6.  *  @version    $Id: exceptions.php 1672 2008-03-02 04:47:34Z edwardzyang $
  7.  */
  8.  
  9. /**#@+
  10.  * Include required SimpleTest files
  11.  */
  12. require_once dirname(__FILE__) . '/invoker.php';
  13. require_once dirname(__FILE__) . '/expectation.php';
  14. /**#@-*/
  15.  
  16.  *    Extension that traps exceptions and turns them into
  17.  *    an error message. PHP5 only.
  18.  *    @package SimpleTest
  19.  *    @subpackage UnitTester
  20.  */
  21. class SimpleExceptionTrappingInvoker extends SimpleInvokerDecorator {
  22.  
  23.     /**
  24.      *    Stores the invoker to be wrapped.
  25.      *    @param SimpleInvoker $invoker   Test method runner.
  26.      */
  27.     function SimpleExceptionTrappingInvoker($invoker) {
  28.         $this->SimpleInvokerDecorator($invoker);
  29.     }
  30.  
  31.     /**
  32.      *    Invokes a test method whilst trapping expected
  33.      *    exceptions. Any left over unthrown exceptions
  34.      *    are then reported as failures.
  35.      *    @param string $method    Test method to call.
  36.      */
  37.     function invoke($method) {
  38.         $trap = SimpleTest::getContext()->get('SimpleExceptionTrap');
  39.         $trap->clear();
  40.         try {
  41.             $has_thrown = false;
  42.             parent::invoke($method);
  43.         } catch (Exception $exception) {
  44.             $has_thrown = true;
  45.             if (! $trap->isExpected($this->getTestCase(), $exception)) {
  46.                 $this->getTestCase()->exception($exception);
  47.             }
  48.             $trap->clear();
  49.         }
  50.         if ($message = $trap->getOutstanding()) {
  51.             $this->getTestCase()->fail($message);
  52.         }
  53.         if ($has_thrown) {
  54.             try {
  55.                 parent::getTestCase()->tearDown();
  56.             } catch (Exception $e) { }
  57.         }
  58.     }
  59. }
  60.  
  61. /**
  62.  *    Tests exceptions either by type or the exact
  63.  *    exception. This could be improved to accept
  64.  *    a pattern expectation to test the error
  65.  *    message, but that will have to come later.
  66.  *    @package SimpleTest
  67.  *    @subpackage UnitTester
  68.  */
  69. class ExceptionExpectation extends SimpleExpectation {
  70.     private $expected;
  71.  
  72.     /**
  73.      *    Sets up the conditions to test against.
  74.      *    If the expected value is a string, then
  75.      *    it will act as a test of the class name.
  76.      *    An exception as the comparison will
  77.      *    trigger an identical match. Writing this
  78.      *    down now makes it look doubly dumb. I hope
  79.      *    come up with a better scheme later.
  80.      *    @param mixed $expected   A class name or an actual
  81.      *                              exception to compare with.
  82.      *    @param string $message   Message to display.
  83.      */
  84.     function __construct($expected, $message = '%s') {
  85.         $this->expected = $expected;
  86.         parent::__construct($message);
  87.     }
  88.  
  89.     /**
  90.      *    Carry out the test.
  91.      *    @param Exception $compare    Value to check.
  92.      *    @return boolean              True if matched.
  93.      */
  94.     function test($compare) {
  95.         if (is_string($this->expected)) {
  96.             return ($compare instanceof $this->expected);
  97.         }
  98.         if (get_class($compare) != get_class($this->expected)) {
  99.             return false;
  100.         }
  101.         return $compare->getMessage() == $this->expected->getMessage();
  102.     }
  103.  
  104.     /**
  105.      *    Create the message to display describing the test.
  106.      *    @param Exception $compare     Exception to match.
  107.      *    @return string                Final message.
  108.      */
  109.     function testMessage($compare) {
  110.         if (is_string($this->expected)) {
  111.             return "Exception [" . $this->describeException($compare) .
  112.                     "] should be type [" . $this->expected . "]";
  113.         }
  114.         return "Exception [" . $this->describeException($compare) .
  115.                 "] should match [" .
  116.                 $this->describeException($this->expected) . "]";
  117.     }
  118.  
  119.     /**
  120.      *    Summary of an Exception object.
  121.      *    @param Exception $compare     Exception to describe.
  122.      *    @return string                Text description.
  123.      */
  124.     protected function describeException($exception) {
  125.         return get_class($exception) . ": " . $exception->getMessage();
  126.     }
  127. }
  128.  
  129. /**
  130.  *    Stores expected exceptions for when they
  131.  *    get thrown. Saves the irritating try...catch
  132.  *    block.
  133.  *    @package  SimpleTest
  134.  *    @subpackage   UnitTester
  135.  */
  136. class SimpleExceptionTrap {
  137.     private $expected;
  138.     private $message;
  139.  
  140.     /**
  141.      *    Clears down the queue ready for action.
  142.      */
  143.     function __construct() {
  144.         $this->clear();
  145.     }
  146.  
  147.     /**
  148.      *    Sets up an expectation of an exception.
  149.      *    This has the effect of intercepting an
  150.      *    exception that matches.
  151.      *    @param SimpleExpectation $expected    Expected exception to match.
  152.      *    @param string $message                Message to display.
  153.      *    @access public
  154.      */
  155.     function expectException($expected = false, $message = '%s') {
  156.         if ($expected === false) {
  157.             $expected = new AnythingExpectation();
  158.         }
  159.         if (! SimpleExpectation::isExpectation($expected)) {
  160.             $expected = new ExceptionExpectation($expected);
  161.         }
  162.         $this->expected = $expected;
  163.         $this->message = $message;
  164.     }
  165.  
  166.     /**
  167.      *    Compares the expected exception with any
  168.      *    in the queue. Issues a pass or fail and
  169.      *    returns the state of the test.
  170.      *    @param SimpleTestCase $test    Test case to send messages to.
  171.      *    @param Exception $exception    Exception to compare.
  172.      *    @return boolean                False on no match.
  173.      */
  174.     function isExpected($test, $exception) {
  175.         if ($this->expected) {
  176.             return $test->assert($this->expected, $exception, $this->message);
  177.         }
  178.         return false;
  179.     }
  180.  
  181.     /**
  182.      *    Tests for any left over exception.
  183.      *    @return string/false     The failure message or false if none.
  184.      */
  185.     function getOutstanding() {
  186.         return sprintf($this->message, 'Failed to trap exception');
  187.     }
  188.  
  189.     /**
  190.      *    Discards the contents of the error queue.
  191.      */
  192.     function clear() {
  193.         $this->expected = false;
  194.         $this->message = false;
  195.     }
  196. }
  197. ?>

Documentation generated on Sun, 04 May 2008 09:21:33 -0500 by phpDocumentor 1.3.0