tlib.php

<?php

// vim: set noexpandtab tabstop=4 shiftwidth=4 softtabstop=4:

class TLNetwork
{
        public static function netmaskDot2Bit($nmDot) {
                $netmask_full = 0; $netmask_full = ~$netmask_full; /* Fill netmask with binary 1's */
                $bitnetmask = $netmask_full - ip2long($nmDot);
                return (32-strlen(decbin($bitnetmask))); /* ugly, but working */
        }

        public static function netmaskBit2Dot ($nmBit) {
                $bitnetmask_inv = pow(2, (int)(32-$nmBit)) - 1; /* I.e. /24 -> 255 */
                $netmask_full = 0; $netmask_full = ~$netmask_full; /* Fill netmask with binary 1's */

                return (long2ip($netmask_full - $bitnetmask_inv));
        }
}

class TLString
{
        public static function explodeAssign($string, $seperator, $vars) 
        {
                $temp = explode($seperator, $string);
                if (count($temp) != count($vars)) {
                        return(false);
                } else {
                        for ($i = 0; $i != count($temp); $i++) {
                                $vars[$i] = $temp[$i];
                        }
                        return(true);
                }
        }

        public static function arrayAssign($array, $vars) 
        {
                if (count($array) != count($vars)) {
                        return(false);
                } else {
                        for ($i = 0; $i != count($array); $i++) {
                                $vars[$i] = $array[$i];
                        }
                        return(true);
                }
        }

        public static function isOfChars($string, $chars) 
        {
                return(!preg_match("/[^".preg_quote($chars, '/')."]/", $string));
        }

        public static function startsWith($string, $start) 
        {
                if (strlen($string) >= strlen($start)) {
                        if (substr($string, 0, strlen($start)) == $start) {
                                return(true);
                        }
                }
                return(false);
        }

        public static function endsWith($string, $end) 
        {
                if (strlen($string) >= strlen($end)) {
                        if (substr($string, strlen($string)-strlen($end)) == $end) {
                                return(true);
                        }
                }
                return(false);
        }
}

class TLVars
{
        public static function isEmpty($var = null) 
        {
                if ($var === "" || $var === null || $var === false || $var === 0 || $var === array()) {
                        return(true);
                }
                return(false);
        }

        public static function import($varName, $from, $default = "") {
                $i = $c = "";
                $varValue = FALSE;

                for ($i = 0; $i < strlen($from); $i++) {

                        $c = $from[$i];

                        switch ($c) {
                                case 'F' : if (isset($_FILES) && array_key_exists($varName, $_FILES)) { $varValue = $_FILES[$varName]; } break;
                                case 'S' : if (isset($_SESSION) && array_key_exists($varName, $_SESSION)) { $varValue = $_SESSION[$varName]; } break;
                                case 'P' : if (isset($_POST) && array_key_exists($varName, $_POST)) { $varValue = $_POST[$varName]; } break;
                                case 'G' : if (isset($_GET) && array_key_exists($varName, $_GET)) { $varValue = $_GET[$varName]; } break;
                                case 'C' : if (isset($_COOKIE) && array_key_exists($varName, $_COOKIE)) { $varValue = $_COOKIE[$varName]; } break;
                                default: break;
                        }
                }

                if ($varValue === FALSE) {
                        if ($default != "") {
                                return ($default);
                        } else {
                                return(null); // Not defined.
                        }
                } else {
                        return ($varValue);
                }
        }
}

class TLControlStruct
{
        public static function isMain($from) 
        {
                if ($from == realpath($_SERVER["SCRIPT_FILENAME"])) {
                        return(true);
                } else {
                        return(false);
                }
        }
}

class TLUnitTest {

        private $appName = "";
        private $cnt = 1;
        private $testOutput = array();
        private $testResults = array();
        private $currentTest = array();
    private $otherErros = "";

        private $prevErrorReporting = 0;
        public function __construct($appName, $testClass) {
                $this->prevErrorReporting = error_reporting(E_ALL);
                set_error_handler(array(&$this, "errorHandler"));
                $this->appName = $appName;
                $this->testClass = $testClass;
                $this->run($this->testClass);
        }

