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

Go to the documentation of this file.

<?php
require_once(dirname(__FILE__) . '/invoker.php');
class SimpleScorer {
    var $_passes;
    var $_fails;
    var $_exceptions;
    var $_is_dry_run;

    function SimpleScorer() {
        $this->_passes = 0;
        $this->_fails = 0;
        $this->_exceptions = 0;
        $this->_is_dry_run = false;
    }

    function makeDry($is_dry = true) {
        $this->_is_dry_run = $is_dry;
    }

    function shouldInvoke($test_case_name, $method) {
        return ! $this->_is_dry_run;
    }

    function &createInvoker(&$invoker) {
        return $invoker;
    }

    function getStatus() {
        if ($this->_exceptions + $this->_fails > 0) {
            return false;
        }
        return true;
    }

    function paintGroupStart($test_name, $size) {
    }

    function paintGroupEnd($test_name) {
    }

    function paintCaseStart($test_name) {
    }

    function paintCaseEnd($test_name) {
    }

    function paintMethodStart($test_name) {
    }

    function paintMethodEnd($test_name) {
    }

    function paintPass($message) {
        $this->_passes++;
    }

    function paintFail($message) {
        $this->_fails++;
    }

    function paintError($message) {
        $this->_exceptions++;
    }

    function paintException($exception) {
        $this->_exceptions++;
    }
    
    function paintSkip($message) {
    }

    function getPassCount() {
        return $this->_passes;
    }

    function getFailCount() {
        return $this->_fails;
    }

    function getExceptionCount() {
        return $this->_exceptions;
    }

    function paintMessage($message) {
    }

    function paintFormattedMessage($message) {
    }

    function paintSignal($type, $payload) {
    }
}

class SimpleReporter extends SimpleScorer {
    var $_test_stack;
    var $_size;
    var $_progress;

    function SimpleReporter() {
        $this->SimpleScorer();
        $this->_test_stack = array();
        $this->_size = null;
        $this->_progress = 0;
    }
    
    function getDumper() {
        return new SimpleDumper();
    }

    function paintGroupStart($test_name, $size) {
        if (! isset($this->_size)) {
            $this->_size = $size;
        }
        if (count($this->_test_stack) == 0) {
            $this->paintHeader($test_name);
        }
        $this->_test_stack[] = $test_name;
    }

    function paintGroupEnd($test_name) {
        array_pop($this->_test_stack);
        if (count($this->_test_stack) == 0) {
            $this->paintFooter($test_name);
        }
    }

    function paintCaseStart($test_name) {
        if (! isset($this->_size)) {
            $this->_size = 1;
        }
        if (count($this->_test_stack) == 0) {
            $this->paintHeader($test_name);
        }
        $this->_test_stack[] = $test_name;
    }

    function paintCaseEnd($test_name) {
        $this->_progress++;
        array_pop($this->_test_stack);
        if (count($this->_test_stack) == 0) {
            $this->paintFooter($test_name);
        }
    }

    function paintMethodStart($test_name) {
        $this->_test_stack[] = $test_name;
    }

    function paintMethodEnd($test_name) {
        array_pop($this->_test_stack);
    }

    function paintHeader($test_name) {
    }

    function paintFooter($test_name) {
    }

    function getTestList() {
        return $this->_test_stack;
    }

    function getTestCaseCount() {
        return $this->_size;
    }

    function getTestCaseProgress() {
        return $this->_progress;
    }

    function inCli() {
        return php_sapi_name() == 'cli';
    }
}

class SimpleReporterDecorator {
    var $_reporter;

    function SimpleReporterDecorator(&$reporter) {
        $this->_reporter = &$reporter;
    }

    function makeDry($is_dry = true) {
        $this->_reporter->makeDry($is_dry);
    }

    function getStatus() {
        return $this->_reporter->getStatus();
    }

    function shouldInvoke($test_case_name, $method) {
        return $this->_reporter->shouldInvoke($test_case_name, $method);
    }

    function &createInvoker(&$invoker) {
        return $this->_reporter->createInvoker($invoker);
    }
    
    function getDumper() {
        return $this->_reporter->getDumper();
    }

    function paintGroupStart($test_name, $size) {
        $this->_reporter->paintGroupStart($test_name, $size);
    }

    function paintGroupEnd($test_name) {
        $this->_reporter->paintGroupEnd($test_name);
    }

    function paintCaseStart($test_name) {
        $this->_reporter->paintCaseStart($test_name);
    }

    function paintCaseEnd($test_name) {
        $this->_reporter->paintCaseEnd($test_name);
    }

