0.2.1/inc/phpmailer/test/phpunit.php

   1 <?php
   2 //
   3 // PHP framework for testing, based on the design of "JUnit".
   4 //
   5 // Written by Fred Yankowski <fred@ontosys.com>
   6 //            OntoSys, Inc  <http://www.OntoSys.com>
   7 //
   8 // $Id: phpunit.php,v 1.1 2002/03/30 19:32:17 bmatzelle Exp $
   9
  10 // Copyright (c) 2000 Fred Yankowski
  11
  12 // Permission is hereby granted, free of charge, to any person
  13 // obtaining a copy of this software and associated documentation
  14 // files (the "Software"), to deal in the Software without
  15 // restriction, including without limitation the rights to use, copy,
  16 // modify, merge, publish, distribute, sublicense, and/or sell copies
  17 // of the Software, and to permit persons to whom the Software is
  18 // furnished to do so, subject to the following conditions:
  19 //
  20 // The above copyright notice and this permission notice shall be
  21 // included in all copies or substantial portions of the Software.
  22 //
  23 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  24 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  25 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  26 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  27 // BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  28 // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  29 // CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  30 // SOFTWARE.
  31 //
  32 error_reporting(E_ERROR | E_WARNING | E_PARSE | E_NOTICE |
  33                 E_CORE_ERROR | E_CORE_WARNING);
  34
  35 /*
  36 interface Test {
  37   function run(&$aTestResult);
  38   function countTestCases();
  39 }
  40 */
  41
  42 function trace($msg) {
  43   return;
  44   print($msg);
  45   flush();
  46 }
  47
  48
  49 class Exception {
  50     /* Emulate a Java exception, sort of... */
  51   var $message;
  52   function Exception($message) {
  53     $this->message = $message;
  54   }
  55   function getMessage() {
  56     return $this->message;
  57   }
  58 }
  59
  60 class Assert {
  61   function assert($boolean, $message=0) {
  62     if (! $boolean)
  63       $this->fail($message);
  64   }
  65
  66   function assertEquals($expected, $actual, $message=0) {
  67     if ($expected != $actual) {
  68       $this->failNotEquals($expected, $actual, "expected", $message);
  69     }
  70   }
  71
  72   function assertRegexp($regexp, $actual, $message=false) {
  73     if (! preg_match($regexp, $actual)) {
  74       $this->failNotEquals($regexp, $actual, "pattern", $message);
  75     }
  76   }
  77
  78   function failNotEquals($expected, $actual, $expected_label, $message=0) {
  79     // Private function for reporting failure to match.
  80     $str = $message ? ($message . ' ') : '';
  81     $str .= "($expected_label/actual)<br>";
  82     $htmlExpected = htmlspecialchars($expected);
  83     $htmlActual = htmlspecialchars($actual);
  84     $str .= sprintf("<pre>%s\n--------\n%s</pre>",
  85                     $htmlExpected, $htmlActual);
  86     $this->fail($str);
  87   }
  88 }
  89
  90 class TestCase extends Assert /* implements Test */ {
  91   /* Defines context for running tests.  Specific context -- such as
  92      instance variables, global variables, global state -- is defined
  93      by creating a subclass that specializes the setUp() and
  94      tearDown() methods.  A specific test is defined by a subclass
  95      that specializes the runTest() method. */
  96   var $fName;
  97   var $fResult;
  98   var $fExceptions = array();
  99
 100   function TestCase($name) {
 101     $this->fName = $name;
 102   }
 103
 104   function run($testResult=0) {
 105     /* Run this single test, by calling the run() method of the
 106        TestResult object which will in turn call the runBare() method
 107        of this object.  That complication allows the TestResult object
 108        to do various kinds of progress reporting as it invokes each
 109        test.  Create/obtain a TestResult object if none was passed in.
 110        Note that if a TestResult object was passed in, it must be by
 111        reference. */
 112     if (! $testResult)
 113       $testResult = $this->_createResult();
 114     $this->fResult = $testResult;
 115     $testResult->run(&$this);
 116     $this->fResult = 0;
 117     return $testResult;
 118   }
 119
 120   function countTestCases() {
 121     return 1;
 122   }
 123
 124   function runTest() {
 125     $name = $this->name();
 126     // Since isset($this->$name) is false, no way to run defensive checks
 127     $this->$name();
 128   }
 129
 130   function setUp() /* expect override */ {
 131     //print("TestCase::setUp()<br>\n");
 132   }
 133
 134   function tearDown() /* possible override */ {
 135     //print("TestCase::tearDown()<br>\n");
 136   }
 137
 138   ////////////////////////////////////////////////////////////////
 139
 140
 141   function _createResult() /* protected */ {
 142     /* override this to use specialized subclass of TestResult */
 143     return new TestResult;
 144   }
 145
 146   function fail($message=0) {
 147     //printf("TestCase::fail(%s)<br>\n", ($message) ? $message : '');
 148     /* JUnit throws AssertionFailedError here.  We just record the
 149        failure and carry on */
 150     $this->fExceptions[] = new Exception(&$message);
 151   }
 152
 153   function error($message) {
 154     /* report error that requires correction in the test script
 155        itself, or (heaven forbid) in this testing infrastructure */
 156     printf('<b>ERROR: ' . $message . '</b><br>');
 157     $this->fResult->stop();
 158   }
 159
 160   function failed() {
 161     return count($this->fExceptions);
 162   }
 163
 164   function getExceptions() {
 165     return $this->fExceptions;
 166   }
 167
 168   function name() {
 169     return $this->fName;
 170   }
 171
 172   function runBare() {
 173     $this->setup();
 174     $this->runTest();
 175     $this->tearDown();
 176   }
 177 }
 178
 179
 180 class TestSuite /* implements Test */ {
 181   /* Compose a set of Tests (instances of TestCase or TestSuite), and
 182      run them all. */
 183   var $fTests = array();
 184
 185   function TestSuite($classname=false) {
 186     if ($classname) {
 187       // Find all methods of the given class whose name starts with
 188       // "test" and add them to the test suite.  We are just _barely_
 189       // able to do this with PHP's limited introspection...  Note
 190       // that PHP seems to store method names in lower case, and we
 191       // have to avoid the constructor function for the TestCase class
 192       // superclass.  This will fail when $classname starts with
 193       // "Test" since that will have a constructor method that will
 194       // get matched below and then treated (incorrectly) as a test
 195       // method.  So don't name any TestCase subclasses as "Test..."!
 196       if (floor(phpversion()) >= 4) {
 197         // PHP4 introspection, submitted by Dylan Kuhn
 198         $names = get_class_methods($classname);
 199         while (list($key, $method) = each($names)) {
 200           if (preg_match('/^test/', $method) && $method != "testcase") {
 201             $this->addTest(new $classname($method));
 202           }
 203         }
 204       }
 205       else {
 206         $dummy = new $classname("dummy");
 207         $names = (array) $dummy;
 208         while (list($key, $value) = each($names)) {
 209           $type = gettype($value);
 210           if ($type == "user function" && preg_match('/^test/', $key)
 211           && $key != "testcase") {
 212             $this->addTest(new $classname($key));
 213           }
 214         }
 215       }
 216     }
 217   }
 218
 219   function addTest($test) {
 220     /* Add TestCase or TestSuite to this TestSuite */
 221     $this->fTests[] = $test;
 222   }
 223
 224   function run(&$testResult) {
 225     /* Run all TestCases and TestSuites comprising this TestSuite,
 226        accumulating results in the given TestResult object. */
 227     reset($this->fTests);
 228     while (list($na, $test) = each($this->fTests)) {
 229       if ($testResult->shouldStop())
 230         break;
 231       $test->run(&$testResult);
 232     }
 233   }
 234
 235   function countTestCases() {
 236     /* Number of TestCases comprising this TestSuite (including those
 237        in any constituent TestSuites) */
 238     $count = 0;
 239     reset($fTests);
 240     while (list($na, $test_case) = each($this->fTests)) {
 241       $count += $test_case->countTestCases();
 242     }
 243     return $count;
 244   }
 245 }
 246
 247
 248 class TestFailure {
 249   /* Record failure of a single TestCase, associating it with the
 250      exception(s) that occurred */
 251   var $fFailedTestName;
 252   var $fExceptions;
 253
 254   function TestFailure(&$test, &$exceptions) {
 255     $this->fFailedTestName = $test->name();
 256     $this->fExceptions = $exceptions;
 257   }
 258
 259   function getExceptions() {
 260       return $this->fExceptions;
 261   }
 262   function getTestName() {
 263     return $this->fFailedTestName;
 264   }
 265 }
 266
 267
 268 class TestResult {
 269   /* Collect the results of running a set of TestCases. */
 270   var $fFailures = array();
 271   var $fRunTests = 0;
 272   var $fStop = false;
 273
 274   function TestResult() { }
 275
 276   function _endTest($test) /* protected */ {
 277       /* specialize this for end-of-test action, such as progress
 278          reports  */
 279   }
 280
 281   function getFailures() {
 282     return $this->fFailures;
 283   }
 284
 285   function run($test) {
 286     /* Run a single TestCase in the context of this TestResult */
 287     $this->_startTest($test);
 288     $this->fRunTests++;
 289
 290     $test->runBare();
 291
 292     /* this is where JUnit would catch AssertionFailedError */
 293     $exceptions = $test->getExceptions();
 294     if ($exceptions)
 295       $this->fFailures[] = new TestFailure(&$test, &$exceptions);
 296     $this->_endTest($test);
 297   }
 298
 299   function countTests() {
 300     return $this->fRunTests;
 301   }
 302
 303   function shouldStop() {
 304     return $this->fStop;
 305   }
 306
 307   function _startTest($test) /* protected */ {
 308       /* specialize this for start-of-test actions */
 309   }
 310
 311   function stop() {
 312     /* set indication that the test sequence should halt */
 313     $fStop = true;
 314   }
 315
 316   function countFailures() {
 317     return count($this->fFailures);
 318   }
 319 }
 320
 321
 322 class TextTestResult extends TestResult {
 323   /* Specialize TestResult to produce text/html report */
 324   function TextTestResult() {
 325     $this->TestResult();  // call superclass constructor
 326   }
 327
 328   function report() {
 329     /* report result of test run */
 330     $nRun = $this->countTests();
 331     $nFailures = $this->countFailures();
 332     printf("<p>%s test%s run<br>", $nRun, ($nRun == 1) ? '' : 's');
 333     printf("%s failure%s.<br>\n", $nFailures, ($nFailures == 1) ? '' : 's');
 334     if ($nFailures == 0)
 335       return;
 336
 337     print("<ol>\n");
 338     $failures = $this->getFailures();
 339     while (list($i, $failure) = each($failures)) {
 340       $failedTestName = $failure->getTestName();
 341       printf("<li>%s\n", $failedTestName);
 342
 343       $exceptions = $failure->getExceptions();
 344       print("<ul>");
 345       while (list($na, $exception) = each($exceptions))
 346         printf("<li>%s\n", $exception->getMessage());
 347       print("</ul>");
 348     }
 349     print("</ol>\n");
 350   }
 351
 352   function _startTest($test) {
 353     printf("%s ", $test->name());
 354     flush();
 355   }
 356
 357   function _endTest($test) {
 358     $outcome = $test->failed()
 359        ? "<font color=\"red\">FAIL</font>"
 360        : "<font color=\"green\">ok</font>";
 361     printf("$outcome<br>\n");
 362     flush();
 363   }
 364 }
 365
 366
 367 class TestRunner {
 368   /* Run a suite of tests and report results. */
 369   function run($suite) {
 370     $result = new TextTestResult;
 371     $suite->run($result);
 372     $result->report();
 373   }
 374 }
 375
 376 ?>