        /*
         * @brief Destructor.
         */
        public function __destruct() {
                restore_error_handler();
                error_reporting($this->prevErrorReporting);
        }

        public function errorHandler($errno, $errmsg, $filename, $linenum, $vars) {
        if ($this->currentTest == array()) {
            //$this->otherErrors .= "$filename($linenum): Error $errno: '$errmsg': ".var_export($vars, true)."\n";
            $this->otherErrors .= "$filename($linenum): Error $errno: '$errmsg'\n";
        } else {
            $e = new Exception($errmsg, $errno);
            $this->failed($e);
        }
        }

        public function exceptionHandler($e) {
                $this->failed($e);
        }

        private function run($testClass) {
        $props = get_object_vars($this->testClass);
        if (array_key_exists("testNames", $props)) {
            $hasNames = true;
        } else {
            $hasNames = false;
        }
                foreach(get_class_methods($this->testClass) as $method) {
                        if (!TLString::explodeAssign($method, "_", array(&$group, &$name))) {
                                $group = "";
                                $name = $method;
                        }
                        if ($hasNames && array_key_exists($method, $this->testClass->testNames)) {
                                $name = $this->testClass->testNames[$method];
                        }

                        // Start the test
                        $this->start($group, $name);
                        try {
                                call_user_func(array($testClass, $method), $this);
                        } catch(Exception $e) {
                                $this->exceptionHandler($e);
                        }
                        $this->end();
                }
        }

        private function start($testGroup, $testName) {
                $this->currentTest = array(
                        "group"  => $testGroup,
                        "nr"     => $this->cnt++,
                        "name"   => $testName,
                        "result" => "",
            "dump"   => "",
                );
                $this->passed();
        }

        public function passed() {
                $this->currentTest["passed"] = true;
                $this->currentTest["result"] = "";
                $this->currentTest["dump"] = "";

                $this->currentTest = array_merge($this->currentTest, array(
                        "passed" => true,
                        )
                );
        }

        public function failed($e) {
                $this->currentTest["passed"] = false;
                $this->currentTest["result"] .= $e->getMessage()."\n";
        $this->currentTest["dump"] .= $e->getMessage()."\n";
                foreach($e->getTrace() as $stackFrame) {
                        if (array_key_exists("file", $stackFrame)) {
                                $this->currentTest["dump"] .= "  ".
                                        $stackFrame["file"] . ":".$stackFrame["line"]." - ";
                                        if (array_key_exists("class", $stackFrame)) {
                                                $this->currentTest["dump"] .= $stackFrame["class"];
                                        }
                                        if (array_key_exists("type", $stackFrame)) {
                                                $this->currentTest["dump"] .= " ".$stackFrame["type"]." ";
                                        }
                                        if (array_key_exists("function", $stackFrame)) {
                                                $this->currentTest["dump"] .= $stackFrame["function"]."(";
                                        }
                                        if (array_key_exists("args", $stackFrame) && count($stackFrame["args"] > 0)) {
                                                foreach($stackFrame["args"] as $arg) {
                                                        $this->currentTest["dump"] .= $arg.", ";
                                                }
                        if (substr($this->currentTest["dump"], -2) == ", ") {
                            $this->currentTest["dump"] = substr($this->currentTest["dump"], 0, -2);
                        }
                                        }
                                        if (array_key_exists("function", $stackFrame)) {
                                                $this->currentTest["dump"] .= ")";
                                        }
                                        $this->currentTest["dump"] .= "\n";
                        }
                }
                $this->currentTest["dump"] .= "\n";
        }

        public function assert($bool) {
                if ($bool) {
                        $this->passed();
                } else {
                        throw new Exception("Assertion failed");
                }
        }

        private function end() {
                $this->testResults[] = $this->currentTest;
                $this->currentTest = array();
        }