    function paintMethodStart($test_name) {
        $this->_reporter->paintMethodStart($test_name);
    }

    function paintMethodEnd($test_name) {
        $this->_reporter->paintMethodEnd($test_name);
    }

    function paintPass($message) {
        $this->_reporter->paintPass($message);
    }

    function paintFail($message) {
        $this->_reporter->paintFail($message);
    }

    function paintError($message) {
        $this->_reporter->paintError($message);
    }

    function paintException($exception) {
        $this->_reporter->paintException($exception);
    }
    
    function paintSkip($message) {
        $this->_reporter->paintSkip($message);
    }

    function paintMessage($message) {
        $this->_reporter->paintMessage($message);
    }

    function paintFormattedMessage($message) {
        $this->_reporter->paintFormattedMessage($message);
    }

    function paintSignal($type, &$payload) {
        $this->_reporter->paintSignal($type, $payload);
    }
}

class MultipleReporter {
    var $_reporters = array();

    function attachReporter(&$reporter) {
        $this->_reporters[] = &$reporter;
    }

    function makeDry($is_dry = true) {
        for ($i = 0; $i < count($this->_reporters); $i++) {
            $this->_reporters[$i]->makeDry($is_dry);
        }
    }

    function getStatus() {
        for ($i = 0; $i < count($this->_reporters); $i++) {
            if (! $this->_reporters[$i]->getStatus()) {
                return false;
            }
        }
        return true;
    }

    function shouldInvoke($test_case_name, $method) {
        for ($i = 0; $i < count($this->_reporters); $i++) {
            if (! $this->_reporters[$i]->shouldInvoke($test_case_name, $method)) {
                return false;
            }
        }
        return true;
    }

    function &createInvoker(&$invoker) {
        for ($i = 0; $i < count($this->_reporters); $i++) {
            $invoker = &$this->_reporters[$i]->createInvoker($invoker);
        }
        return $invoker;
    }
    
    function getDumper() {
        return new SimpleDumper();
    }

    function paintGroupStart($test_name, $size) {
        for ($i = 0; $i < count($this->_reporters); $i++) {
            $this->_reporters[$i]->paintGroupStart($test_name, $size);
        }
    }

    function paintGroupEnd($test_name) {
        for ($i = 0; $i < count($this->_reporters); $i++) {
            $this->_reporters[$i]->paintGroupEnd($test_name);
        }
    }

    function paintCaseStart($test_name) {
        for ($i = 0; $i < count($this->_reporters); $i++) {
            $this->_reporters[$i]->paintCaseStart($test_name);
        }
    }

    function paintCaseEnd($test_name) {
        for ($i = 0; $i < count($this->_reporters); $i++) {
            $this->_reporters[$i]->paintCaseEnd($test_name);
        }
    }

    function paintMethodStart($test_name) {
        for ($i = 0; $i < count($this->_reporters); $i++) {
            $this->_reporters[$i]->paintMethodStart($test_name);
        }
    }

    function paintMethodEnd($test_name) {
        for ($i = 0; $i < count($this->_reporters); $i++) {
            $this->_reporters[$i]->paintMethodEnd($test_name);
        }
    }

    function paintPass($message) {
        for ($i = 0; $i < count($this->_reporters); $i++) {
            $this->_reporters[$i]->paintPass($message);
        }
    }

    function paintFail($message) {
        for ($i = 0; $i < count($this->_reporters); $i++) {
            $this->_reporters[$i]->paintFail($message);
        }
    }

    function paintError($message) {
        for ($i = 0; $i < count($this->_reporters); $i++) {
            $this->_reporters[$i]->paintError($message);
        }
    }
    
    function paintException($exception) {
        for ($i = 0; $i < count($this->_reporters); $i++) {
            $this->_reporters[$i]->paintException($exception);
        }
    }

    function paintSkip($message) {
        for ($i = 0; $i < count($this->_reporters); $i++) {
            $this->_reporters[$i]->paintSkip($message);
        }
    }

    function paintMessage($message) {
        for ($i = 0; $i < count($this->_reporters); $i++) {
            $this->_reporters[$i]->paintMessage($message);
        }
    }

    function paintFormattedMessage($message) {
        for ($i = 0; $i < count($this->_reporters); $i++) {
            $this->_reporters[$i]->paintFormattedMessage($message);
        }
    }

    function paintSignal($type, &$payload) {
        for ($i = 0; $i < count($this->_reporters); $i++) {
            $this->_reporters[$i]->paintSignal($type, $payload);
        }
    }
}
?>