C:/xampp/htdocs/moodle/lib/simpletestlib/unit_tester.php

Go to the documentation of this file.

<?php
require_once(dirname(__FILE__) . '/test_case.php');
require_once(dirname(__FILE__) . '/dumper.php');
class UnitTestCase extends SimpleTestCase {

    function UnitTestCase($label = false) {
        if (! $label) {
            $label = get_class($this);
        }
        $this->SimpleTestCase($label);
    }

    function assertTrue($result, $message = false) {
        return $this->assert(new TrueExpectation(), $result, $message);
    }

    function assertFalse($result, $message = '%s') {
        return $this->assert(new FalseExpectation(), $result, $message);
    }

    function assertNull($value, $message = '%s') {
        $dumper = new SimpleDumper();
        $message = sprintf(
                $message,
                '[' . $dumper->describeValue($value) . '] should be null');
        return $this->assertTrue(! isset($value), $message);
    }

    function assertNotNull($value, $message = '%s') {
        $dumper = new SimpleDumper();
        $message = sprintf(
                $message,
                '[' . $dumper->describeValue($value) . '] should not be null');
        return $this->assertTrue(isset($value), $message);
    }

    function assertIsA($object, $type, $message = '%s') {
        return $this->assert(
                new IsAExpectation($type),
                $object,
                $message);
    }

    function assertNotA($object, $type, $message = '%s') {
        return $this->assert(
                new NotAExpectation($type),
                $object,
                $message);
    }

    function assertEqual($first, $second, $message = '%s') {
        return $this->assert(
                new EqualExpectation($first),
                $second,
                $message);
    }

    function assertNotEqual($first, $second, $message = '%s') {
        return $this->assert(
                new NotEqualExpectation($first),
                $second,
                $message);
    }

    function assertWithinMargin($first, $second, $margin, $message = '%s') {
        return $this->assert(
                new WithinMarginExpectation($first, $margin),
                $second,
                $message);
    }

    function assertOutsideMargin($first, $second, $margin, $message = '%s') {
        return $this->assert(
                new OutsideMarginExpectation($first, $margin),
                $second,
                $message);
    }

    function assertIdentical($first, $second, $message = '%s') {
        return $this->assert(
                new IdenticalExpectation($first),
                $second,
                $message);
    }

    function assertNotIdentical($first, $second, $message = '%s') {
        return $this->assert(
                new NotIdenticalExpectation($first),
                $second,
                $message);
    }

    function assertReference(&$first, &$second, $message = '%s') {
        $dumper = new SimpleDumper();
        $message = sprintf(
                $message,
                '[' . $dumper->describeValue($first) .
                        '] and [' . $dumper->describeValue($second) .
                        '] should reference the same object');
        return $this->assertTrue(
                SimpleTestCompatibility::isReference($first, $second),
                $message);
    }

    function assertClone(&$first, &$second, $message = '%s') {
        $dumper = new SimpleDumper();
        $message = sprintf(
                $message,
                '[' . $dumper->describeValue($first) .
                        '] and [' . $dumper->describeValue($second) .
                        '] should not be the same object');
        $identical = new IdenticalExpectation($first);
        return $this->assertTrue(
                $identical->test($second) &&
                        ! SimpleTestCompatibility::isReference($first, $second),
                $message);
    }

    function assertCopy(&$first, &$second, $message = "%s") {
        $dumper = new SimpleDumper();
        $message = sprintf(
                $message,
                "[" . $dumper->describeValue($first) .
                        "] and [" . $dumper->describeValue($second) .
                        "] should not be the same object");
        return $this->assertFalse(
                SimpleTestCompatibility::isReference($first, $second),
                $message);
    }

    function assertPattern($pattern, $subject, $message = '%s') {
        return $this->assert(
                new PatternExpectation($pattern),
                $subject,
                $message);
    }

    function assertWantedPattern($pattern, $subject, $message = '%s') {
        return $this->assertPattern($pattern, $subject, $message);
    }

    function assertNoPattern($pattern, $subject, $message = '%s') {
        return $this->assert(
                new NoPatternExpectation($pattern),
                $subject,
                $message);
    }

    function assertNoUnwantedPattern($pattern, $subject, $message = '%s') {
        return $this->assertNoPattern($pattern, $subject, $message);
    }

    function swallowErrors() {
        $context = &SimpleTest::getContext();
        $queue = &$context->get('SimpleErrorQueue');
        $queue->clear();
    }

    function assertNoErrors($message = '%s') {
        $context = &SimpleTest::getContext();
        $queue = &$context->get('SimpleErrorQueue');
        return $queue->assertNoErrors($message);
    }

    function assertError($expected = false, $message = '%s') {
        $context = &SimpleTest::getContext();
        $queue = &$context->get('SimpleErrorQueue');
        return $queue->assertError($this->_coerceExpectation($expected), $message);
    }

    function expectError($expected = false, $message = '%s') {
        $context = &SimpleTest::getContext();
        $queue = &$context->get('SimpleErrorQueue');
        $queue->expectError($this->_coerceExpectation($expected), $message);
    }

    function expectException($expected = false, $message = '%s') {
        $context = &SimpleTest::getContext();
        $queue = &$context->get('SimpleExceptionTrap');
        // :HACK: Directly substituting in seems to cause a segfault with
        // Zend Optimizer on some systems
        $line = $this->getAssertionLine();
        $queue->expectException($expected, $message . $line);
    }

    function _coerceExpectation($expected) {
        if ($expected == false) {
            return new TrueExpectation();
        }
        if (SimpleTestCompatibility::isA($expected, 'SimpleExpectation')) {
            return $expected;
        }
        return new EqualExpectation(
                is_string($expected) ? str_replace('%', '%%', $expected) : $expected);
    }

    function assertErrorPattern($pattern, $message = '%s') {
        return $this->assertError(new PatternExpectation($pattern), $message);
    }
}
?>