--TEST--
AusPostCheck class
--FILE--
<?php

    require_once("../../../test/newGuiTest/bootstrap.php");
    require_once("../check_contact_details.php");

    var_dump(AusPostCheck::SuburbStatePostcodeMatch('Windsor', 'VIC', '3181'));
    var_dump(AusPostCheck::SuburbStatePostcodeMatch('Windsor', 'VIC', '3182'));
    var_dump(AusPostCheck::SuburbStatePostcodeMatch('Windsor', 'NSW', '3181'));
    var_dump(AusPostCheck::SuburbStatePostcodeMatch('Prahran', 'VIC', '3181'));
    var_dump(AusPostCheck::SuburbStatePostcodeMatch('Foobar', 'VIC', '3181'));

?>
--EXPECT--
string(5) "MATCH"
string(8) "NO_MATCH"
string(8) "NO_MATCH"
string(5) "MATCH"
string(9) "NO_SUBURB"

margaret ~/tests $ phpt
PHPT Test Runner v0.1.1alpha

.

Test Cases Run: 1, Passes: 1, Failures: 0, Skipped: 0

$row = $table->tr();

if(!($amIAltOrNot = !$amIAltOrNot))
{
    $row->class = "alt";
}


//  Edit: Much better now
$row = $table->tr();

$row->class = ($amIAltOrNot = !$amIAltOrNot) ? "" : "alt";

<?php

/*

    PHP implementation of a common programming problem:

        Reversing a singly linked list

*/


    error_reporting(E_ALL | E_STRICT);


    //  This is our basic node
    class WordNode
    {
        public $word;
        public $nextNode;

        public function __construct($word = null)
        {
            $this->word = $word;
        }

        //  Print all content of this node, and linked nodes
        public function __toString($separator = '')
        {
            $buffer  = '';
            $current = $this;

            do
            {
                //  Append the separator as long as there is a next node
                $buffer .= $current->word . (($current->nextNode !== null) ? $separator : '');
            }
            while(($current = $current->nextNode) !== null);

            return $buffer;
        }
    }


    //  Takes an array and turns it into a linked list
    //  (Remember this is purely an academic exercise :-)
    function buildWordNodeList($sourceArray)
    {
        //  First step create the linked list
        $firstNode = new WordNode($sourceArray[0]);

        $lastNode = $firstNode;

        foreach(array_slice($sourceArray, 1) as $word)
        {
            $thisNode = new WordNode($word);

            $lastNode->nextNode = $thisNode;

            $lastNode = $thisNode;
        }

        return $firstNode;
    }


    //  Inplace reverse
    function reverseWordNodeListInplace(WordNode &$head)
    {
        //  Init the loop by separating the top node, and
        //  keeping track of what is left ($tail)
        $tail = $head->nextNode;

        //  This is set to null as it will end up being the
        //  last node and shouldn't point anywhere
        $head->nextNode = null;

        while($tail !== null)
        {
            //  Take the next node, and seperate it, and again
            //  keep track of what's left
            $next = $tail;
            $tail = $next->nextNode;

            //  Now make this node the parent of the previous top node
            $next->nextNode = $head;

            //  This node is now at the top
            $head = $next;
        }
    }


    $list = buildWordNodeList(array("a","b","c","d","e","f","g","h", "i", "j", "k"));

    echo $list . "\n";

    reverseWordNodeListInplace($list);

    echo $list . "\n";

    reverseWordNodeListInplace($list);

    echo $list . "\n";

    echo $list->__toString(" ") . "\n";

?>

abcdefghijk
kjihgfedcba
abcdefghijk
a b c d e f g h i j k

<?php

/*

    Some hacked up code for Very Simple (Pretend) SQL Paramaters
    -- For when you don't have PDO, or just can't be bothered

    Examples:

        >>> SQL("SELECT * FROM users WHERE id=? AND name LIKE ?", 123, '"123\"');
        SELECT * FROM users WHERE id=123 AND name LIKE "\"123\\\""

        >>> SQL("INSERT INTO user (nameFirst, nameLast) VALUES (?, ?)", "Fred", "Nurk");
        INSERT INTO user (nameFirst, nameLast) VALUES ("Fred", "Nurk")

*/