        private function sortResultsByGroup() {
                $cmp = create_function('$a,$b', '
                        if ($a["group"] == $b["group"]) {
                                return (0); 
                        }; 
                        return($a["group"] > $b["group"] ? -1 : 1);
                ');
                usort($this->testResults, $cmp);
        }

        public function dumpHtml($hidePassed = false, $sortGroups = false) {
                if ($sortGroups) { 
                        $this->sortResultsByGroup();
                }
                $out = "
                        <html>
                                <body>
                                        <style>
                                                body { font-family: sans-serif; }
                                                table { border: 1px solid #000000; }
                                                th { empty-cells: show; font-family: sans-serif; border-left: 1px solid #FFFFFF; border-top: 1px solid #FFFFFF; border-bottom: 1px solid #000000; border-right: 1px solid #000000; margin: 0px; font-size: x-small; color: #FFFFFF; background-color: #404040; padding: 2px 4px 2px 4px; }
                                                td { empty-cells: show; font-family: sans-serif; border-bottom: 1px solid #909090; margin: 0px; padding: 2px 4px 2px 4px; border-left: 1px solid #E0E0E0; font-size: x-small; }
                                                div.dump { background-color: #F0F0F0; }
                                                a.dump { text-decoration: underline; cursor: pointer; }
                                        </style>
                                </body>
                                <h1>Test results for ".$this->appName."</h1>
                                <h2>Test results</h2>
                                <table cellspacing='0' cellpadding='0'>
                                        ";
                                        $prevResult = $this->testResults[0];
                                        $nrOfPassed = 0;
                                        $nrOfFailed = 0;
                                        foreach ($this->testResults as $result) {
                                                if ($result["passed"] == false) {
                                                        $nrOfFailed++;
                                                        $textResult = "FAILED";
                                                        $rowColor = "#FF0000";
                                                        $dump = "<a class='dump' onclick='document.getElementById(\"dump_".$result["nr"]."\").style.display=\"block\"'>Dump</a><div style='border: 1px solid #000000; background-color: #F0F0F0; display:none;' class='dump' id='dump_".$result["nr"]."'><pre>".$result["dump"]."</pre></div>";
                                                } else {
                                                        $nrOfPassed++;
                                                        if ($hidePassed) {
                                                                continue;
                                                        }
                                                        $textResult = "passed";
                                                        $rowColor = "#50FF00";
                                                        $dump = "";
                                                }
                                                if ($result["group"] != $prevResult["group"]) {
                                                        $out .= "
                                                        <tr valign='top' align='left'>
                                                                <td colspan='6'></td>
                                                        </tr>\n";
                                                }
                                                $out .= "
                                                        <tr valign='top' align='left'>
                                                                <th>".$result["nr"]."</th>
                                                                <th>".$result["group"]."</th>
                                                                <th>".$result["name"]."</th>
                                                                <td bgcolor='".$rowColor."'>".$textResult."</td>
                                                                <td>".str_replace("\n", "<br />\n", $result["result"])."</td>
                                                                <td>".$dump."</td>
                                                        </tr>\n";

                                                $prevResult = $result;
                                        }
                                        $out .= "
                                </table>
                                <h2>Total results</h2>
                                <table cellspacing='0' cellpadding='0'>
                                        <tr><th>Passed:</th><td>".$nrOfPassed."</td></tr>
                                        <tr><th>Failed:</th><td>".$nrOfFailed."</td></tr>
                                </table>
                                <h2>Non-testcase errors</h2>
                <pre>\n".$this->otherErrors."
                </pre>
                        </html>
                ";

                return($out);
        }

        public function dumpPrettyText($hidePassed = false) {
                $fmt = "%3s | %-60s | %-6s | %s\n";
                $sep = "%3s-+-%-60s-+-%-6s-+-%s\n";

                $out = "";
                $out .= sprintf($fmt, "Nr", "Test", "Passed", "Result");
                $out .= sprintf($sep, str_repeat('-', 3), str_repeat('-', 60), str_repeat('-', 6), str_repeat('-', 40));
                foreach ($this->testResults as $result) {
                        if ($result["passed"] == false) {
                                $textResult = "FAILED";
                        } else {
                                if ($hidePassed) {
                                        continue;
                                }
                                $textResult = "passed";
                        }
                        $out .= sprintf($fmt, $result["nr"], $result["group"].":".$result["name"], $textResult, $result["result"]);
                }
                return($out);
        }
}

class TLDebug {

        static function backtraceString($relative = True) {
                $out = "";

                if ($relative) {
                        $docRootLen = strlen($_SERVER["DOCUMENT_ROOT"]);
                } else {
                        $docRootLen = 0;
                }

                $trace = debug_backtrace();
                if (is_array($trace)) {
                        for ($i = 0; $i != count($trace); $i++) {
                                $stackFrame = $trace[$i];

                                // Skip frames relating to this class
                                if (array_key_exists("class", $stackFrame) && $stackFrame["class"] == __CLASS__) {
                                        continue;
                                }

                                if (array_key_exists("file", $stackFrame)) { 
                                        $out .= substr($stackFrame["file"], $docRootLen, strlen($stackFrame["file"]) - $docRootLen).":"; 
                                } else {
                                        $out .= "??:";
                                }
                                if (array_key_exists("line", $stackFrame)) {
                                        $out .= $stackFrame["line"]." ";
                                } else {
                                        $out .= "?? ";
                                }
                                if (array_key_exists("class", $stackFrame)) {
                                        $out .= $stackFrame["class"].$stackFrame["type"];
                                }
                                if (array_key_exists("function", $stackFrame)) {
                                        $out .= $stackFrame["function"]."(";
                                        $args = array();
                                        if (array_key_exists("args", $stackFrame)) {
                                                foreach($stackFrame["args"] as $arg) {
                                                        if (gettype($arg) == "array") {
                                                                $args[] = "Array(".@implode(", ", $arg).")";
                                                        } else {
                                                                $args[] = $arg;
                                                        }
                                                }
                                                $out .= implode(", ", $args);
                                        }
                                        $out .= ")";
                                }
                                $out .= "\n";
                        }
                }

                return($out);
        }
        
        static function backtraceSingleLine($relative = True) {
                $out = TLDebug::backtraceString($relative);
                $out = str_replace("\n", "; ", $out);
                return($out);
        }

        static function startPedantic() {
                assert_options(ASSERT_ACTIVE, 1);
                assert_options(ASSERT_WARNING, 1);
                assert_options(ASSERT_BAIL, 1);
                if (defined("E_STRICT")) {
                        error_reporting(E_ALL | E_STRICT);
                } else {
                        error_reporting(E_ALL);
                }
                ini_set("display_errors", "1");
        }
}

class TLTypeException extends Exception {

        public function __construct($expectedType, $gotVar, $varName = null) {
                
                $this->expectedType = $expectedType; // The type the caller expected to get
                $this->type = gettype($gotVar);      // The type of the variable which the caller got
                if ($varName != null) {
                        $this->name = $varName;              // The name of the variable which the caller got
                }
                if (is_object($gotVar)) {
                $this->value = get_class($gotVar);
                $this->class = get_class($gotVar);   // The class of the variable which the caller got
                } else {
                        $this->value = $gotVar;
                }

                if (isset($this->name)) {
                        $message = sprintf("Expected \"%s\", got \"%s(%s)\" for variable \"%s\"", $this->expectedType, $this->type, $this->value, $this->name);
                } else {
                        $message = sprintf("Expected \"%s\", got \"%s(%s)\"", $this->expectedType, $this->type, $this->value);
                }

                parent::__construct($message);
        }
}

class TLValueException extends Exception {

        public function __construct($message, $gotVar, $varName) {
                $message = sprintf("\"$%s(%s)\": %s", $varName, $gotVar, $message);
                parent::__construct($message);
        }
}

class TLSQLException extends Exception {

        public function __construct($message, $query = "") {
                $this->message = $message;
                $this->query = $query;
        }

        public function getQuery() {
                return($this->query);
        }
}


class TLSelfURL {
        
        public $type = "";     
        public $host = "";     
        public $port = "";     
        public $path = "";     
        public $script = "";   
        public $params = null; 
        public function __construct() {
                if (array_key_exists("HTTPS", $_SERVER)) {
                        $this->type = "https";
                } else {
                        $this->type = "http";
                }

                // Get raw data
                if (!array_key_exists("HTTP_HOST", $_SERVER)) {
                        throw new Exception("Not running on a HTTP server");
                }

                $this->host = $_SERVER["HTTP_HOST"];
                $this->port = $_SERVER["SERVER_PORT"];
                $this->path = dirname($_SERVER["PHP_SELF"]);
                $this->script = basename($_SERVER["PHP_SELF"]);

                $this->params = $_REQUEST;
                if (array_key_exists("PHPSESSID", $this->params)) {
                        // Work around PHP's idiotic definition of developer-friendly nonsense.
                        unset($this->params["PHPSESSID"]);
                }

                // Verify and correct raw data
                if (strlen($this->path) == 0 || $this->path[0] != '/') {
                        $this->path = '/'.$this->path;
                }
                if ($this->path[strlen($this->path) - 1] == '/') {
                        $this->path = substr($this->path, 0, strlen($this->path) - 1);
                }
                
                assert($this->self_check());
        }

        public function getServerURL() {
                $serverURL = $this->type."://".$this->host;
                if ($this->port != "80" && $this->port != "443") {
                        $serverURL .= ":" . $this->port;
                }
                return($serverURL);
        }

        public function getAbsolutePathURL() {
                $pathURL = $this->getServerURL();
                $pathURL .= $this->path;
                return($pathURL);
        }

        public function getRelativePathURL() {
                $pathURL = $this->path;
                return($pathURL);
        }

        public function getAbsoluteScriptURL() {
                $scriptURL = $this->getServerURL();
                $scriptURL .= $this->path . '/' . $this->script;
                return($scriptURL);
        }

        public function getRelativeScriptURL() {
                $scriptURL = $this->path . '/' . $this->script;
                return($scriptURL);
        }

        public function getParams($stripVarsPrefix = null) {
                $paramsString = "";

                // Only process params if there are any
                if (count($this->params) > 0) {
                        // Create a duplicate of the params and remove unwanted ones
                        if ($stripVarsPrefix != null) {
                                $vars = $this->params;
                                $prefixLen = strlen($stripVarsPrefix);
                                foreach(array_keys($vars) as $key) {
                                        if (substr($key, 0, $prefixLen) == $stripVarsPrefix) {
                                                unset($vars[$key]);
                                        }
                                }
                                $paramsString .= "?".http_build_query($vars);
                        } else {
                                $paramsString .= "?".http_build_query($this->params);
                        }
                }

                return($paramsString);
        }

        public function getAbsoluteFullURL($stripVarsPrefix = null) {
                $fullURL = $this->getAbsoluteScriptURL();
                $fullURL .= $this->getParams($stripVarsPrefix);

                return($fullURL);
        }

        public function getRelativeFullURL($stripVarsPrefix = null) {
                $fullURL = $this->getRelativeScriptURL();
                $fullURL .= $this->getParams($stripVarsPrefix);
                return($fullURL);
        }

        private function self_check() {
                if (
                        $this->type == "" || 
                        $this->host == "" || 
                        $this->port == "" || 
                        $this->path == "" || 
                        $this->script == "" || 
                        $this->params == "") {
                                return(false);
                } else {
                        return(true);
                }
        }
}

TLDebug::startPedantic();

/* Perform a bunch of tests/examples if we're the main script */
if (TLControlStruct::isMain(__FILE__)) {
        //###########################################################################
        // TLNetwork
        //###########################################################################
        // TLNetwork::netmaskDot2Bit()
        print (TLNetwork::netmaskDot2Bit("255.255.254.0")."\n");
        //---------------------------------------------------------------------------
        // TLNetwork::netmaskBit2Dot()
        print (TLNetwork::netmaskBit2Dot(24)."\n");

        //###########################################################################
        // TLString
        //###########################################################################
        // TLString::explodeAssign()
        if (!TLString::explodeAssign("Peterson:Pete:25", ':', array(&$last,&$first,&$age))) {
                $last = "Doe";
                $first = "John";
                $age = "38";
        }
        print ("Hello $first $last. You are $age years old.\n");
        //---------------------------------------------------------------------------
        // TLString::isOfChars()
        $username = "-^myusername102^-";
        if (!TLString::isOfChars($username, "a-z0-9")) {
                print ("Invalid username\n");
        }
        //---------------------------------------------------------------------------
        // TLString::startsWith()
        if (TLString::startsWith("Hello", "He")) {
                print ("'Hello' starts with 'He'\n");
        }
        //---------------------------------------------------------------------------
        // TLString::endsWith()
        if (TLString::endsWith("Hello", "lo")) {
                print ("'Hello' ends with 'lo'\n");
        }

        //###########################################################################
        // TLVars
        //###########################################################################
        // TLVars::isEmpty()
        if (@TLVars::isEmpty(false)) { print ("Empty\n"); }
        if (@TLVars::isEmpty($ape)) { print ("Empty\n"); } /* $ape is undefined */
        //---------------------------------------------------------------------------
        // TLVars::import()
        $foo = TLVars::import("foo", "GP", "default value");
        print($foo."\n");

        //###########################################################################
        // TLControlStruct
        //###########################################################################
        // TLControlStruct::isIncluded()
        if (TLControlStruct::isMain(__FILE__)) {
                print ("We are the main script!\n");
        } else {
                print ("We are merely being included\n");
        }
        //###########################################################################
        // TLUnitTest
        //###########################################################################
        // TLControlStruct::isIncluded()
        class TestMe {
                public $testNames = array(
                        "User_Load" => "Load user",
                        "Group_AddUser" => "Add user to group",
                        "FailingCase" => "Deliberitely fail",
                );
         
                public function User_Load($test) {
                        $this->user = "john";
                        $test->assert($this->user == "john");
                }
                public function Group_AddUser($test) {
                        $this->group[] = $this->user;
                }
                public function FailingCase($test) {
                        throw new Exception("This testcase will fail");
                }
        }
        $cases = new TestMe();
        $test = new TLUnitTest("ExampleTest", $cases);
        print($test->dumpPrettyText());
        $test->__destruct(); // PHP Bug work-around.

        //###########################################################################
        // TLTypeException
        //###########################################################################
        // TLTypeException
        function TLTypeExceptionTest($name) {
                if (!is_string($name)) {
                        throw new TLTypeException("string", $name, "name");
                }
        }
        try {
                TLTypeExceptionTest("ferry");
                TLTypeExceptionTest(26);
        } catch (TLTypeException $e) {
                print($e->getMessage()."\n");
        }

        //###########################################################################
        // TLValueException
        //###########################################################################
        // TLValueException
        function TLValueExceptionTest($age) {
                if (!($age > -1 and $age < 200)) {
                        throw new TLValueException("Age should be between 0 and 200", $age, "age");
                }
        }
        try {
                TLValueExceptionTest(50);
                TLValueExceptionTest(230);
        } catch (TLValueException $e) {
                print($e->getMessage()."\n");
        }

        //###########################################################################
        // TLSelfURL 
        //###########################################################################
        // 
        try {
                $s = new TLSelfURL();
                print ($s->getServerURL());
                print ($s->getAbsolutePathURL());
                print ($s->getAbsoluteScriptURL());
                print ($s->getAbsoluteFullURL());
                print ($s->getAbsoluteFullURL("strip_"));
                print ($s->getRelativePathURL());
                print ($s->getRelativeScriptURL());
                print ($s->getRelativeFullURL());
                print ($s->getRelativeFullURL("strip_"));
        } catch (Exception $e) {
                // Not running in a HTTP server.
                ;
        }
}
?>

---