root/test_suite/trunk/run-tests

#!/usr/bin/php
<?php
/** 
 * A script to download and run a given test set
 *
 * Author:  Bart Vanbrabant <bart.vanbrabant at zoeloelip.be>
 */

$tmp = "/tmp/";                                    // the temporary directory
$web_root = "/var/www/html/ea_test/";            // the webroot for the tests
$web_url = "http://localhost/ea_test/";            // the url to the webroot
$test_url = "http://zoeloelip.be/ea/tests/";    // the remote directory with the test set files

/**
 * Get a file with a given url using curl.
 */
function get_remote_file($url) {
    $ch = curl_init($url);

    curl_setopt($ch, CURLOPT_HEADER, 0);
    curl_setopt($ch, CURLOPT_ENCODING, "gzip");
    curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 1);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
    curl_setopt($ch, CURLOPT_TIMEOUT, 120);

    $output = curl_exec($ch);
    if (curl_errno($ch) != 0)
        return '';
    curl_close($ch);
    return $output;
}

/**
 * Prepate test, get the test and save it
 */
function prep_test($url, $sum, $nocache, $noenc) {
    global $web_root;

    // is the file the same?
    $file_name = $web_root.basename($url, ".txt").".php";
    if (is_file($file_name))
        $old_sum = md5(file_get_contents($web_root.basename($url, ".txt").".php"));
    else 
        $old_sum = '';

    if ($old_sum != $sum) {
        // retrieve the test
        $test = get_remote_file($url);
        if (strncasecmp($test, "! eAccelerator test", strlen("! eAccelerator test")) != 0) {
            die("Could not retrieve valid test file. (url=$url)\n");
        }

        // parse options header
        $options = parse_header($test);
       
        // save the test file to the webroot
        if ($options['cache'] && !$nocache)
            file_put_contents($file_name, $test);
        
        // save an encoded version
        if ($options['encode'] && !$noenc)
            file_put_contents(dirname($file_name).'/'.basename($file_name, '.php').'.enc.php', 
                "<?php eaccelerator_load('".eaccelerator_encode($file_name)."'); ?>");
    } else {
        touch ($file_name);
        $options = parse_header(file_get_contents($file_name));
    } 

    if ($nocache)
        $options['cache'] = false;
    if ($noenc)
        $options['encode'] = false;
    return $options;
}

/**
 * Parse the options header in the test
 */
function parse_header($test) {
    // parse options
    $lines = explode("\n", $test);
    $options = array('cache' => true, 'encode' => true);
    foreach ($lines as $line) {
        if (ereg('![[:space:]](.*)', $line, $regs)) {
            switch ($regs[1]) {
                case 'no-cache':
                    $options['cache'] = false;
                    break;
                case 'no-encode':
                    $options['encode'] = false;
                    break;
                default:    // nothing
            }
        }
    } 
    return $options;
}

/**
 * Run the test on the given url
 */
function run_test($url, $cache, $encode) {
    global $web_url, $debug;
    
    $test_file_url = $web_url.basename($url, ".txt").".php";
    if ($debug) print "\n url : $test_file_url\n";
    // run the test the first time, this will be the output when ea isn't used
    $php_output = get_remote_file($test_file_url);
    if ($debug) echo "php: \n$php_output\n";

    // run the test a second time, this will be the cached version
    if ($cache)
        $ea_output = get_remote_file($test_file_url);
    if ($debug) echo "ea: \n$ea_output\n";

    // run the test on the encoded file
    if ($encode)
        $enc_output = get_remote_file(substr($test_file_url, 0, strlen($test_file_url) - 4).".enc.php");
    if ($debug) echo "enc: \n$enc_output\n";
    
    if (!$cache)
        $result['cache'] = 'skipped';
    elseif ($php_output == $ea_output)
        $result['cache'] = 'succes';
    else
        $result['cache'] = 'failed';

    if (!$encode)
        $result['encoded'] = 'skipped';
    elseif ($php_output == $enc_output)
        $result['encoded'] = 'succes';
    else
        $result['encoded'] = 'failed';
    
    return $result; 
}

function show_help() {
    die("eAccelerator test suite.\n" .
    "Usage: run-tests [options] command\n" .
    "commands:\n" .
    "   list                    List the test sets available.\n" .
    "   run [test set, test]    Run the given test set.\n" .
    "       --noenc     Don't test encoding\n" .
    "       --nocache   Don't test caching\n" .
    "   clean                   Clean the test directory.\n"
    );
}

function list_sets() {
    global $test_url;
    $sets = get_remote_file($test_url.'SETLIST');
    $sets = explode("\n", $sets);
    foreach($sets as $set) {
        $line = explode(':', $set);
        if (count($line) == 2) {
            echo $line[0];
            echo "\t";
            echo $line[1];
            echo "\n";
        }
    }
}

function run_set($test_set, $nocache, $noenc) {
    global $test_url;
    
    /** get the test set **/
    $set = get_remote_file("$test_url$test_set");
    $tests = explode("\n", $set);

    if ($tests[0] != "! eAccelerator test set") {
        echo "Error: $test_url$test_set isn't a valid test set!\n";
        exit(1);
    }

    /** when saving the test and directly after it retrieving
      the test, the file won't be cached. Run it in two stages.   **/
    /* prepare each test */
    $test_queue = '';
    foreach ($tests as $test) {
        // split the checksum and url
        if (ereg('([A-z0-9]{32})[[:space:]]{2}(.+)', $test, $regs)) {
            $options = prep_test($test_url.$regs[2], $regs[1], $nocache, $noenc);
            $options['url'] = $regs[2];
            $test_queue[] = $options;
        } else {
            echo "$test\n";
        }
    }

    // wait, so the tests will be cached
    echo "Waiting ...";
    for ($i = 5; $i > 0; $i--) {
        sleep(1);
        echo " $i ...";
    }
    echo "\n";

    /* run each of the tests in the test set */
    foreach ($test_queue as $test) {
        echo "Test: {$test['url']}\n";
        $result = run_test($test_url.$test['url'], $test['cache'], $test['encode']);
        echo "\t cached: ".$result['cache']."\n";
        echo "\t encoded: ".$result['encoded']."\n";
    }
}


/* the set to run */
$options = ''; // the options array
$command = '';

/** parse the commandline options **/
if ($_SERVER['argc'] > 1) {
    $arguments = $_SERVER['argv'];
    unset($arguments[0]);
    // arg 0 is the script name
    foreach ($arguments as $arg) {
        if (strlen($arg) > 2 && $arg{0} == '-' && $arg{1} == '-') {
            if (strstr($arg, '=')) {
                $arr = explode('=', $arg);
                $options[substr($arr[0], 2)] = $arr[1];
            } else {
                $options[substr($arg, 2)] = true;
            }
        } else { // this isn't an option, so this is a set
            $command[] = $arg;
        }
    }
}

/** --help */
if (isset($options['help'])) {
    show_help();
}

if (!isset($command[0])) {
    show_help();
}

switch ($command[0]) {
    case 'list':
        list_sets();
        break;

    case 'clean':
        
        break;

    case 'run':
        if (!isset($command[1])) {
            die("run requires a test set to run!\n");
        }
        run_set($command[1], isset($options['nocache']) ? true:false, isset($options['noenc']) ? true:false);
        break;
}

?>