function SQL($sql)
{
    $params = func_get_args();
    $params = array_map('mysql_real_escape_string', $params);
    $sql    = explode('?', $sql);

    if(count($params) != (count($sql)-1))
    {
        throw new Exception(sprintf("Incorrect number of paramaters.  Expected %d got %d", count($sql)-1, count($params)));
    }

    $newSql = '';

    for($i = 0; $i < count($params); $i++)
    {
        $newSql .= $sql[$i] . (is_numeric($params[$i]) ? $params[$i] : '"' . $params[$i] . '"');
    }

    return $newSql . $sql[$i];
}

?>

<?php

/*

    PHP interface for the DecentUrl service
        by Matthew D (project-2501.net)

    Based on the Python script by Ben Hoyt
    See http://decenturl.com/tools#api

    Example:


    <?php

        require_once("decenturl_interface.php");

        //  returns: "youtube/medieval-helpdesk-with-english"
        DecentUrl::Get('http://youtube.com/watch?v=pQHX-SjgQvQ');

        //  returns: "http://youtube.com/watch?v=pQHX-SjgQvQ"
        DecentUrl::Resolve('youtube/medieval-helpdesk-with-english');

        //  returns: array("DecentURL - Making ugly URLs decent", "making-ugly-urls-decent")
        DecentUrl::Title('http://decenturl.com/');

        //  returns: "brush.co.nz"
        DecentUrl::Domain('http://brush.co.nz');

        //  throws a DecentUrlException("resolve request failed:  notfound")
        DecentUrl::Resolve('baddy');
    ?>

*/

    class DecentUrlException extends Exception {}
    class DecentUrl
    {
        const BASE_URL = 'http://decenturl.com/api-';

        //  Create or get decent URL from given ugly one and return it
        public static function Get($url, $title="")
        {
            $response = self::Request("get", array("u" => $url, "t" => $title), 2);

            return $response[0];
        }

        //  Resolve decent URL and return ugly original
        public static function Resolve($decentUrl)
        {
            $response = self::Request("resolve", array("d" => $decentUrl), 2);

            return $response[0];
        }

        //  Return tuple of full <title> and decent title for given URL
        public static function Title($url, $maxLength = 1000)
        {
            return self::Request("title", array("u" => $url, "l" => $maxLength), 2);
        }

        //  Return URL's base domain
        public static function Domain($url, $maxLength = 1000)
        {
            $response = self::Request("domain", array("u" => $url, "l" => $maxLength), 1);

            return $response[0];
        }

        //  Call generic DecentUul API function, throw DecentUrlException if not ok
        private static function Request($type, $parameters, $expectedResponseSize = false)
        {
            //  Take a key value pair, and join them together, making sure to
            //  urlencode the value
            foreach($parameters as $key => $value)
            {
                $parameters[$key] = sprintf("%s=%s", $key, urlencode($value));
            }

            $queryString = implode("&", array_values($parameters));

            $url = sprintf("%s%s?%s", self::BASE_URL, $type, $queryString);

            $contents = file_get_contents($url);

            $response = json_decode($contents);

            if($response == null)
            {
                throw new DecentUrlException("Response was not valid JSON");
            }

            if($response[0] != "ok")
            {
                throw new DecentUrlException("{$type} request failed:  {$response[0]}");
            }

            //  Remove the first element (which we proved was 'ok' above)
            $trimedResponse = array_slice($response, 1);

            //  If requested, we check to see that the response is the correct
            //  size.
            if(($expectedResponseSize !== false) && (count($trimedResponse) != $expectedResponseSize))
            {
                throw new DecentUrlException("{$type} request failed:  expected {$expectedResponseSize} fields, got " . count($trimedResponse));
            }

            return $trimedResponse;
        }
    }

?>