Replacing generate script with a new version

author: Zoe Slattery <zoe@php.net> 2009-05-07 09:21:43 +0000
committer: Zoe Slattery <zoe@php.net> 2009-05-07 09:21:43 +0000
commit: cba448a9d358451338d57c5e45f7c7e06f3143d2 (patch)
tree: df77a5d196aca30ffeb295d7dd5e79dc2429422a /scripts
parent: 903f306a60fddda0c7faf824d9252b08add34456 (diff)
download: php-git-cba448a9d358451338d57c5e45f7c7e06f3143d2.tar.gz
79 files changed, 2853 insertions, 1148 deletions
diff --git a/scripts/dev/generate-phpt.phar b/scripts/dev/generate-phpt.phar
new file mode 100644
index 0000000000..d9e6ce4302
--- /dev/null
+++ b/scripts/dev/generate-phpt.phar
diff --git a/scripts/dev/generate-phpt/build.xml b/scripts/dev/generate-phpt/build.xml
new file mode 100755
index 0000000000..c01954bda9
--- /dev/null
+++ b/scripts/dev/generate-phpt/build.xml
@@ -0,0 +1,15 @@
+<?xml version="1.0"?>
+
+<project name="generate" default="test" basedir=".">
+
+  <property name="build.dir" value="_build" />
+  
+  <target name="docs" description="Create API documentation.">
+    <exec command="doxygen doxygen.conf" />
+  </target>
+
+  <target name="test" description="Run all unit tests.">
+    <exec command="phpunit --coverage-html coverage tests" passthru="true" />
+  </target>
+
+</project>
diff --git a/scripts/dev/generate-phpt/gtPackage.php b/scripts/dev/generate-phpt/gtPackage.php
new file mode 100644
index 0000000000..566899d8de
--- /dev/null
+++ b/scripts/dev/generate-phpt/gtPackage.php
@@ -0,0 +1,30 @@
+<?php
+
+/**
+ * This creates a standalone phar file with all of the PHP source included. To run the
+ * phar just type 'php generate-phpt.phar <options>' at the command line.
+ */
+
+if (Phar::canWrite()) {
+  echo "Writing phar archive\n";
+} else {
+  echo "Unable to write archive, check that phar.readonly is 0 in your php.ini\n";
+  exit();
+}
+$thisDir = dirname(__FILE__);
+$pharPath = substr($thisDir, 0, -strlen('/generate-phpt'));
+
+$phar = new Phar($pharPath.'/generate-phpt.phar');
+
+$phar->buildFromDirectory($thisDir.'/src');
+
+$stub = <<<ENDSTUB
+<?php
+Phar::mapPhar('generate-phpt.phar');
+require 'phar://generate-phpt.phar/generate-phpt.php';
+__HALT_COMPILER();
+ENDSTUB;
+
+$phar->setStub($stub);
+
+?>
diff --git a/scripts/dev/generate-phpt/src/codeSnippets/array.txt b/scripts/dev/generate-phpt/src/codeSnippets/array.txt
new file mode 100644
index 0000000000..69a4af72c1
--- /dev/null
+++ b/scripts/dev/generate-phpt/src/codeSnippets/array.txt
@@ -0,0 +1,9 @@
+$index_array = array(1, 2, 3);
+$assoc_array = array(1 => 'one', 2 => 'two');
+
+$variation_array = array(
+  'empty array' => array(),
+  'int indexed array' => $index_array,
+  'associative array' => $assoc_array,
+  'nested arrays' => array('foo', $index_array, $assoc_array),
+  );
+\ No newline at end of file
diff --git a/scripts/dev/generate-phpt/src/codeSnippets/boolean.txt b/scripts/dev/generate-phpt/src/codeSnippets/boolean.txt
new file mode 100644
index 0000000000..53db40d30b
--- /dev/null
+++ b/scripts/dev/generate-phpt/src/codeSnippets/boolean.txt
@@ -0,0 +1,6 @@
+$variation_array = array(
+  'lowercase true' => true,
+  'lowercase false' =>false,
+  'uppercase TRUE' =>TRUE,
+  'uppercase FALSE' =>FALSE,
+  );
+\ No newline at end of file
diff --git a/scripts/dev/generate-phpt/src/codeSnippets/commentEnd.txt b/scripts/dev/generate-phpt/src/codeSnippets/commentEnd.txt
new file mode 100644
index 0000000000..d116022fb8
--- /dev/null
+++ b/scripts/dev/generate-phpt/src/codeSnippets/commentEnd.txt
@@ -0,0 +1,2 @@
+ *
+ */
+\ No newline at end of file
diff --git a/scripts/dev/generate-phpt/src/codeSnippets/commentStart.txt b/scripts/dev/generate-phpt/src/codeSnippets/commentStart.txt
new file mode 100644
index 0000000000..e3466d5a1a
--- /dev/null
+++ b/scripts/dev/generate-phpt/src/codeSnippets/commentStart.txt
@@ -0,0 +1,2 @@
+/**
+ *
+\ No newline at end of file
diff --git a/scripts/dev/generate-phpt/src/codeSnippets/emptyUnsetUndefNull.txt b/scripts/dev/generate-phpt/src/codeSnippets/emptyUnsetUndefNull.txt
new file mode 100644
index 0000000000..7e28494f5b
--- /dev/null
+++ b/scripts/dev/generate-phpt/src/codeSnippets/emptyUnsetUndefNull.txt
@@ -0,0 +1,11 @@
+$unset_var = 10;
+unset($unset_var);
+
+$variation_array = array(
+  'unset var' => @$unset_var,
+  'undefined var' => @$undefined_var,	
+  'empty string DQ' => "",
+  'empty string SQ' => '',
+  'uppercase NULL' => NULL,
+  'lowercase null' => null,
+  );
+\ No newline at end of file
diff --git a/scripts/dev/generate-phpt/src/codeSnippets/float.txt b/scripts/dev/generate-phpt/src/codeSnippets/float.txt
new file mode 100644
index 0000000000..75c2b6cd52
--- /dev/null
+++ b/scripts/dev/generate-phpt/src/codeSnippets/float.txt
@@ -0,0 +1,7 @@
+$variation_array = array(
+  'float 10.5' => 10.5,
+  'float -10.5' => -10.5,
+  'float 12.3456789000e10' => 12.3456789000e10,
+  'float -12.3456789000e10' => -12.3456789000e10,
+  'float .5' => .5,
+  );
+\ No newline at end of file
diff --git a/scripts/dev/generate-phpt/src/codeSnippets/int.txt b/scripts/dev/generate-phpt/src/codeSnippets/int.txt
new file mode 100644
index 0000000000..cdd28ae435
--- /dev/null
+++ b/scripts/dev/generate-phpt/src/codeSnippets/int.txt
@@ -0,0 +1,6 @@
+$variation_array = array (
+    'int 0' => 0,
+    'int 1' => 1,
+    'int 12345' => 12345,
+    'int -12345' => -2345,
+    );
+\ No newline at end of file
diff --git a/scripts/dev/generate-phpt/src/codeSnippets/loopClose.txt b/scripts/dev/generate-phpt/src/codeSnippets/loopClose.txt
new file mode 100644
index 0000000000..ff30235f07
--- /dev/null
+++ b/scripts/dev/generate-phpt/src/codeSnippets/loopClose.txt
@@ -0,0 +1 @@
+}
+\ No newline at end of file
diff --git a/scripts/dev/generate-phpt/src/codeSnippets/loopStart.txt b/scripts/dev/generate-phpt/src/codeSnippets/loopStart.txt
new file mode 100644
index 0000000000..8fd5eb20fd
--- /dev/null
+++ b/scripts/dev/generate-phpt/src/codeSnippets/loopStart.txt
@@ -0,0 +1 @@
+foreach ( $variation_array as $var ) {
+\ No newline at end of file
diff --git a/scripts/dev/generate-phpt/src/codeSnippets/object.txt b/scripts/dev/generate-phpt/src/codeSnippets/object.txt
new file mode 100644
index 0000000000..28ee61bfae
--- /dev/null
+++ b/scripts/dev/generate-phpt/src/codeSnippets/object.txt
@@ -0,0 +1,25 @@
+function test_error_handler($err_no, $err_msg, $filename, $linenum, $vars) {
+        if (error_reporting() != 0) {
+                // report non-silenced errors
+                echo "Error: $err_no - $err_msg, $filename($linenum)\n";
+        }
+}
+set_error_handler('test_error_handler');
+
+
+
+class classWithToString
+{
+        public function __toString() {
+                return "Class A object";
+        }
+}
+
+class classWithoutToString
+{
+}
+
+$variation_array = array(
+  'instance of classWithToString' => new classWithToString(),
+  'instance of classWithoutToString' => new classWithoutToString(),
+  );
+\ No newline at end of file
diff --git a/scripts/dev/generate-phpt/src/codeSnippets/skipif64b.txt b/scripts/dev/generate-phpt/src/codeSnippets/skipif64b.txt
new file mode 100644
index 0000000000..f05e9808d8
--- /dev/null
+++ b/scripts/dev/generate-phpt/src/codeSnippets/skipif64b.txt
@@ -0,0 +1 @@
+if (PHP_INT_SIZE != 4) die("skip this test is for 32bit platforms only");
diff --git a/scripts/dev/generate-phpt/src/codeSnippets/skipifnot64b.txt b/scripts/dev/generate-phpt/src/codeSnippets/skipifnot64b.txt
new file mode 100644
index 0000000000..e44071a6a2
--- /dev/null
+++ b/scripts/dev/generate-phpt/src/codeSnippets/skipifnot64b.txt
@@ -0,0 +1 @@
+if (PHP_INT_SIZE != 8) die("skip this test is for 64bit platforms only");
diff --git a/scripts/dev/generate-phpt/src/codeSnippets/skipifnotwin.txt b/scripts/dev/generate-phpt/src/codeSnippets/skipifnotwin.txt
new file mode 100644
index 0000000000..75ea3e1ef2
--- /dev/null
+++ b/scripts/dev/generate-phpt/src/codeSnippets/skipifnotwin.txt
@@ -0,0 +1 @@
+if (substr(PHP_OS, 0, 3) != 'WIN') die("skip this test is for Windows platforms only");
diff --git a/scripts/dev/generate-phpt/src/codeSnippets/skipifwin.txt b/scripts/dev/generate-phpt/src/codeSnippets/skipifwin.txt
new file mode 100644
index 0000000000..f712116527
--- /dev/null
+++ b/scripts/dev/generate-phpt/src/codeSnippets/skipifwin.txt
@@ -0,0 +1 @@
+if (substr(PHP_OS, 0, 3) == 'WIN') die("skip this test is not for Windows platforms");
diff --git a/scripts/dev/generate-phpt/src/codeSnippets/string.txt b/scripts/dev/generate-phpt/src/codeSnippets/string.txt
new file mode 100644
index 0000000000..a1d42376da
--- /dev/null
+++ b/scripts/dev/generate-phpt/src/codeSnippets/string.txt
@@ -0,0 +1,10 @@
+$heredoc = <<<EOT
+hello world
+EOT;
+
+$variation_array = array(
+  'string DQ' => "string",
+  'string SQ' => 'string',
+  'mixed case string' => "sTrInG",
+  'heredoc' => $heredoc,
+  );
+\ No newline at end of file
diff --git a/scripts/dev/generate-phpt/src/generate-phpt.php b/scripts/dev/generate-phpt/src/generate-phpt.php
new file mode 100644
index 0000000000..4f57a70b54
--- /dev/null
+++ b/scripts/dev/generate-phpt/src/generate-phpt.php
@@ -0,0 +1,115 @@
+<?php
+/**
+ * Main code for test case generation
+ */
+
+require_once dirname(__FILE__) . '/gtAutoload.php';
+
+//Version check. Will not run on less than PHP53;
+
+list($major, $minor, $bug) = explode(".", phpversion(), 3);
+ if($major == 5) {
+       if($minor < 3) { die("Sorry, you need PHP version 5.3 or greater to run this.\n"); }
+   }
+   if ($major < 5) { die ("Seriously, you need to upgrade you PHP level\n"); }
+
+
+$options = new gtCommandLineOptions();
+$optionalSections = new gtOptionalSections();
+
+try{
+  $options->parse($argv);
+} catch (exception $e) {
+  echo $e->getMessage()."\n";
+  die();
+}
+
+if($options->hasOption('h')) {
+  die(gtText::get('help'));
+}
+
+try {
+  $preConditions = new gtPreConditionList();
+  $preConditions->check($options);
+} catch (exception $e) {
+  echo $e->getMessage()."\n";
+  die();
+}
+
+if($options->hasOption('s')) {
+  $optionalSections->setOptions($options);
+}
+  
+
+
+if($options->hasOption('c')) {
+  $name = $options->getOption('c')."_".$options->getOption('m');
+  $method = new gtMethod($options->getOption('c'), $options->getOption('m'));
+  
+  $method->setArgumentNames();
+  $method->setArgumentLists();
+  $method->setInitialisationStatements();
+  
+  $method->setConstructorArgumentNames();
+  $method->setConstructorInitStatements();
+  $method->setConstructorArgumentList();
+}
+
+if($options->hasOption('f')) {
+  $name = $options->getOption('f');
+  $function = new gtFunction($name);
+  $function->setArgumentNames();
+  $function->setArgumentLists();
+  $function->setInitialisationStatements();
+}
+
+
+if($options->hasOption('b')) {
+  if($options->hasOption('c')) {
+    $testCase = gtBasicTestCase::getInstance($optionalSections, 'method');
+    $testCase->setMethod($method);
+  } else {
+    $testCase = gtBasicTestCase::getInstance($optionalSections);
+    $testCase->setFunction($function);
+  }
+
+  $testCase->constructTestCase();
+  gtTestCaseWriter::write($name, $testCase->toString(), 'b');
+}
+
+if($options->hasOption('e')) {
+  if($options->hasOption('c')) {
+    $testCase = gtErrorTestCase::getInstance($optionalSections, 'method');
+    $testCase->setMethod($method);
+  } else {
+    $testCase = gtErrorTestCase::getInstance($optionalSections);
+    $testCase->setFunction($function);
+  }
+
+  $testCase->constructTestCase();
+  gtTestCaseWriter::write($name, $testCase->toString(), 'e');
+}
+
+
+
+if($options->hasOption('v')) {
+  if($options->hasOption('c')) {
+    $testCaseContainer = gtVariationContainer::getInstance($optionalSections, 'method');
+    $testCaseContainer->setMethod($method);
+  } else {
+    $testCaseContainer = gtVariationContainer::getInstance ($optionalSections);
+    $testCaseContainer->setFunction($function);
+  }
+
+  $testCaseContainer->constructAll();
+
+  $tests = $testCaseContainer->getVariationTests();
+
+  $count = 1;
+  foreach($tests as $test) {
+    gtTestCaseWriter::write($name, $test, 'v', $count);
+    $count++;
+  }
+
+}
+?>
diff --git a/scripts/dev/generate-phpt/src/gtAutoload.php b/scripts/dev/generate-phpt/src/gtAutoload.php
new file mode 100644
index 0000000000..8c18c179eb
--- /dev/null
+++ b/scripts/dev/generate-phpt/src/gtAutoload.php
@@ -0,0 +1,63 @@
+<?php
+
+
+gtAutoload::init();
+
+/**
+ * Autoloader using a map file (gtClassMap.php)
+ * defining the file to load each class from.
+ */
+class gtAutoload
+{
+  /**
+   * @var array
+   */
+  protected static $classMap;
+
+  /**
+   * @var string
+   */
+  protected static $classPath;
+
+
+  /**
+   * Initialize the autoloader
+   *
+   * @return null
+   */
+  public static function init()
+  {
+    self::$classPath = dirname(__FILE__);
+
+    if (substr(self::$classPath, -1) != '/') {
+      self::$classPath .= '/';
+    }
+
+    if (file_exists(self::$classPath . 'gtClassMap.php')) {
+      include self::$classPath . 'gtClassMap.php';
+      self::$classMap = $gtClassMap;
+    }
+
+    if (function_exists('__autoload')) {
+      spl_autoload_register('__autoload');
+    }
+
+    spl_autoload_register(array('gtAutoload', 'autoload'));
+  }
+
+
+  /**
+   * Autoload method
+   *
+   * @param string $class Class name to autoload
+   * @return null
+   */
+  public static function autoload($class)
+  {
+    if (isset(self::$classMap[$class])) {
+      include self::$classPath . self::$classMap[$class];
+    }
+  }
+}
+
+?>
+\ No newline at end of file
diff --git a/scripts/dev/generate-phpt/src/gtClassMap.php b/scripts/dev/generate-phpt/src/gtClassMap.php
new file mode 100644
index 0000000000..3e45b4764d
--- /dev/null
+++ b/scripts/dev/generate-phpt/src/gtClassMap.php
@@ -0,0 +1,48 @@
+<?php
+
+ $gtClassMap = array(
+ 
+    'gtCodeSnippet'                 => 'gtCodeSnippet.php',
+    'gtTestSubject'                 => 'gtTestSubject.php',
+    'gtFunction'                    => 'gtFunction.php',
+    'gtMethod'                      => 'gtMethod.php',
+    'gtTestCaseWriter'              => 'gtTestCaseWriter.php',
+    'gtText'                        => 'gtText.php',
+ 
+ 
+ 
+    'gtCommandLineOptions'          => 'setup/gtCommandLineOptions.php',
+    'gtOptionalSections'            => 'setup/gtOptionalSections.php',
+    'gtMissingArgumentException'    => 'setup/exceptions/gtMissingArgumentException.php',
+    'gtUnknownOptionException'      => 'setup/exceptions/gtUnknownOptionException.php',
+    'gtUnknownSectionException'      => 'setup/exceptions/gtUnknownSectionException.php',
+    'gtMissingOptionsException'     => 'setup/exceptions/gtMissingOptionsException.php',
+ 
+    'gtPreCondition'                => 'setup/gtPreCondition.php',
+    'gtPreConditionList'            => 'setup/gtPreConditionList.php',
+    'gtIsSpecifiedTestType'         => 'setup/preconditions/gtIsSpecifiedTestType.php',
+    'gtIfClassHasMethod'            => 'setup/preconditions/gtIfClassHasMethod.php',
+    'gtIsSpecifiedFunctionOrMethod' => 'setup/preconditions/gtIsSpecifiedFunctionOrMethod.php',
+    'gtIsValidClass'                => 'setup/preconditions/gtIsValidClass.php',
+    'gtIsValidMethod'               => 'setup/preconditions/gtIsValidMethod.php',
+    'gtIsValidFunction'             => 'setup/preconditions/gtIsValidFunction.php',
+ 
+ 
+     'gtTestCase'                   => 'testcase/gtTestCase.php',
+     'gtVariationTestCase'          => 'testcase/gtVariationTestCase.php',
+     'gtVariationTestCaseFunction'  => 'testcase/gtVariationTestCaseFunction.php',
+     'gtVariationTestCaseMethod'    => 'testcase/gtVariationTestCaseMethod.php',
+ 
+     'gtBasicTestCase'              => 'testcase/gtBasicTestCase.php',
+     'gtBasicTestCaseFunction'      => 'testcase/gtBasicTestCaseFunction.php',
+     'gtBasicTestCaseMethod'        => 'testcase/gtBasicTestCaseMethod.php',
+ 
+     'gtErrorTestCase'              => 'testcase/gtErrorTestCase.php',
+     'gtErrorTestCaseFunction'      => 'testcase/gtErrorTestCaseFunction.php',
+     'gtErrorTestCaseMethod'        => 'testcase/gtErrorTestCaseMethod.php',
+ 
+     'gtVariationContainer'         => 'testcase/gtVariationContainer.php',
+     'gtVariationContainerMethod'   => 'testcase/gtVariationContainerMethod.php',
+     'gtVariationContainerFunction' => 'testcase/gtVariationContainerFunction.php',
+ );
+?>
+\ No newline at end of file
diff --git a/scripts/dev/generate-phpt/src/gtCodeSnippet.php b/scripts/dev/generate-phpt/src/gtCodeSnippet.php
new file mode 100644
index 0000000000..220fbdf699
--- /dev/null
+++ b/scripts/dev/generate-phpt/src/gtCodeSnippet.php
@@ -0,0 +1,72 @@
+<?php
+
+/**
+ * Retrieves code snippets for adding to test cases
+ * 
+ */
+class gtCodeSnippet
+{
+
+  /**
+   * get the code snippet and initialise an array with it
+   *
+   * @param string $name
+   * @return array
+   */
+  public static function get($name) {
+    
+    $filename = dirname(__FILE__) . '/codeSnippets/' . $name . '.txt';
+
+    if (!file_exists($filename)) {
+      throw new LogicException('The code snippet ' . $name . ' does not exist');
+    }
+    
+    $lines = file($filename);
+    foreach($lines as $l) {
+      $array[] = rtrim($l);
+    }
+    return $array;
+  }
+  
+  
+  /**
+   * Append the code snippet on to an existing array
+   *
+   * @param string $name
+   * @param array $array
+   * @return array
+   */
+  public static function append($name, $array) {
+    $filename = dirname(__FILE__) . '/codeSnippets/' . $name . '.txt';
+
+    if (!file_exists($filename)) {
+      throw new LogicException('The code snippet ' . $name . ' does not exist');
+    }
+
+    $text =  file($filename);
+    foreach ($text as $t) {
+      $array[] = rtrim($t);
+    }
+    
+    return $array;
+  }
+  
+  
+  /**
+   * Appends blank entries on to an array
+   *
+   * @param int $numberOfLines
+   * @param array $array
+   * @return array
+   */
+  public static function appendBlankLines($numberOfLines, $array) {
+
+    for ($i=0; $i< $numberOfLines; $i++) {
+      $array[] = "";
+    }
+    
+    return $array;
+  }
+  
+}
+?>
+\ No newline at end of file
diff --git a/scripts/dev/generate-phpt/src/gtFunction.php b/scripts/dev/generate-phpt/src/gtFunction.php
new file mode 100644
index 0000000000..74058216ee
--- /dev/null
+++ b/scripts/dev/generate-phpt/src/gtFunction.php
@@ -0,0 +1,48 @@
+<?php
+
+/**
+ * Class reperesents a single PHP function.
+ *
+ */
+class gtFunction extends gtTestSubject {
+
+  private $functionName;
+  
+  /**
+   * Set the name of the name of the function
+   *
+   * @param string $functionName
+   */
+  public function __construct($functionName)  {
+    $this->functionName = $functionName;
+  }
+
+
+  /**
+   * Get the names of function argments and initialise mandatory and optional argument arrays
+   *
+   */
+  public function setArgumentNames() {
+    $function= new ReflectionFunction($this->functionName);
+
+    foreach ($function->getParameters() as $i => $param) {
+      if($param->isOptional()) {
+        $this->optionalArgumentNames[] = $param->getName();
+      } else {
+        $this->mandatoryArgumentNames[] = $param->getName();
+      }
+    }
+  }
+
+
+  /**
+   * Return the name of the function
+   *
+   * @return string
+   */
+  public function getName() {
+    return $this->functionName;
+  }
+
+}
+?>
+\ No newline at end of file
diff --git a/scripts/dev/generate-phpt/src/gtMethod.php b/scripts/dev/generate-phpt/src/gtMethod.php
new file mode 100644
index 0000000000..820d7e0a76
--- /dev/null
+++ b/scripts/dev/generate-phpt/src/gtMethod.php
@@ -0,0 +1,139 @@
+<?php
+
+/**
+ * Class for method under test (see gtFunction for non-OO tests)
+ */
+class gtMethod  extends gtTestSubject {
+
+  private $className;
+  private $methodName;
+  private $constructorArgumentNames;
+  private $constructorArgumentList = '';
+  private $constructorInitialisationStatements;
+
+
+
+  /**
+   * Construct gtMethod object from the class and method names
+   *
+   * @param string $className
+   * @param string $methodName
+   */
+  public function __construct($className, $methodName) {
+    $this->className = $className;
+    $this->methodName = $methodName;
+  }
+
+
+  /**
+   * Set the names of the class constructor arguments. Take only mandatory argument names.
+   *
+   */
+  public function setConstructorArgumentNames() {
+    $reflectionClass = new ReflectionClass($this->className);
+    $constructor = $reflectionClass->getConstructor();
+    foreach($constructor->getParameters() as $i => $param) {
+      //if(!$param->isOptional()) {
+        $this->constructorArgumentNames[] = $param->getName();
+      //}
+    }
+  }
+
+  
+  /**
+   * Set the names of the mandatory and optional arguments to the method
+   *
+   */
+  public function setArgumentNames() {
+
+    $methodClass  = new reflectionMethod($this->className, $this->methodName);
+    $parameters = $methodClass->getParameters();
+
+    foreach ($methodClass->getParameters() as $i => $param) {
+      if($param->isOptional()) {
+        $this->optionalArgumentNames[] = $param->getName();
+      } else {
+        $this->mandatoryArgumentNames[] = $param->getName();
+      }
+
+    }
+  }
+
+
+  /**
+   * Return the list of constructor argument names
+   *
+   * @return array
+   */
+  public function getConstructorArgumentNames() {
+    return $this->constructorArgumentNames;
+  }
+
+  /**
+   * Return the name of the method
+   *
+   * @return string
+   */
+  public function getName() {
+    return $this->methodName;
+  }
+
+
+  /**
+   * Return the name of the class
+   *
+   * @return string
+   */
+  public function getClassName() {
+    return $this->className;
+  }
+  
+  /**
+   * Set the list of arguments to be passed to the constructor
+   *
+   */
+  public function setConstructorArgumentList() {
+    if(count ($this->constructorArgumentNames) > 0) {
+      
+      for( $i = 0; $i < count( $this->constructorArgumentNames ); $i++) {
+        $this->constructorArgumentList .= "\$".$this->constructorArgumentNames[$i].", ";
+      }
+      $this->constructorArgumentList = substr($this->constructorArgumentList, 0, -2);
+    }
+  }
+
+
+  /**
+   * Return the list of the arguments to be passed to the constructor
+   *
+   * @return string
+   */
+  public function getConstructorArgumentList() {
+    return $this->constructorArgumentList;
+  }
+
+  
+  /**
+   * Set up the source statements that initialise constructor arguments;
+   *
+   */
+  public function setConstructorInitStatements() {
+    if(count ($this->constructorArgumentNames) > 0) {
+      foreach( $this->constructorArgumentNames as $name) {
+        $this->constructorInitialisationStatements[] = "\$".$name." = ";
+      }
+    }
+
+  }
+
+  
+  /**
+   * Return the constructor initialisation statements
+   *
+   * @return array
+   */
+  public function getConstructorInitStatements() {
+    return $this->constructorInitialisationStatements;
+  }
+}
+?>
+\ No newline at end of file
diff --git a/scripts/dev/generate-phpt/src/gtTestCaseWriter.php b/scripts/dev/generate-phpt/src/gtTestCaseWriter.php
new file mode 100644
index 0000000000..cc57863d9b
--- /dev/null
+++ b/scripts/dev/generate-phpt/src/gtTestCaseWriter.php
@@ -0,0 +1,27 @@
+<?php
+
+/**
+ * Writes a single test case to a file
+ *
+ */
+class gtTestCaseWriter {
+  
+  public static function write($name, $string, $type, $count = 0) {
+    if ($type  == 'b') {
+    $fileName = $name."_basic.phpt";
+    }
+    
+    if ($type  == 'e') {
+     $fileName = $name."_error.phpt";
+    }
+    
+    if ($type  == 'v') {
+      $fileName = $name."_variation".$count.".phpt";
+    }
+    
+    $fh = fopen($fileName, 'w');
+    fwrite ($fh, $string);
+    fclose($fh);
+  }
+}
+?>
+\ No newline at end of file
diff --git a/scripts/dev/generate-phpt/src/gtTestSubject.php b/scripts/dev/generate-phpt/src/gtTestSubject.php
new file mode 100644
index 0000000000..9be1e74509
--- /dev/null
+++ b/scripts/dev/generate-phpt/src/gtTestSubject.php
@@ -0,0 +1,166 @@
+<?php
+abstract class gtTestSubject {
+
+  protected $optionalArgumentNames;
+  protected $mandatoryArgumentNames;
+
+  protected $extraArgumentList = '';
+  protected $shortArgumentList = '';
+
+  protected $allowedArgumentLists;
+
+  protected $maximumArgumentList;
+  
+  protected $initialisationStatements;
+
+
+  /** Return the list of all mandatory argument names
+   *
+   * @return array
+   */
+  public function getMandatoryArgumentNames() {
+    return $this->mandatoryArgumentNames;
+  }
+
+
+  /**
+   * Return the list of all optional argument names
+   *
+   * @return array
+   */
+  public function getOptionalArgumentNames() {
+    return $this->optionalArgumentNames;
+  }
+  
+  public function setArgumentLists() {
+    $this->setValidArgumentLists();
+    $this->setExtraArgumentList();
+    $this->setShortArgumentList();
+  }
+
+  /**
+   * Set the argument list to call the subject with. Adds one extra argument.
+   *
+   */
+  public function setExtraArgumentList() {
+    if(count ($this->mandatoryArgumentNames) > 0) {
+      for( $i = 0; $i < count( $this->mandatoryArgumentNames ); $i++) {
+        $this->extraArgumentList .= "\$".$this->mandatoryArgumentNames[$i].", ";
+      }
+    }
+     
+    if(count ($this->optionalArgumentNames) > 0) {
+      for( $i = 0; $i < count( $this->optionalArgumentNames ); $i++) {
+        $this->extraArgumentList .=  "\$".$this->optionalArgumentNames[$i].", ";
+      }
+    }
+
+    $this->extraArgumentList= $this->extraArgumentList. "\$extra_arg";
+  }
+   
+
+  /**
+   * Return the list of arguments as it appears in the function call
+   *
+   * @return string - list of arguments
+   */
+  public function getExtraArgumentList() {
+    return $this->extraArgumentList;
+  }
+
+
+  /**
+   * Set the list of function arguments to be one less that the number of mandatory arguments
+   *
+   */
+  public function setShortArgumentList() {
+
+    if(count ($this->mandatoryArgumentNames) > 0) {
+      for( $i = 0; $i < count( $this->mandatoryArgumentNames ) - 1; $i++) {
+        $this->shortArgumentList .= "\$".$this->mandatoryArgumentNames[$i].", ";
+      }
+      $this->shortArgumentList = substr($this->shortArgumentList, 0, -2);
+    }
+  }
+
+
+  /**
+   * Return the short list of arguments
+   *
+   * @return string - list of arguments
+   */
+  public function getShortArgumentList() {
+    return $this->shortArgumentList;
+  }
+
+
+  /**
+   * Construct the list of all possible ways to call the subject (function or method)
+   *
+   */
+  public function setValidArgumentLists() {
+    $this->allowedArgumentLists[0] = '';
+    if(count ($this->mandatoryArgumentNames) > 0) {
+      for( $i = 0; $i < count( $this->mandatoryArgumentNames ); $i++) {
+        $this->allowedArgumentLists[0] .= "\$".$this->mandatoryArgumentNames[$i].", ";
+      }
+    }
+     
+    if(count ($this->optionalArgumentNames) > 0) {
+      for( $i = 0; $i < count( $this->optionalArgumentNames ); $i++) {
+        $this->allowedArgumentLists[] = $this->allowedArgumentLists[$i]."\$".$this->optionalArgumentNames[$i].", ";
+        $this->allowedArgumentLists[$i] = substr ($this->allowedArgumentLists[$i], 0, -2);
+      }
+    }
+
+    $this->allowedArgumentLists[count($this->allowedArgumentLists) -1 ] = substr($this->allowedArgumentLists[count($this->allowedArgumentLists) -1 ], 0, -2);
+  }
+
+
+  /**
+   * Return the array of all possible sets of method/function arguments
+   *
+   * @return unknown
+   */
+  public function getValidArgumentLists() {
+    return $this->allowedArgumentLists;
+  }
+
+
+  /**
+   * Returns the argument list with teh greatest possible number of arguments.
+   *
+   * @return string
+   */
+  public function getMaximumArgumentList() {
+    return end($this->allowedArgumentLists);
+  }
+
+
+  /**
+   * Write initialisation statemenst for all the variables that might be used
+   *
+   */
+  public function setInitialisationStatements() {
+    if(count ($this->mandatoryArgumentNames) > 0) {
+      foreach( $this->mandatoryArgumentNames as $name) {
+        $this->initialisationStatements[] = "\$".$name." = ";
+      }
+    }
+    if(count ($this->optionalArgumentNames) > 0) {
+      foreach( $this->optionalArgumentNames as $name) {
+        $this->initialisationStatements[] = "\$".$name." = ";
+      }
+    }
+  }
+  
+  /**
+   * Return the initialisation statements
+   *
+   * @return unknown
+   */
+  public function getInitialisationStatements() {
+    return $this->initialisationStatements;
+  }
+}
+?>
+\ No newline at end of file
diff --git a/scripts/dev/generate-phpt/src/gtText.php b/scripts/dev/generate-phpt/src/gtText.php
new file mode 100644
index 0000000000..8cbd1650d4
--- /dev/null
+++ b/scripts/dev/generate-phpt/src/gtText.php
@@ -0,0 +1,27 @@
+<?php
+
+/**
+ * Get a text message
+ *
+ */
+class gtText
+{
+
+  /**
+   * Get the text message and return it
+   *
+   * @param string $name
+   * @return string
+   */
+  public static function get($name) {
+    $filename = dirname(__FILE__) . '/texts/' . $name . '.txt';
+
+    if (!file_exists($filename)) {
+      throw new LogicException('The text ' . $name . ' does not exist');
+    }
+
+    return file_get_contents($filename);
+  }
+}
+
+?>
+\ No newline at end of file
diff --git a/scripts/dev/generate-phpt/src/setup/exceptions/gtMissingArgumentException.php b/scripts/dev/generate-phpt/src/setup/exceptions/gtMissingArgumentException.php
new file mode 100644
index 0000000000..91638e5ade
--- /dev/null
+++ b/scripts/dev/generate-phpt/src/setup/exceptions/gtMissingArgumentException.php
@@ -0,0 +1,7 @@
+<?php
+
+  class gtMissingArgumentException extends RuntimeException
+  {
+  }
+
+?>
diff --git a/scripts/dev/generate-phpt/src/setup/exceptions/gtMissingOptionsException.php b/scripts/dev/generate-phpt/src/setup/exceptions/gtMissingOptionsException.php
new file mode 100644
index 0000000000..5bff5e01a0
--- /dev/null
+++ b/scripts/dev/generate-phpt/src/setup/exceptions/gtMissingOptionsException.php
@@ -0,0 +1,7 @@
+<?php
+
+ class gtMissingOptionsException extends RuntimeException
+  {
+  }
+
+?>
+\ No newline at end of file
diff --git a/scripts/dev/generate-phpt/src/setup/exceptions/gtUnknownOptionException.php b/scripts/dev/generate-phpt/src/setup/exceptions/gtUnknownOptionException.php
new file mode 100644
index 0000000000..9b1a820985
--- /dev/null
+++ b/scripts/dev/generate-phpt/src/setup/exceptions/gtUnknownOptionException.php
@@ -0,0 +1,7 @@
+<?php
+
+  class gtUnknownOptionException extends RuntimeException
+  {
+  }
+
+?>
diff --git a/scripts/dev/generate-phpt/src/setup/exceptions/gtUnknownSectionException.php b/scripts/dev/generate-phpt/src/setup/exceptions/gtUnknownSectionException.php
new file mode 100644
index 0000000000..c4843240d7
--- /dev/null
+++ b/scripts/dev/generate-phpt/src/setup/exceptions/gtUnknownSectionException.php
@@ -0,0 +1,6 @@
+<?php
+
+class gtUnknownSectionException extends RuntimeException
+  {
+  }
+?>
+\ No newline at end of file
diff --git a/scripts/dev/generate-phpt/src/setup/gtCommandLineOptions.php b/scripts/dev/generate-phpt/src/setup/gtCommandLineOptions.php
new file mode 100644
index 0000000000..0e4d878bab
--- /dev/null
+++ b/scripts/dev/generate-phpt/src/setup/gtCommandLineOptions.php
@@ -0,0 +1,98 @@
+<?php
+
+/**
+ * Parse command line options
+ *
+ */
+class gtCommandLineOptions {
+
+  protected $shortOptions = array(
+    'b',
+    'e',
+    'v',
+    'h',
+  );
+
+  protected $shortOptionsWithArgs = array(
+    'c',
+    'm',
+    'f',
+    'i',
+    's',
+    'x',
+    'k',
+  );
+  
+  protected $options;
+
+  protected function isShortOption($arg)
+  {
+    return (substr($arg, 0, 1) == '-') && (substr($arg, 1, 1) != '-');
+  }
+
+  public function isValidOptionArg($array, $index) {
+    if (!isset($array[$index]))
+    {
+      return false;
+    }
+    return substr($array[$index], 0, 1) != '-';
+  }
+
+
+  public function parse($argv)
+  {
+    if(count($argv) < 2) {
+      throw new gtMissingOptionsException('Command line options are required');
+    }
+    
+    for ($i=1; $i<count($argv); $i++) {
+
+      if ($this->isShortOption($argv[$i])) {
+        $option = substr($argv[$i], 1);
+      } else {
+        throw new gtUnknownOptionException('Unrecognised command line option ' . $argv[$i]);
+      }
+
+      if (!in_array($option, array_merge($this->shortOptions, $this->shortOptionsWithArgs)))
+      {
+        throw new gtUnknownOptionException('Unknown option ' . $argv[$i]);
+      }
+
+      if (in_array($option, $this->shortOptions)) {
+        $this->options[$option] = true;
+        continue;
+      }
+
+      if (!$this->isValidOptionArg($argv, $i + 1))
+      {
+        throw new gtMissingArgumentException('Missing argument for command line option ' . $argv[$i]);
+      }
+
+      $i++;
+      $this->options[$option] = $argv[$i];
+    }
+  }
+  
+ /**
+   *
+   */
+  public function getOption($option)
+  {
+    if (!isset($this->options[$option])) {
+      return false;
+    }
+    return $this->options[$option];
+  }
+
+
+  /**
+   * Check whether an option exists
+   */
+  public function hasOption($option)
+  {
+    return isset($this->options[$option]);
+  }
+
+
+}
+?>
+\ No newline at end of file
diff --git a/scripts/dev/generate-phpt/src/setup/gtOptionalSections.php b/scripts/dev/generate-phpt/src/setup/gtOptionalSections.php
new file mode 100644
index 0000000000..1d2a163175
--- /dev/null
+++ b/scripts/dev/generate-phpt/src/setup/gtOptionalSections.php
@@ -0,0 +1,85 @@
+<?php
+class gtOptionalSections {
+
+  private $optSections = array(
+    'skipif' => false,
+    'ini'    => false,
+    'clean'  => false,
+    'done'   => false,
+  );
+
+  private $skipifKey = '';
+  private $skipifExt = '';
+
+
+  public function setOptions($commandLineOptions) {
+    if($commandLineOptions->hasOption('s')) {
+      $options = explode(':', $commandLineOptions->getOption('s'));
+
+      foreach($options as $option) {
+
+        if(array_key_exists($option, $this->optSections )) {
+          $this->optSections[$option] = true;
+        } else {
+          throw new gtUnknownSectionException('Unrecognised optional section');
+        }
+      }
+
+      if($commandLineOptions->hasOption('k')) {
+        $this->skipifKey = $commandLineOptions->getOption('k');
+      }
+      
+      if($commandLineOptions->hasOption('x')) {
+        $this->skipifExt = $commandLineOptions->getOption('x');
+      }
+      
+    }
+  }
+
+
+
+  public function getOptions() {
+    return $this->optSections;
+  }
+
+
+  public function getSkipifKey() {
+    return $this->skipifKey;
+  }
+  
+  public function getSkipifExt() {
+    return $this->skipifExt;
+  }
+
+  public function hasSkipif() {
+    return $this->optSections['skipif'];
+  }
+
+  public function hasSkipifKey() {
+    if($this->skipifKey != '') {
+      return true;
+    }
+    return false;
+  }
+  
+  public function hasSkipifExt() {
+    if($this->skipifExt != '') {
+      return true;
+    }
+    return false;
+  }
+  public function hasIni() {
+    return $this->optSections['ini'];
+  }
+
+  public function hasClean() {
+    return $this->optSections['clean'];
+  }
+  
+  public function hasDone() {
+    return $this->optSections['done'];
+  }
+
+
+}
+?>
+\ No newline at end of file
diff --git a/scripts/dev/generate-phpt/src/setup/gtPreCondition.php b/scripts/dev/generate-phpt/src/setup/gtPreCondition.php
new file mode 100644
index 0000000000..858395bc9d
--- /dev/null
+++ b/scripts/dev/generate-phpt/src/setup/gtPreCondition.php
@@ -0,0 +1,14 @@
+<?php
+
+/**
+ * parent class for preconditions
+ *
+ */
+abstract class gtPreCondition {
+  
+  abstract public function check($clo); 
+  
+  abstract public function getMessage(); 
+  
+}
+?>
+\ No newline at end of file
diff --git a/scripts/dev/generate-phpt/src/setup/gtPreConditionList.php b/scripts/dev/generate-phpt/src/setup/gtPreConditionList.php
new file mode 100644
index 0000000000..06c17521f2
--- /dev/null
+++ b/scripts/dev/generate-phpt/src/setup/gtPreConditionList.php
@@ -0,0 +1,33 @@
+<?php
+
+/**
+ * List of preconditions.
+ *
+ */
+class gtPreConditionList {
+  
+  private $preConditions = array(
+      'gtIsSpecifiedTestType',
+      'gtIsSpecifiedFunctionOrMethod',  
+      'gtIfClassHasMethod',
+      'gtIsValidClass',
+      'gtIsValidFunction',
+      'gtIsValidMethod',
+  );
+
+
+  /**
+   * Create an instance of each pre-condition and run their check methods
+   *
+   */
+  public function check($clo) {
+    foreach ($this->preConditions as $preCon) {
+      $checkThis = new $preCon;
+      if(!$checkThis->check($clo)) {
+        echo $checkThis->getMessage();
+        die(gtText::get('help'));
+      }
+    }
+  }
+}
+?>
+\ No newline at end of file
diff --git a/scripts/dev/generate-phpt/src/setup/preconditions/gtIfClassHasMethod.php b/scripts/dev/generate-phpt/src/setup/preconditions/gtIfClassHasMethod.php
new file mode 100644
index 0000000000..c91b210714
--- /dev/null
+++ b/scripts/dev/generate-phpt/src/setup/preconditions/gtIfClassHasMethod.php
@@ -0,0 +1,24 @@
+<?php
+
+/**
+ * If use has requested a class check that method is specified
+ *
+ */
+class gtIfClassHasMethod extends gtPreCondition {
+  
+  public function check( $clo) {
+    if($clo->hasOption('c')) {
+      if(!$clo->hasOption('m')) {
+        return false;
+      }
+      return  true;
+    }
+    return true;
+  }
+  
+  public function getMessage() {
+    return gtText::get('methodNotSpecified');
+  }
+
+}
+?>
+\ No newline at end of file
diff --git a/scripts/dev/generate-phpt/src/setup/preconditions/gtIsSpecifiedFunctionOrMethod.php b/scripts/dev/generate-phpt/src/setup/preconditions/gtIsSpecifiedFunctionOrMethod.php
new file mode 100644
index 0000000000..7495c73eca
--- /dev/null
+++ b/scripts/dev/generate-phpt/src/setup/preconditions/gtIsSpecifiedFunctionOrMethod.php
@@ -0,0 +1,21 @@
+<?php
+
+/**
+ * Check that either a method or a function is specified
+ *
+ */
+class gtIsSpecifiedFunctionOrMethod extends gtPreCondition {
+  
+  public function check( $clo) {
+    if($clo->hasOption('f') || $clo->hasOption('m')) {
+    
+        return true;
+      }
+    return false;
+  }
+  
+  public function getMessage() {
+    return gtText::get('functionOrMethodNotSpecified');
+  }
+}
+?>
+\ No newline at end of file
diff --git a/scripts/dev/generate-phpt/src/setup/preconditions/gtIsSpecifiedTestType.php b/scripts/dev/generate-phpt/src/setup/preconditions/gtIsSpecifiedTestType.php
new file mode 100644
index 0000000000..40530f3aca
--- /dev/null
+++ b/scripts/dev/generate-phpt/src/setup/preconditions/gtIsSpecifiedTestType.php
@@ -0,0 +1,21 @@
+<?php
+
+/**
+ * Check that b|c|v is specified
+ *
+ */
+class gtIsSpecifiedTestType extends gtPreCondition {
+  
+  public function check( $clo) {
+    if($clo->hasOption('b') || $clo->hasOption('e') || $clo->hasOption('v') ) {
+    
+        return true;
+      }
+    return false;
+  }
+  
+  public function getMessage() {
+    return gtText::get('testTypeNotSpecified');
+  }
+}
+?>
+\ No newline at end of file
diff --git a/scripts/dev/generate-phpt/src/setup/preconditions/gtIsValidClass.php b/scripts/dev/generate-phpt/src/setup/preconditions/gtIsValidClass.php
new file mode 100644
index 0000000000..a39bab453e
--- /dev/null
+++ b/scripts/dev/generate-phpt/src/setup/preconditions/gtIsValidClass.php
@@ -0,0 +1,24 @@
+<?php
+
+/**
+ * Check that the class name is valid
+ *
+ */
+class gtIsValidClass extends gtPreCondition {
+
+  public function check( $clo) {
+    if($clo->hasOption('c') ) {
+      $className = $clo->getOption('c');
+      if( in_array( $className, get_declared_classes() ) ) {
+        return true;
+      }
+      return false;
+    }
+    return true;
+  }
+
+  public function getMessage() {
+    return gtText::get('unknownClass');
+  }
+}
+?>
+\ No newline at end of file
diff --git a/scripts/dev/generate-phpt/src/setup/preconditions/gtIsValidFunction.php b/scripts/dev/generate-phpt/src/setup/preconditions/gtIsValidFunction.php
new file mode 100644
index 0000000000..ed91c2ca3b
--- /dev/null
+++ b/scripts/dev/generate-phpt/src/setup/preconditions/gtIsValidFunction.php
@@ -0,0 +1,25 @@
+<?php
+
+/**
+ * Check that the function name is valid
+ *
+ */
+class gtIsValidFunction extends gtPreCondition {
+
+  public function check( $clo) {
+    if($clo->hasOption('f') ) {
+      $function = $clo->getOption('f');
+      $functions = get_defined_functions();
+      if( in_array( $function, $functions['internal'] ) ) {
+        return true;
+      }
+      return false;
+    }
+    return true;
+  }
+
+  public function getMessage() {
+    return gtText::get('unknownFunction');
+  }
+}
+?>
+\ No newline at end of file
diff --git a/scripts/dev/generate-phpt/src/setup/preconditions/gtIsValidMethod.php b/scripts/dev/generate-phpt/src/setup/preconditions/gtIsValidMethod.php
new file mode 100644
index 0000000000..5f16d98f30
--- /dev/null
+++ b/scripts/dev/generate-phpt/src/setup/preconditions/gtIsValidMethod.php
@@ -0,0 +1,28 @@
+<?php
+
+/**
+ * Check that teh method name is valid
+ *
+ */
+class gtIsValidMethod extends gtPreCondition {
+
+ public function check( $clo) {
+    if($clo->hasOption('m') ) {
+      $className = $clo->getOption('c');
+      $class = new ReflectionClass($className);
+      $methods = $class->getMethods();
+      foreach($methods as $method) {
+        if($clo->getOption('m') == $method->getName()) {
+          return true;
+        }
+      }
+      return false;
+    }
+    return true;
+  }
+
+  public function getMessage() {
+    return gtText::get('unknownMethod');
+  }
+}
+?>
+\ No newline at end of file
diff --git a/scripts/dev/generate-phpt/src/testcase/gtBasicTestCase.php b/scripts/dev/generate-phpt/src/testcase/gtBasicTestCase.php
new file mode 100644
index 0000000000..ac7eb5cb36
--- /dev/null
+++ b/scripts/dev/generate-phpt/src/testcase/gtBasicTestCase.php
@@ -0,0 +1,37 @@
+<?php
+
+/**
+ * Class for basic test case construction
+ */
+
+abstract class gtBasicTestCase extends gtTestCase {
+
+  protected $subject;
+
+
+  /**
+   * Returns an instance of a test case for a method or a function
+   *
+   * @param string $type
+   * @return test case object
+   */
+  public static function getInstance($optionalSections, $type = 'function') {
+    if($type == 'function') {
+      return new gtBasicTestCaseFunction($optionalSections);
+    }
+    if($type =='method') {
+      return new gtBasicTestCaseMethod($optionalSections);
+    }
+  }
+  
+  public function constructSubjectCalls() {
+        $this->argInit();
+        $this->subjectCalls();
+  }
+  
+  public function addBasicEcho() {
+    $this->testCase[] = "echo \"*** Test by calling method or function with its expected arguments ***\\n\"";
+    $this->testCase = gtCodeSnippet::appendBlankLines(1, $this->testCase );
+  }
+}
+?>
+\ No newline at end of file
diff --git a/scripts/dev/generate-phpt/src/testcase/gtBasicTestCaseFunction.php b/scripts/dev/generate-phpt/src/testcase/gtBasicTestCaseFunction.php
new file mode 100644
index 0000000000..f64c6daf32
--- /dev/null
+++ b/scripts/dev/generate-phpt/src/testcase/gtBasicTestCaseFunction.php
@@ -0,0 +1,62 @@
+<?php
+
+/**
+ * Basic test case for a PHP function
+ *
+ */
+class gtBasicTestCaseFunction extends gtBasicTestCase {
+
+
+  public function __construct($opt) {
+    $this->optionalSections = $opt;
+  }
+
+  /**
+   * Set the function name
+   *
+   * @param gtFunction $function
+   */
+  public function setFunction($function) {
+    $this->subject = $function;
+  }
+
+  public function constructTestCase() {
+    $this->constructCommonHeaders();
+    
+    $this->addBasicEcho();
+    
+    $this->constructSubjectCalls();
+    
+    $this->constructCommonClosing();
+   
+  }
+
+
+  /**
+   * Construct test case header
+   *
+   */
+  public function testHeader() {
+    //Opening section and start of test case array.
+    $this->testCase[] = "--TEST--";
+    $this->testCase[] = "Test function ".$this->subject->getName()."() by calling it with its expected arguments";
+  }
+
+  /**
+   * Add the test section to call the function
+   *
+   */
+  public function subjectCalls() {
+    // Construct the argument list to pass to the function being tested
+    $lists = $this->subject->getValidArgumentLists();
+
+    foreach($lists as $list){
+
+      $this->testCase = gtCodeSnippet::appendBlankLines(1, $this->testCase );
+      $this->testCase[] = "var_dump(".$this->subject->getName()."( ".$list." ) );";
+    }
+    $this->testCase = gtCodeSnippet::appendBlankLines(2, $this->testCase );
+  }
+
+}
+?>
+\ No newline at end of file
diff --git a/scripts/dev/generate-phpt/src/testcase/gtBasicTestCaseMethod.php b/scripts/dev/generate-phpt/src/testcase/gtBasicTestCaseMethod.php
new file mode 100644
index 0000000000..3d3896e233
--- /dev/null
+++ b/scripts/dev/generate-phpt/src/testcase/gtBasicTestCaseMethod.php
@@ -0,0 +1,52 @@
+<?php
+
+/**
+ * Class for basic test case construction for class methods
+ */
+class gtBasicTestCaseMethod extends gtBasicTestCase {
+
+  public function __construct($opt) {
+    $this->optionalSections = $opt;
+  }
+
+  /**
+   * Set the method 
+   *
+   * @param gtMethod $method
+   */
+  public function setMethod($method) {
+    $this->subject = $method;
+  }
+  
+public function constructTestCase() {
+    $this->constructCommonHeaders();
+
+    $this->addBasicEcho();
+    
+    $this->constructorArgInit();
+    $this->constructorCreateInstance();
+    
+    $this->constructSubjectCalls();
+    
+    $this->constructCommonClosing();
+    
+  }
+
+  public function testHeader() {
+    $this->testCase[] = "--TEST--";
+    $this->testCase[] = "Test class ".$this->subject->getClassName()." method  ".$this->subject->getName()."() by calling it with its expected arguments";
+    
+  }
+  
+  public function subjectCalls() {
+    $lists = $this->subject->getValidArgumentLists();
+
+    foreach($lists as $list){
+      $this->testCase[] = "var_dump( \$class->".$this->subject->getName()."( ".$list." ) );";
+      $this->testCase = gtCodeSnippet::appendBlankLines(1, $this->testCase );
+    }
+    $this->testCase = gtCodeSnippet::appendBlankLines(2, $this->testCase );    
+  }
+
+}
+?>
+\ No newline at end of file
diff --git a/scripts/dev/generate-phpt/src/testcase/gtErrorTestCase.php b/scripts/dev/generate-phpt/src/testcase/gtErrorTestCase.php
new file mode 100644
index 0000000000..c2b388dd81
--- /dev/null
+++ b/scripts/dev/generate-phpt/src/testcase/gtErrorTestCase.php
@@ -0,0 +1,53 @@
+<?php
+
+/**
+ * Class for simple errors - one too many args and one too few
+ */
+
+abstract class gtErrorTestCase extends gtTestCase {
+
+  protected $shortArgumentList = '';
+  protected $longArgumentList = '';
+
+
+  /**
+   * Return instance of either method or function error test case
+   *
+   * @param string $type
+   * @return test case object
+   */
+  public static function getInstance($optionalSections, $type = 'function') {
+     
+    if($type == 'function') {
+      return new gtErrorTestCaseFunction($optionalSections);
+    }
+    if($type =='method') {
+      return new gtErrorTestCaseMethod($optionalSections);
+    }
+
+  }
+
+  public function getShortArgumentList() {
+    return $this->shortArgumentList;
+  }
+
+  public function getLongArgumentList() {
+    return $this->longArgumentList;
+  }
+  
+  public function constructSubjectCalls() {
+    $this->argInit();
+    
+    //Initialise the additional argument
+    $this->testCase[] = "\$extra_arg = ";
+    
+    $this->subjectCalls();
+  }
+  
+ public function addErrorEcho() {
+    $this->testCase[] = "echo \"*** Test by calling method or function with incorrect numbers of arguments ***\\n\"";
+    $this->testCase = gtCodeSnippet::appendBlankLines(1, $this->testCase );
+  }
+}
+
+?>
+\ No newline at end of file
diff --git a/scripts/dev/generate-phpt/src/testcase/gtErrorTestCaseFunction.php b/scripts/dev/generate-phpt/src/testcase/gtErrorTestCaseFunction.php
new file mode 100644
index 0000000000..2453acf6fd
--- /dev/null
+++ b/scripts/dev/generate-phpt/src/testcase/gtErrorTestCaseFunction.php
@@ -0,0 +1,57 @@
+<?php
+
+/**
+ * Error test case for a PHP function
+ *
+ */
+class gtErrorTestCaseFunction extends gtErrorTestCase {
+
+  public function __construct($opt) {
+    $this->optionalSections = $opt;
+  }
+
+  /**
+   * Set the function name
+   *
+   * @param string $function
+   */
+  public function setFunction($function) {
+    $this->subject = $function;
+  }
+
+
+  /**
+   * Construct the test case as an array of strings
+   *
+   */
+  public function constructTestCase() {
+    $this->constructCommonHeaders();
+    
+    $this->addErrorEcho();
+      
+    $this->constructSubjectCalls();
+    
+    $this->constructCommonClosing();
+    
+  }
+
+
+  public function testHeader() {
+    $this->testCase[] = "--TEST--";
+    $this->testCase[] = "Test function ".$this->subject->getName()."() by calling it more than or less than its expected arguments";
+  }
+
+  public function subjectCalls() {
+    // Construct the argument lists to pass to the function being tested
+    $list = $this->subject->getExtraArgumentList();
+    $this->testCase = gtCodeSnippet::appendBlankLines(1, $this->testCase );
+    $this->testCase[] = "var_dump(".$this->subject->getName()."( ".$list." ) );";
+
+    $list = $this->subject->getShortArgumentList();
+    $this->testCase = gtCodeSnippet::appendBlankLines(1, $this->testCase );
+    $this->testCase[] = "var_dump(".$this->subject->getName()."( ".$list." ) );";
+    $this->testCase = gtCodeSnippet::appendBlankLines(2, $this->testCase );
+  }
+
+}
+?>
+\ No newline at end of file
diff --git a/scripts/dev/generate-phpt/src/testcase/gtErrorTestCaseMethod.php b/scripts/dev/generate-phpt/src/testcase/gtErrorTestCaseMethod.php
new file mode 100644
index 0000000000..647e52f93e
--- /dev/null
+++ b/scripts/dev/generate-phpt/src/testcase/gtErrorTestCaseMethod.php
@@ -0,0 +1,59 @@
+<?php
+
+/**
+ * Error test case for a PHP method
+ *
+ */
+class gtErrorTestCaseMethod extends gtErrorTestCase {
+
+  public function __construct($opt) {
+    $this->optionalSections = $opt;
+  }
+  private $method;
+
+  /**
+   * Set the method name
+   *
+   * @param string $method
+   */
+  public function setMethod($method) {
+    $this->subject = $method;
+  }
+
+
+  /**
+   * Construct the test case as an array of strings
+   *
+   */
+  public function constructTestCase() {
+    $this->constructCommonHeaders();
+    
+    $this->addErrorEcho();
+    
+    $this->constructorArgInit();
+    $this->constructorCreateInstance();
+    
+    $this->constructSubjectCalls();
+    
+    $this->constructCommonClosing();
+  }
+ 
+  public function testHeader() {
+    $this->testCase[] = "--TEST--";
+    $this->testCase[] = "Test class ".$this->subject->getClassName()." method ".$this->subject->getName()."() by calling it more than or less than its expected arguments";
+  }
+ 
+  public function subjectCalls() {
+
+    // Construct the argument list to pass to the method being tested
+    $list = $this->subject->getExtraArgumentList();
+    $this->testCase = gtCodeSnippet::appendBlankLines(1, $this->testCase );
+    $this->testCase[] = "var_dump(".$this->subject->getName()."( ".$list." ) );";
+    
+    $list = $this->subject->getShortArgumentList();
+    $this->testCase = gtCodeSnippet::appendBlankLines(1, $this->testCase );
+    $this->testCase[] = "var_dump(".$this->subject->getName()."( ".$list." ) );";
+  
+  }
+}
+?>
+\ No newline at end of file
diff --git a/scripts/dev/generate-phpt/src/testcase/gtTestCase.php b/scripts/dev/generate-phpt/src/testcase/gtTestCase.php
new file mode 100644
index 0000000000..cb67aa345d
--- /dev/null
+++ b/scripts/dev/generate-phpt/src/testcase/gtTestCase.php
@@ -0,0 +1,230 @@
+<?php
+
+/**
+ * Class for all test cases
+ */
+abstract class gtTestCase {
+
+
+  /**
+   * The subject of the test, may be either a function (gtFunction) or a method (gtMethod)
+   *
+   * @var gtMethod or gtFunction
+   */
+  protected $subject;
+
+
+  /**
+   * Arry of strings containing the test case
+   *
+   * @var array
+   */
+  protected $testCase;
+
+
+  /**
+   * Object containing teh ooptional sections that may be added to the test case
+   *
+   * @var gtOptionalSections
+   */
+  protected $optionalSections;
+
+
+  /**
+   * Convert test case from array to string
+   *
+   * @return string
+   */
+  public function toString() {
+    $testCaseString = "";
+    foreach($this->testCase as $line) {
+      $testCaseString .= $line."\n";
+    }
+    return $testCaseString;
+  }
+
+
+
+  /**
+   * Returns test case as a array
+   *
+   * @return array
+   */
+  public function getTestCase() {
+    return $this->testCase;
+  }
+
+
+  /**
+   * Construct the common headers (title, file section..) of the test case
+   *
+   */
+  public function ConstructCommonHeaders() {
+    $this->testHeader();
+
+    if($this->optionalSections->hasSkipif()) {
+      $this->addSkipif();
+    }
+
+    if($this->optionalSections->hasIni()) {
+      $this->addIni();
+    }
+
+    $this->fileOpening();
+  }
+
+
+  /**
+   * Construct the common closing statements (clean, done, EXPECTF...)
+   *
+   */
+  public function ConstructCommonClosing() {
+    $this->fileClosing();
+     
+    if ($this->optionalSections->hasDone()) {
+      $this->addDone();
+    }
+     
+    if ($this->optionalSections->hasClean()) {
+      $this->addClean();
+    }
+
+    $this->addExpectf();
+  }
+
+  /**
+   * Start the FILE section of the test
+   *
+   */
+  public function fileOpening() {
+    $this->testCase[] = "--FILE--";
+    $this->testCase[] = "<?php";
+    $this->testCase = gtCodeSnippet::appendBlankLines(2, $this->testCase );
+  }
+
+
+  /**
+   * Add contructor argument initialisation to test case
+   *
+   */
+  public function constructorArgInit() {
+    $conStatements = $this->subject->getConstructorInitStatements();
+    foreach($conStatements as $statement) {
+      $this->testCase[] = $statement;
+    }
+  }
+
+
+  /**
+   * Create instance of class in the test case
+   *
+   */
+  public function constructorCreateInstance() {
+    $constructorList = $this->subject->getConstructorArgumentList();
+    $this->testCase[] = "\$class = new ".$this->subject->getClassName()."( ".$constructorList." );";
+    $this->testCase = gtCodeSnippet::appendBlankLines(2, $this->testCase );
+  }
+
+
+  /**
+   * Add function or method initilaisation statements to the test case
+   *
+   */
+  public function argInit() {
+    $statements = $this->subject->getInitialisationStatements();
+    foreach($statements as $statement) {
+      $this->testCase[] = $statement;
+    }
+    $this->testCase = gtCodeSnippet::appendBlankLines(2, $this->testCase );
+  }
+
+
+  /**
+   * Add FILE section closing tag to teh test case
+   *
+   */
+  public function fileClosing() {
+    $this->testCase[] = "?>";
+  }
+
+
+  /**
+   * Add a skipif section to the test case
+   *
+   */
+  public function addSkipif() {
+    $this->testCase[] = "--SKIPIF--";
+    $this->testCase[] = "<?php";
+    if($this->optionalSections->hasSkipifKey()) {
+      $key = $this->optionalSections->getSkipifKey();
+      //test standard skipif sections
+      if($key == 'win') {
+        $this->testCase = gtCodeSnippet::append('skipifwin', $this->testCase);
+      }
+      if($key == 'notwin' ) {
+        $this->testCase = gtCodeSnippet::append('skipifnotwin', $this->testCase);
+      }
+
+      if($key == '64b' ) {
+        $this->testCase = gtCodeSnippet::append('skipif64b', $this->testCase);
+      }
+
+      if($key == 'not64b' ) {
+        $this->testCase = gtCodeSnippet::append('skipifnot64b', $this->testCase);
+      }
+    }
+
+    if($this->optionalSections->hasSkipifExt()) {
+      $ext = $this->optionalSections->getSkipifExt();
+      $this->testCase[] = "if (!extension_loaded('$ext')) die ('skip $ext extension not available in this build');";
+    }
+    $this->testCase[] = "?>";
+  }
+
+
+  /**
+   * Add an INI section to the test case
+   *
+   */
+  public function addIni() {
+    $this->testCase[] = "--INI--";
+    $this->testCase[] = "";
+  }
+
+
+  /**
+   * Add a clean section to the test case
+   *
+   */
+  public function addClean() {
+    $this->testCase[] = "--CLEAN--";
+    $this->testCase[] = "<?php";
+    $this->testCase[] = "?>";
+  }
+
+
+  /**
+   * Add a ===DONE=== statement to the test case
+   *
+   */
+  public function addDone() {
+    $this->testCase[] = "===DONE===";
+  }
+
+
+  /**
+   * Add an EXPECTF section
+   *
+   */
+  public function addExpectf() {
+    $this->testCase[] = "--EXPECTF--";
+    if ($this->optionalSections->hasDone() ){
+      $this->testCase[] = '===DONE===';
+    }
+  }
+
+  public function getOpt() {
+    return $this->optionalSections;
+  }
+}
+?>
+\ No newline at end of file
diff --git a/scripts/dev/generate-phpt/src/testcase/gtVariationContainer.php b/scripts/dev/generate-phpt/src/testcase/gtVariationContainer.php
new file mode 100644
index 0000000000..59951707ce
--- /dev/null
+++ b/scripts/dev/generate-phpt/src/testcase/gtVariationContainer.php
@@ -0,0 +1,54 @@
+<?php
+
+/**
+ * Container for all possible variation test cases
+ */
+abstract class gtVariationContainer {
+  
+  protected $variationTests;
+  
+  protected $dataTypes = array (
+                         'array',
+                         'boolean',
+                         'emptyUnsetUndefNull',
+                         'float',
+                         'int',
+                         'object',
+                         'string',
+                         );
+  
+  
+                     
+  /**
+   * Return an instance of a containers for either function or method tests
+   *
+   * @param string $type
+   * @return variation test container
+   */
+   public static function getInstance ($optionalSections, $type = 'function') {
+    
+    if($type == 'function') {
+      return new gtVariationContainerFunction($optionalSections);
+    }
+    if($type =='method') {
+      return new gtVariationContainerMethod($optionalSections);
+    }
+    
+  }
+  
+  
+  public function constructAll() {
+  }
+  
+  
+  /**
+   * Returns all varaition tests as an array of arrays
+   *
+   * @return string
+   */
+  public function getVariationTests() {
+    return $this->variationTests;
+  }
+  
+}
+?>
+\ No newline at end of file
diff --git a/scripts/dev/generate-phpt/src/testcase/gtVariationContainerFunction.php b/scripts/dev/generate-phpt/src/testcase/gtVariationContainerFunction.php
new file mode 100644
index 0000000000..dfee4ea75e
--- /dev/null
+++ b/scripts/dev/generate-phpt/src/testcase/gtVariationContainerFunction.php
@@ -0,0 +1,43 @@
+<?php
+
+/**
+ * Container for all possible variation test cases of functions
+ */
+class gtVariationContainerFunction extends gtVariationContainer {
+  
+  protected $function;
+  protected $optionalSections;
+  
+  public function __construct($osl) {
+    $this->optionalSections = $osl;
+  }
+  
+  /**
+   * Sets function being tested
+   *
+   * @param gtFunction $function
+   */
+  public function setFunction(gtFunction $function) {
+    $this->function = $function;
+  }
+  
+  
+  /**
+   * Constucts all possible variation testcases in array $this->variationTests
+   *
+   */
+  public function constructAll() {
+    
+        
+    $numberOfArguments = count($this->function->getMandatoryArgumentNames()) + count($this->function->getOptionalArgumentNames());
+    for($i = 1; $i <= $numberOfArguments; $i++) {
+      foreach ($this->dataTypes as $d) {
+        $testCase = gtVariationTestCase::getInstance($this->optionalSections);
+        $testCase->setUp($this->function, $i, $d);
+        $testCase->constructTestCase();
+        $this->variationTests[] = $testCase->toString();
+      }
+    }
+  }  
+}
+?>
+\ No newline at end of file
diff --git a/scripts/dev/generate-phpt/src/testcase/gtVariationContainerMethod.php b/scripts/dev/generate-phpt/src/testcase/gtVariationContainerMethod.php
new file mode 100644
index 0000000000..bee26b08aa
--- /dev/null
+++ b/scripts/dev/generate-phpt/src/testcase/gtVariationContainerMethod.php
@@ -0,0 +1,46 @@
+<?php
+/**
+ * Container for all possible variation test cases for a method
+ */
+class gtVariationContainerMethod extends gtVariationContainer {
+  
+  protected $method;
+  protected $optionalSections;
+  
+  public function __construct($osl) {
+    $this->optionalSections = $osl;
+  }
+  
+  
+  /**
+   * Sets the method to be tested
+   *
+   * @param gtMethod $method
+   */
+  public function setMethod(gtMethod $method) {
+    $this->method = $method;
+  }
+  
+  
+  /**
+   * Constructs all variation tests in $this_variationTests
+   *
+   */
+  public function constructAll() {
+    
+    $numberOfArguments = count($this->method->getMandatoryArgumentNames()) + count($this->method->getOptionalArgumentNames());
+    
+    for($i = 1; $i <= $numberOfArguments; $i++) {
+      
+      foreach ($this->dataTypes as $d) {
+        
+        $testCase = gtVariationTestCase::getInstance($this->optionalSections, 'method');
+        $testCase->setUp($this->method, $i, $d);
+        $testCase->constructTestCase();
+        $this->variationTests[] = $testCase->toString();
+        
+      }
+    }
+  }  
+}
+?>
+\ No newline at end of file
diff --git a/scripts/dev/generate-phpt/src/testcase/gtVariationTestCase.php b/scripts/dev/generate-phpt/src/testcase/gtVariationTestCase.php
new file mode 100644
index 0000000000..039367d5b3
--- /dev/null
+++ b/scripts/dev/generate-phpt/src/testcase/gtVariationTestCase.php
@@ -0,0 +1,55 @@
+
+<?php
+
+/**
+ * Class for extended variations. Needs 'data type' and argument to vary
+ */
+
+abstract class gtVariationTestCase extends gtTestCase {
+
+
+  /**
+   * Returns an instance of a test case for a method or a function
+   *
+   * @param string $type
+   * @return test case object
+   */
+  public static function getInstance($optionalSections, $type = 'function') {
+     
+    if($type == 'function') {
+      return new gtVariationTestCaseFunction($optionalSections);
+    }
+    if($type =='method') {
+      return new gtVariationTestCaseMethod($optionalSections);
+    }
+
+  }
+
+  public function argInitVariation() {
+    $statements = $this->subject->getInitialisationStatements();
+    for($i=0; $i<count($statements); $i++) {
+      if($i != ( $this->argumentNumber -1) ) {
+        $this->testCase[] = $statements[$i];
+      }
+    }
+    $this->testCase = gtCodeSnippet::appendBlankLines(2, $this->testCase );
+  }
+
+  public function addVariationCode() {
+    $this->testCase = gtCodeSnippet::append($this->variationData, $this->testCase);
+    $this->testCase = gtCodeSnippet::appendBlankLines(2, $this->testCase );
+  }
+
+  public function constructSubjectCalls() {
+    $this->argInitVariation();
+    $this->addVariationCode();
+    $this->subjectCalls();
+  }
+
+  public function addVariationEcho() {
+    $this->testCase[] = "echo \"*** Test substituting argument ".$this->argumentNumber." with ".$this->variationData." values ***\\n\";";
+    $this->testCase = gtCodeSnippet::appendBlankLines(1, $this->testCase );
+  }
+
+}
+?>
+\ No newline at end of file
diff --git a/scripts/dev/generate-phpt/src/testcase/gtVariationTestCaseFunction.php b/scripts/dev/generate-phpt/src/testcase/gtVariationTestCaseFunction.php
new file mode 100644
index 0000000000..7bf1c8b778
--- /dev/null
+++ b/scripts/dev/generate-phpt/src/testcase/gtVariationTestCaseFunction.php
@@ -0,0 +1,64 @@
+<?php
+
+/**
+ * Class for variation tests for a PHP function
+ */
+class gtVariationTestCaseFunction extends gtVariationTestCase {
+
+  protected $argumentNumber;
+  protected $variationData;
+  protected $testCase;
+
+  public function __construct($opt) {
+    $this->optionalSections = $opt;
+  }
+  /**
+   * Set data neede to construct variation tests
+   *
+   * @param gtfunction $function
+   * @param string $argumentNumber
+   * @param string $variationData
+   */
+  public function setUp(gtfunction $function, $argumentNumber, $variationData) {
+    $this->subject = $function;
+    $this->argumentNumber = $argumentNumber;
+    $this->variationData = $variationData;
+
+  }
+
+
+  /**
+   * Constructs  the test case as a array of strings
+   *
+   */
+  public function constructTestCase() {
+    $this->constructCommonHeaders(); 
+      
+    $this->addVariationEcho();
+    
+    $this->constructSubjectCalls();
+    
+    $this->constructCommonClosing();
+    
+  }
+  public function testHeader() {
+    $this->testCase[] = "--TEST--";
+    $this->testCase[] = "Test function ".$this->subject->getName()."() by substituting argument ".$this->argumentNumber." with ".$this->variationData." values.";
+  }
+
+  
+  public function subjectCalls() { 
+    $this->testCase = gtCodeSnippet::append('loopStart', $this->testCase);
+
+    // Construct the argument list to pass to the function being tested
+    $argumentList = explode(",", $this->subject->getMaximumArgumentList());
+    $argumentList[$this->argumentNumber -1 ] = "\$var ";
+    $list = implode(", ", $argumentList);
+
+
+    $this->testCase[] = "  var_dump(".$this->subject->getName()."( ".$list." ) );";
+    $this->testCase = gtCodeSnippet::append('loopClose', $this->testCase);
+  }
+   
+}
+?>
+\ No newline at end of file
diff --git a/scripts/dev/generate-phpt/src/testcase/gtVariationTestCaseMethod.php b/scripts/dev/generate-phpt/src/testcase/gtVariationTestCaseMethod.php
new file mode 100644
index 0000000000..a9c921f9db
--- /dev/null
+++ b/scripts/dev/generate-phpt/src/testcase/gtVariationTestCaseMethod.php
@@ -0,0 +1,68 @@
+<?php
+
+/**
+ * Class for variation tests for a PHP method
+ */
+class gtVariationTestCaseMethod extends gtVariationTestCase {
+
+  protected $subject;
+  protected $argumentNumber;
+  protected $variationData;
+  protected $testCase;
+
+  public function __construct($opt) {
+    $this->optionalSections = $opt;
+  }
+
+  /**
+   * Set data neede to construct variation tests
+   *
+   * @param gtMethod $method
+   * @param string $argumentNumber
+   * @param string $variationData
+   */
+  public function setUp(gtMethod $method, $argumentNumber, $variationData) {
+    $this->subject = $method;
+    $this->argumentNumber = $argumentNumber;
+    $this->variationData = $variationData;
+  }
+
+
+  /**
+   * Constructs the test case as a array of strings
+   *
+   */
+  public function constructTestCase() {
+    $this->constructCommonHeaders();
+    
+    $this->addVariationEcho();
+    
+    $this->constructorArgInit();
+    $this->constructorCreateInstance();
+    
+    $this->constructSubjectcalls();
+    $this->constructCommonClosing();
+    
+  }
+
+  public function testHeader() {
+    $this->testCase[] = "--TEST--";
+    $this->testCase[] = "Test class ".$this->subject->getClassName()." method ".$this->subject->getName()."() by substituting argument ".$this->argumentNumber." with ".$this->variationData." values.";
+  }
+
+  public function subjectCalls() {
+    $this->testCase = gtCodeSnippet::append('loopStart', $this->testCase);
+    // Construct the argument list to pass to the method being tested
+    $argumentList = explode(",", $this->subject->getMaximumArgumentList());
+    $argumentList[$this->argumentNumber -1 ] = "\$var ";
+    $list = implode(", ", $argumentList);
+
+
+    $this->testCase[] = "  var_dump(\$class->".$this->subject->getName()."( ".$list." ) );";
+    $this->testCase = gtCodeSnippet::append('loopClose', $this->testCase);
+
+  }
+
+}
+
+?>
+\ No newline at end of file
diff --git a/scripts/dev/generate-phpt/src/texts/functionOrMethodNotSpecified.txt b/scripts/dev/generate-phpt/src/texts/functionOrMethodNotSpecified.txt
new file mode 100644
index 0000000000..b497682cb7
--- /dev/null
+++ b/scripts/dev/generate-phpt/src/texts/functionOrMethodNotSpecified.txt
@@ -0,0 +1,3 @@
+
+Please supply a function or method name to be tested.
+
diff --git a/scripts/dev/generate-phpt/src/texts/help.txt b/scripts/dev/generate-phpt/src/texts/help.txt
new file mode 100644
index 0000000000..cfc3b626e5
--- /dev/null
+++ b/scripts/dev/generate-phpt/src/texts/help.txt
@@ -0,0 +1,14 @@
+Usage:
+php generate-phpt.php  -f <function_name> |-c <class_name> -m <method_name> -b|e|v [-s skipif:ini:clean:done] [-k win|notwin|64b|not64b] [-x ext]
+
+Where:
+-f function_name ................. Name of PHP function, eg cos
+-c class name .....................Name of class, eg DOMDocument
+-m method name ....................Name of method, eg createAttribute
+-b ............................... Generate basic tests
+-e ............................... Generate error tests
+-v ............................... Generate variation tests
+-s sections....................... Create optional sections, colon separated list
+-k skipif key..................... Skipif option, only used if -s skipif is used.
+-x extension.......................Skipif option, specify extension to check for
+-h ............................... Print this message
diff --git a/scripts/dev/generate-phpt/src/texts/methodNotSpecified.txt b/scripts/dev/generate-phpt/src/texts/methodNotSpecified.txt
new file mode 100644
index 0000000000..1f11a3a1ba
--- /dev/null
+++ b/scripts/dev/generate-phpt/src/texts/methodNotSpecified.txt
@@ -0,0 +1,4 @@
+
+You have given a class name but not supplied a method name to test.
+The method name is required.
+
diff --git a/scripts/dev/generate-phpt/src/texts/testTypeNotSpecified.txt b/scripts/dev/generate-phpt/src/texts/testTypeNotSpecified.txt
new file mode 100644
index 0000000000..e83ddbb5c2
--- /dev/null
+++ b/scripts/dev/generate-phpt/src/texts/testTypeNotSpecified.txt
@@ -0,0 +1,3 @@
+
+Please specify basic, error or variation tests.
+
diff --git a/scripts/dev/generate-phpt/src/texts/unknownClass.txt b/scripts/dev/generate-phpt/src/texts/unknownClass.txt
new file mode 100644
index 0000000000..b0a47ca8b9
--- /dev/null
+++ b/scripts/dev/generate-phpt/src/texts/unknownClass.txt
@@ -0,0 +1,4 @@
+
+The class name is not a valid PHP class name.
+Check that the extension containing the class is loaded.
+
diff --git a/scripts/dev/generate-phpt/src/texts/unknownFunction.txt b/scripts/dev/generate-phpt/src/texts/unknownFunction.txt
new file mode 100644
index 0000000000..2e76978a52
--- /dev/null
+++ b/scripts/dev/generate-phpt/src/texts/unknownFunction.txt
@@ -0,0 +1,4 @@
+
+The function name is not a valid PHP function name.
+Check that the extension containing the function is loaded.
+
diff --git a/scripts/dev/generate-phpt/src/texts/unknownMethod.txt b/scripts/dev/generate-phpt/src/texts/unknownMethod.txt
new file mode 100644
index 0000000000..8cc9eaeda6
--- /dev/null
+++ b/scripts/dev/generate-phpt/src/texts/unknownMethod.txt
@@ -0,0 +1,4 @@
+
+The method name is not a valid PHP method name.
+Check that the extension containing the method is loaded.
+
diff --git a/scripts/dev/generate-phpt/tests/gtBasicTestCaseFunctionTest.php b/scripts/dev/generate-phpt/tests/gtBasicTestCaseFunctionTest.php
new file mode 100644
index 0000000000..dbba0d6470
--- /dev/null
+++ b/scripts/dev/generate-phpt/tests/gtBasicTestCaseFunctionTest.php
@@ -0,0 +1,24 @@
+<?php
+require_once 'PHPUnit/Framework.php';
+require_once dirname(__FILE__) . '/../src/gtAutoload.php';
+
+class gtBasicTestCaseFunctionTest extends PHPUnit_Framework_TestCase {
+
+
+  public function testTestCase() {
+   
+    $f = new gtFunction('cos');
+    $f->setArgumentNames();
+    $f->setArgumentLists();
+    $f->setInitialisationStatements();
+    $optSect = new gtOptionalSections();
+    
+    $btc = gtBasicTestCase::getInstance($optSect);
+    $btc->setFunction($f);
+    $btc->constructTestCase();
+
+    $fs = $btc->toString();
+    $this->assertTrue(is_string($fs));
+  }
+}
+?>
+\ No newline at end of file
diff --git a/scripts/dev/generate-phpt/tests/gtBasicTestCaseMethodTest.php b/scripts/dev/generate-phpt/tests/gtBasicTestCaseMethodTest.php
new file mode 100644
index 0000000000..81307f139c
--- /dev/null
+++ b/scripts/dev/generate-phpt/tests/gtBasicTestCaseMethodTest.php
@@ -0,0 +1,28 @@
+<?php
+require_once 'PHPUnit/Framework.php';
+require_once dirname(__FILE__) . '/../src/gtAutoload.php';
+
+class gtBasicTestCaseMethodTest extends PHPUnit_Framework_TestCase {
+
+
+  public function testTestCase() {
+   
+    $f = new gtMethod('DOMDocument','createAttribute');
+    $f->setArgumentNames();
+    $f->setArgumentLists();
+    $f->setInitialisationStatements();
+    $f->setConstructorArgumentNames();
+    $f->setConstructorInitStatements();
+
+    $optSect = new gtOptionalSections();
+    $btc = gtBasicTestCaseMethod::getInstance($optSect, 'method');
+    $btc->setMethod($f);
+    $btc->constructTestCase();
+    
+
+    $fs = $btc->toString();
+    $this->assertTrue(is_string($fs));
+    
+  }
+}
+?>
+\ No newline at end of file
diff --git a/scripts/dev/generate-phpt/tests/gtCodeSnippetTest.php b/scripts/dev/generate-phpt/tests/gtCodeSnippetTest.php
new file mode 100644
index 0000000000..bc0c48a5a1
--- /dev/null
+++ b/scripts/dev/generate-phpt/tests/gtCodeSnippetTest.php
@@ -0,0 +1,15 @@
+<?php
+require_once 'PHPUnit/Framework.php';
+require_once dirname(__FILE__) . '/../src/gtAutoload.php';
+
+
+class gtCodeSnippetTest extends PHPUnit_Framework_TestCase
+{
+  
+  public function testAppend() {
+    $array = array('something', 'nothing');
+    $array = gtCodeSnippet::append('loopClose', $array);
+    $this->assertEquals($array[2], '}');
+  }
+}
+?>
+\ No newline at end of file
diff --git a/scripts/dev/generate-phpt/tests/gtCommandLineOptionsTest.php b/scripts/dev/generate-phpt/tests/gtCommandLineOptionsTest.php
new file mode 100644
index 0000000000..2fd6818a45
--- /dev/null
+++ b/scripts/dev/generate-phpt/tests/gtCommandLineOptionsTest.php
@@ -0,0 +1,46 @@
+<?php
+require_once 'PHPUnit/Framework.php';
+  require_once dirname(__FILE__) . '/../src/gtAutoload.php';
+
+
+  class gtCommandLineOptionsTest extends PHPUnit_Framework_TestCase
+  {
+    
+    /**
+    * @expectedException RuntimeException
+    */
+    public function testNoOption() {
+      $clo = new gtCommandLineOptions();
+      $clo->parse(array('generate-phpt.php'));
+    }
+
+    public function testShortOption() {
+      $clo = new gtCommandLineOptions();
+      $clo->parse(array('generate-phpt.php', '-h'));
+      $this->assertTrue($clo->hasOption('h'));
+    }
+
+    public function testShortOptionArgument() {
+      $clo = new gtCommandLineOptions();
+      $clo->parse(array('generate-phpt.php', '-f', 'some-function'));
+      $this->assertTrue($clo->hasOption('f'));
+      $this->assertEquals('some-function', $clo->getOption('f'));
+    }
+    
+    /**
+    * @expectedException RuntimeException
+    */
+      public function testInvalidOption() {
+      $clo = new gtCommandLineOptions();
+      $clo->parse(array('generate-phpt.php', '-z'));
+    }
+    
+    /**
+    * @expectedException RuntimeException
+    */
+   public function testMissingArgument() {
+      $clo = new gtCommandLineOptions();
+      $clo->parse(array('generate-phpt.php', '-f'));
+    }
+  }
+?>
+\ No newline at end of file
diff --git a/scripts/dev/generate-phpt/tests/gtErrorTestCaseFunctionTest.php b/scripts/dev/generate-phpt/tests/gtErrorTestCaseFunctionTest.php
new file mode 100644
index 0000000000..5b72fcc9f5
--- /dev/null
+++ b/scripts/dev/generate-phpt/tests/gtErrorTestCaseFunctionTest.php
@@ -0,0 +1,28 @@
+<?php
+require_once 'PHPUnit/Framework.php';
+require_once dirname(__FILE__) . '/../src/gtAutoload.php';
+
+class gtErrorTestCaseFunctionTest extends PHPUnit_Framework_TestCase {
+
+
+  public function testTestCase() {
+   
+    $f = new gtFunction('cos');
+    $f->setArgumentNames();
+    $f->setArgumentLists();
+    $f->setInitialisationStatements();
+    
+    $optSect = new gtOptionalSections();
+    
+    $btc = gtErrorTestCase::getInstance($optSect);
+    $btc->setFunction($f);
+    $btc->constructTestCase();
+    
+    
+    $fs = $btc->toString();
+    $this->assertTrue(is_string($fs));
+    
+  }
+  
+}
+?>
+\ No newline at end of file
diff --git a/scripts/dev/generate-phpt/tests/gtErrorTestCaseMethodTest.php b/scripts/dev/generate-phpt/tests/gtErrorTestCaseMethodTest.php
new file mode 100644
index 0000000000..7077881296
--- /dev/null
+++ b/scripts/dev/generate-phpt/tests/gtErrorTestCaseMethodTest.php
@@ -0,0 +1,30 @@
+<?php
+require_once 'PHPUnit/Framework.php';
+require_once dirname(__FILE__) . '/../src/gtAutoload.php';
+
+class gtErrorTestCaseMethodTest extends PHPUnit_Framework_TestCase {
+
+
+  public function testTestCase() {
+   
+    $f = new gtMethod('DOMDocument', 'createAttribute');
+    $f->setArgumentNames();
+    $f->setArgumentLists();
+
+    $f->setInitialisationStatements();
+
+    $f->setConstructorArgumentNames();
+    $f->setConstructorInitStatements();
+    
+    $optSect = new gtOptionalSections();
+    
+    $btc = gtErrorTestCase::getInstance($optSect,'method');
+    $btc->setMethod($f);
+    $btc->constructTestCase();
+    
+    
+    $fs = $btc->toString();
+    $this->assertTrue(is_string($fs));
+  }
+}
+?>
+\ No newline at end of file
diff --git a/scripts/dev/generate-phpt/tests/gtFunctionTest.php b/scripts/dev/generate-phpt/tests/gtFunctionTest.php
new file mode 100644
index 0000000000..0aa7eac119
--- /dev/null
+++ b/scripts/dev/generate-phpt/tests/gtFunctionTest.php
@@ -0,0 +1,71 @@
+cd
+<?php
+require_once 'PHPUnit/Framework.php';
+require_once dirname(__FILE__) . '/../src/gtAutoload.php';
+
+
+class gtFunctionTest extends PHPUnit_Framework_TestCase
+{
+  public function testArguments() {
+
+    $f = new gtFunction('cos');
+    $f->setArgumentNames();
+    $m = $f->getMandatoryArgumentNames();
+    $this->assertEquals($m[0], 'number');
+  }
+
+  public function testArguments2() {
+
+    $f = new gtFunction('version_compare');
+    $f->setArgumentNames();
+    $m = $f->getMandatoryArgumentNames();
+    $o = $f->getOptionalArgumentNames();
+    $this->assertEquals($m[0], 'ver1');
+    $this->assertEquals($m[1], 'ver2');
+    $this->assertEquals($o[0], 'oper');
+
+  }
+
+  public function testExtraArguments() {
+
+    $f = new gtFunction('version_compare');
+    $f->setArgumentNames();
+    $f->setExtraArgumentList();
+
+    $this->assertEquals('$ver1, $ver2, $oper, $extra_arg', $f->getExtraArgumentList());
+  }
+
+  public function testShortArguments() {
+
+    $f = new gtFunction('version_compare');
+    $f->setArgumentNames();
+    $f->setShortArgumentList();
+
+    $this->assertEquals('$ver1', $f->getShortArgumentList());
+  }
+  
+   public function testAllArgumentList() {
+
+    $f = new gtFunction('version_compare');
+    $f->setArgumentNames();
+    $f->setValidArgumentLists();
+    $a = $f->getValidArgumentLists();
+    
+    $this->assertEquals('$ver1, $ver2', $a[0]);
+    $this->assertEquals('$ver1, $ver2, $oper', $a[1]);
+  }
+  
+   public function testInitialisation() {
+
+    $f = new gtFunction('version_compare');
+    $f->setArgumentNames();
+    $f->setInitialisationStatements();
+    $a = $f->getInitialisationStatements();
+    
+    $this->assertEquals('$ver1 = ', $a[0]);
+    $this->assertEquals('$ver2 = ', $a[1]);
+    $this->assertEquals('$oper = ', $a[2]);
+  }
+
+}
+?>
+\ No newline at end of file
diff --git a/scripts/dev/generate-phpt/tests/gtIfClassHasMethodTest.php b/scripts/dev/generate-phpt/tests/gtIfClassHasMethodTest.php
new file mode 100644
index 0000000000..b9f2410b5d
--- /dev/null
+++ b/scripts/dev/generate-phpt/tests/gtIfClassHasMethodTest.php
@@ -0,0 +1,41 @@
+<?php
+require_once 'PHPUnit/Framework.php';
+require_once dirname(__FILE__) . '/../src/gtAutoload.php';
+
+
+class gtIfClassHasMethodTest extends PHPUnit_Framework_TestCase {
+
+  public function testValid() {
+
+    $clo = new gtCommandLineOptions();
+    $clo->parse(array('generate-phpt.php', '-c', 'blah', '-m', 'blah'));
+    $ch = new gtIfClassHasMethod();
+    $this->assertTrue($ch->check($clo));
+  }
+
+  public function testNotValid() {
+
+    $clo = new gtCommandLineOptions();
+    $clo->parse(array('generate-phpt.php', '-c', 'blah'));
+    $ch = new gtIfClassHasMethod();
+    $this->assertFalse($ch->check($clo));
+  }
+
+  public function testNotSpecified() {
+
+    $clo = new gtCommandLineOptions();
+    $clo->parse(array('generate-phpt.php', '-b'));
+    $ch = new gtIfClassHasMethod();
+    $this->assertTrue($ch->check($clo));
+  }
+
+  public function testMessage() {
+
+    $clo = new gtCommandLineOptions();
+    $clo->parse(array('generate-phpt.php', '-c', 'blah'));
+    $ch = new gtIfClassHasMethod();
+    $this->assertEquals($ch->getMessage(), gtText::get('methodNotSpecified'));
+  }
+}
+
+?>
+\ No newline at end of file
diff --git a/scripts/dev/generate-phpt/tests/gtIsSpecifiedFunctionOrMethodTest.php b/scripts/dev/generate-phpt/tests/gtIsSpecifiedFunctionOrMethodTest.php
new file mode 100644
index 0000000000..064edf3b65
--- /dev/null
+++ b/scripts/dev/generate-phpt/tests/gtIsSpecifiedFunctionOrMethodTest.php
@@ -0,0 +1,41 @@
+<?php
+require_once 'PHPUnit/Framework.php';
+require_once dirname(__FILE__) . '/../src/gtAutoload.php';
+
+
+class gtIsSpecifiedFunctionOrMethodTest extends PHPUnit_Framework_TestCase {
+
+  public function testValid() {
+
+    $clo = new gtCommandLineOptions();
+    $clo->parse(array('generate-phpt.php', '-m', 'blah'));
+    $ch = new gtIsSpecifiedFunctionOrMethod();
+    $this->assertTrue($ch->check($clo));
+  }
+
+  public function testValid2() {
+
+    $clo = new gtCommandLineOptions();
+    $clo->parse(array('generate-phpt.php', '-f', 'blah'));
+    $ch = new gtIsSpecifiedFunctionOrMethod();
+    $this->assertTrue($ch->check($clo));
+  }
+  
+   public function testNotValid() {
+
+    $clo = new gtCommandLineOptions();
+    $clo->parse(array('generate-phpt.php', '-b'));
+    $ch = new gtIsSpecifiedFunctionOrMethod();
+    $this->assertFalse($ch->check($clo));
+    
+  }
+  
+  public function testMessage() {
+
+    $clo = new gtCommandLineOptions();
+    $clo->parse(array('generate-phpt.php', '-c', 'blah'));
+    $ch = new gtIsSpecifiedFunctionOrMethod();
+    $this->assertEquals($ch->getMessage(), gtText::get('functionOrMethodNotSpecified'));
+  }
+}
+?>
+\ No newline at end of file
diff --git a/scripts/dev/generate-phpt/tests/gtIsSpecifiedTestTypeTest.php b/scripts/dev/generate-phpt/tests/gtIsSpecifiedTestTypeTest.php
new file mode 100644
index 0000000000..c8b0a4e36a
--- /dev/null
+++ b/scripts/dev/generate-phpt/tests/gtIsSpecifiedTestTypeTest.php
@@ -0,0 +1,32 @@
+<?php
+require_once 'PHPUnit/Framework.php';
+require_once dirname(__FILE__) . '/../src/gtAutoload.php';
+
+
+class gtIsSpecifiedTestTypeTest extends PHPUnit_Framework_TestCase {
+
+  public function testValid() {
+
+    $clo = new gtCommandLineOptions();
+    $clo->parse(array('generate-phpt.php', '-c', 'DOMDocument','-b'));
+    $ch = new gtIsSpecifiedTestType();
+    $this->assertTrue($ch->check($clo));
+  }
+
+  public function testNotValid() {
+
+    $clo = new gtCommandLineOptions();
+    $clo->parse(array('generate-phpt.php', '-c', 'DOMDocument'));
+    $ch = new gtIsSpecifiedTestType();
+    $this->assertFalse($ch->check($clo));
+  }
+  
+  public function testMessage() {
+
+    $clo = new gtCommandLineOptions();
+    $clo->parse(array('generate-phpt.php', '-c', 'blah'));
+    $ch = new gtIsSpecifiedtestType();
+    $this->assertEquals($ch->getMessage(), gtText::get('testTypeNotSpecified'));
+  }
+}
+?>
+\ No newline at end of file
diff --git a/scripts/dev/generate-phpt/tests/gtIsValidClassTest.php b/scripts/dev/generate-phpt/tests/gtIsValidClassTest.php
new file mode 100644
index 0000000000..51ca87879d
--- /dev/null
+++ b/scripts/dev/generate-phpt/tests/gtIsValidClassTest.php
@@ -0,0 +1,41 @@
+<?php
+require_once 'PHPUnit/Framework.php';
+require_once dirname(__FILE__) . '/../src/gtAutoload.php';
+
+
+class gtIsValidClassTest extends PHPUnit_Framework_TestCase {
+
+  public function testValid() {
+
+    $clo = new gtCommandLineOptions();
+    $clo->parse(array('generate-phpt.php', '-c', 'DOMDocument'));
+    $ch = new gtIsValidClass();
+    $this->assertTrue($ch->check($clo));
+  }
+
+  public function testNotValid() {
+
+    $clo = new gtCommandLineOptions();
+    $clo->parse(array('generate-phpt.php', '-c', 'blah'));
+    $ch = new gtIsValidClass();
+    $this->assertFalse($ch->check($clo));
+  }
+  
+  public function testNotGiven() {
+
+    $clo = new gtCommandLineOptions();
+    $clo->parse(array('generate-phpt.php','-b'));
+    $ch = new gtIsValidClass();
+    $this->assertTrue($ch->check($clo));
+  }
+  
+  public function testMessage() {
+
+    $clo = new gtCommandLineOptions();
+    $clo->parse(array('generate-phpt.php', '-c', 'blah'));
+    $ch = new gtIsvalidClass();
+    $this->assertEquals($ch->getMessage(), gtText::get('unknownClass'));
+  }
+}
+
+?>
+\ No newline at end of file
diff --git a/scripts/dev/generate-phpt/tests/gtIsValidFunctionTest.php b/scripts/dev/generate-phpt/tests/gtIsValidFunctionTest.php
new file mode 100644
index 0000000000..d4700b9d66
--- /dev/null
+++ b/scripts/dev/generate-phpt/tests/gtIsValidFunctionTest.php
@@ -0,0 +1,40 @@
+<?php
+require_once 'PHPUnit/Framework.php';
+require_once dirname(__FILE__) . '/../src/gtAutoload.php';
+
+
+class gtIsValidFunctionTest extends PHPUnit_Framework_TestCase {
+
+  public function testValid() {
+
+    $clo = new gtCommandLineOptions();
+    $clo->parse(array('generate-phpt.php', '-f', 'cos'));
+    $ch = new gtIsValidFunction();
+    $this->assertTrue($ch->check($clo));
+  }
+
+  public function testNotValid() {
+
+    $clo = new gtCommandLineOptions();
+    $clo->parse(array('generate-phpt.php', '-f', 'blah'));
+    $ch = new gtIsValidFunction();
+    $this->assertFalse($ch->check($clo));
+  }
+  
+  public function testNotSupplied() {
+
+    $clo = new gtCommandLineOptions();
+    $clo->parse(array('generate-phpt.php','-b'));
+    $ch = new gtIsValidFunction();
+    $this->assertTrue($ch->check($clo));
+  }
+  
+  public function testMessage() {
+
+    $clo = new gtCommandLineOptions();
+    $clo->parse(array('generate-phpt.php', '-c', 'blah'));
+    $ch = new gtIsvalidFunction();
+    $this->assertEquals($ch->getMessage(), gtText::get('unknownFunction'));
+  }
+}
+?>
+\ No newline at end of file
diff --git a/scripts/dev/generate-phpt/tests/gtIsValidMethodTest.php b/scripts/dev/generate-phpt/tests/gtIsValidMethodTest.php
new file mode 100644
index 0000000000..fe069977ef
--- /dev/null
+++ b/scripts/dev/generate-phpt/tests/gtIsValidMethodTest.php
@@ -0,0 +1,40 @@
+<?php
+require_once 'PHPUnit/Framework.php';
+require_once dirname(__FILE__) . '/../src/gtAutoload.php';
+
+
+class gtIsValidMethodTest extends PHPUnit_Framework_TestCase {
+
+  public function testValid() {
+
+    $clo = new gtCommandLineOptions();
+    $clo->parse(array('generate-phpt.php', '-c', 'DOMDocument', '-m', 'createAttribute'));
+    $ch = new gtIsValidMethod();
+    $this->assertTrue($ch->check($clo));
+  }
+
+  public function testNotValid() {
+
+    $clo = new gtCommandLineOptions();
+    $clo->parse(array('generate-phpt.php', '-c', 'DOMDocument', '-m', 'blah'));
+    $ch = new gtIsValidMethod();
+    $this->assertFalse($ch->check($clo));
+  }
+  
+  public function testNotGiven() {
+
+    $clo = new gtCommandLineOptions();
+    $clo->parse(array('generate-phpt.php','-b'));
+    $ch = new gtIsValidMethod();
+    $this->assertTrue($ch->check($clo));
+  }
+  
+  public function testMessage() {
+
+    $clo = new gtCommandLineOptions();
+    $clo->parse(array('generate-phpt.php', '-c', 'blah'));
+    $ch = new gtIsvalidMethod();
+    $this->assertEquals($ch->getMessage(), gtText::get('unknownMethod'));
+  }
+}
+?>
+\ No newline at end of file
diff --git a/scripts/dev/generate-phpt/tests/gtMethodTest.php b/scripts/dev/generate-phpt/tests/gtMethodTest.php
new file mode 100644
index 0000000000..430161ee1c
--- /dev/null
+++ b/scripts/dev/generate-phpt/tests/gtMethodTest.php
@@ -0,0 +1,82 @@
+<?php
+require_once 'PHPUnit/Framework.php';
+require_once dirname(__FILE__) . '/../src/gtAutoload.php';
+
+
+class gtMethodTest extends PHPUnit_Framework_TestCase
+{
+  public function testGetParams() {
+    $m = new gtMethod('DOMDocument', 'createAttribute');
+    $m->setArgumentNames();
+    $a = $m->getMandatoryArgumentNames();
+    $this->assertEquals($a[0], 'name');
+  }
+
+  public function testConstructor() {
+    $m = new gtMethod('DOMDocument', 'createAttribute');
+    $m->setConstructorArgumentNames();
+    $a = $m->getConstructorArgumentNames();
+    $this->assertEquals($a[0], 'version');
+    $this->assertEquals($a[1], 'encoding');
+  }
+
+  public function testExtraParamList() {
+    $m = new gtMethod('DOMDocument', 'createAttribute');
+    $m->setArgumentNames();
+    $m->setExtraArgumentList();
+    $this->assertEquals('$name, $extra_arg',$m->getExtraArgumentList());
+  }
+
+  public function testShortParamList() {
+    $m = new gtMethod('DOMDocument', 'createAttribute');
+    $m->setArgumentNames();
+    $m->setShortArgumentList();
+    $this->assertEquals('',$m->getShortArgumentList());
+  }
+
+  public function testAllParamList() {
+    $m = new gtMethod('DOMDocument', 'createAttribute');
+    $m->setArgumentNames();
+    $m->setValidArgumentLists();
+    $a = $m->getValidArgumentLists();
+    $this->assertEquals('$name',$a[0]);
+  }
+
+  public function testMaxParamList() {
+    $m = new gtMethod('DOMDocument', 'createAttribute');
+    $m->setArgumentNames();
+    $m->setValidArgumentLists();
+    $this->assertEquals('$name',$m->getMaximumArgumentList());
+  }
+
+
+
+  public function testConstructorList() {
+    $m = new gtMethod('Phar', 'buildFromDirectory');
+    $m->setArgumentNames();
+    $m->setConstructorArgumentNames();
+
+    $m->setConstructorArgumentList();
+    $this->assertEquals('$filename, $flags, $alias, $fileformat',$m->getConstructorArgumentList());
+
+  }
+
+  public function testConstructorInit() {
+    $m = new gtMethod('Phar', 'buildFromDirectory');
+    $m->setArgumentNames();
+    $m->setConstructorArgumentNames();
+
+    $m->setConstructorInitStatements();
+    $a = $m->getConstructorInitStatements();
+    $this->assertEquals('$filename = ',$a[0]);
+    $this->assertEquals('$flags = ',$a[1]);
+    $this->assertEquals('$alias = ',$a[2]);
+    $this->assertEquals('$fileformat = ',$a[3]);
+  }
+
+
+
+
+}
+
+?>
+\ No newline at end of file
diff --git a/scripts/dev/generate-phpt/tests/gtOptionalSectionsTest.php b/scripts/dev/generate-phpt/tests/gtOptionalSectionsTest.php
new file mode 100644
index 0000000000..dbf2994567
--- /dev/null
+++ b/scripts/dev/generate-phpt/tests/gtOptionalSectionsTest.php
@@ -0,0 +1,58 @@
+<?php
+require_once 'PHPUnit/Framework.php';
+require_once dirname(__FILE__) . '/../src/gtAutoload.php';
+
+
+class gtOptionalSectionsTest extends PHPUnit_Framework_TestCase
+{
+  public function testBasic() {
+
+    $clo = new gtCommandLineOptions();
+    $clo->parse(array('generate-phpt.php', '-s', 'skipif:ini'));
+
+    $opt = new gtOptionalSections();
+    $opt->setOptions($clo);
+    $a = $opt->getOptions();
+    $this->assertEquals(true, $a['skipif']);
+    $this->assertEquals(true, $a['ini']);
+    $this->assertEquals(false, $a['clean']);
+  }
+
+  /**
+   * @expectedException RuntimeException
+   */
+  public function testException() {
+    $clo = new gtCommandLineOptions();
+    $clo->parse(array('generate-phpt.php', '-s', 'blah'));
+    $opt = new gtOptionalSections();
+    $opt->setOptions($clo);
+  }
+  
+  public function testSkip() {
+    $clo = new gtCommandLineOptions();
+    $clo->parse(array('generate-phpt.php', '-s', 'skipif', '-x', 'standard'));
+    $opt = new gtOptionalSections();
+    $opt->setOptions($clo);
+    
+    $opt = new gtOptionalSections();
+    $opt->setOptions($clo);
+    
+    $this->assertEquals('standard', $opt->getSkipifExt() );
+
+  }
+  
+  public function testSkipKey() {
+    $clo = new gtCommandLineOptions();
+    $clo->parse(array('generate-phpt.php', '-s', 'skipif', '-k', 'win'));
+    $opt = new gtOptionalSections();
+    $opt->setOptions($clo);
+    
+    $opt = new gtOptionalSections();
+    $opt->setOptions($clo);
+    
+    $this->assertEquals('win', $opt->getSkipifKey() );
+
+  }
+
+}
+?>
+\ No newline at end of file
diff --git a/scripts/dev/generate-phpt/tests/gtVariationTestCaseFunctionTest.php b/scripts/dev/generate-phpt/tests/gtVariationTestCaseFunctionTest.php
new file mode 100644
index 0000000000..df9f21c309
--- /dev/null
+++ b/scripts/dev/generate-phpt/tests/gtVariationTestCaseFunctionTest.php
@@ -0,0 +1,59 @@
+<?php
+require_once 'PHPUnit/Framework.php';
+require_once dirname(__FILE__) . '/../src/gtAutoload.php';
+
+class gtVariationTestCaseFunctionTest extends PHPUnit_Framework_TestCase {
+
+  public function testTestCase() {
+   
+    $f = new gtFunction('cos');
+    $f->setArgumentNames();
+    $f->setArgumentLists();
+    
+    $optSect = new gtOptionalSections();
+    
+    $vtc = gtVariationTestCase::getInstance($optSect);
+    $vtc->setUp($f, 1, 'int');
+    $vtc->constructTestCase();
+    
+    $fs = $vtc->toString();
+    $this->assertTrue(is_string($fs));
+    
+  }
+
+  public function testTestCase2() {
+    
+    $f = new gtFunction('date_sunrise');
+    $f->setArgumentNames();
+    $f->setArgumentLists();
+    $a = $f->getMandatoryArgumentNames();
+    
+    $optSect = new gtOptionalSections();
+    
+    $vtc = gtVariationTestCase::getInstance($optSect);
+    $vtc->setUp($f, 6, 'int');
+    $vtc->constructTestCase();
+    
+    $fs = $vtc->toString();
+    $this->assertTrue(is_string($fs));
+    
+  }
+  
+  public function testTestCase3() {
+    
+    $f = new gtFunction('date_sunrise');
+    $f->setArgumentNames();
+    $f->setArgumentLists();
+    
+    $optSect = new gtOptionalSections();
+
+    $vtc = gtVariationTestCase::getInstance($optSect);
+    $vtc->setUp($f, 6, 'array');
+    $vtc->constructTestCase();
+    
+    $fs = $vtc->toString();
+    $this->assertTrue(is_string($fs));
+    
+  }
+}
+?>
+\ No newline at end of file
diff --git a/scripts/dev/generate-phpt/tests/gtVariationTestCaseMethodTest.php b/scripts/dev/generate-phpt/tests/gtVariationTestCaseMethodTest.php
new file mode 100644
index 0000000000..d99b6562d0
--- /dev/null
+++ b/scripts/dev/generate-phpt/tests/gtVariationTestCaseMethodTest.php
@@ -0,0 +1,27 @@
+<?php
+require_once 'PHPUnit/Framework.php';
+require_once dirname(__FILE__) . '/../src/gtAutoload.php';
+
+class gtVariationTestCaseMethodTest extends PHPUnit_Framework_TestCase {
+
+  public function testTestCase() {
+   
+    $f = new gtMethod('DOMDocument','createAttribute');
+    $f->setArgumentNames();
+    $f->setArgumentLists();
+
+    $f->setConstructorArgumentNames();
+    $f->setConstructorInitStatements();
+    
+    $optSect = new gtOptionalSections();
+    
+    $vtc = gtVariationTestCase::getInstance($optSect, 'method');
+    $vtc->setUp($f, 1, 'int');
+    $vtc->constructTestCase();
+    $fs = $vtc->toString();
+    
+    $this->assertTrue(is_string($fs));
+   
+  }
+}
+?>
+\ No newline at end of file
diff --git a/scripts/dev/generate_phpt.php b/scripts/dev/generate_phpt.php
deleted file mode 100644
index 24b08b942b..0000000000
--- a/scripts/dev/generate_phpt.php
+++ /dev/null
@@ -1,1148 +0,0 @@
-<?php
-/* This is a script which generates simple PHPT test cases from the name of the function.
- * It works using the {{{ proto for the function PHP source code. The test cases that it generates 
- * are simple, however you can also give it the name of a file with PHP code in and it will turn this
- * into the right format for a PHPT test. 
- * This script will not generate expected output. 
- * Further quidance on how to use it can be found on qa.php.net, or by using the -h command line option.
- */
-
-//read the command line input and parse it, do some basic checks to make sure that it's correct
-
-$opt = initialise_opt();
-$opt = parse_args($argv, $opt);
-
-check_source($opt['source_loc']);
-check_fname($opt['name']);
-check_testcase($opt['error_gen'], $opt['basic_gen'],$opt['variation_gen']);
-
-if ($opt['include_block'] != NULL) {
-        check_file($opt['include_block']);
-}
- 
-
-//Get a list of all the c funtions in the source tree
-
-$all_c = array();
-$c_file_count = 0;
-dirlist($opt['source_loc'], $c_file_count, $all_c);
-
-
-//Search the list of c functions for the function prototype, quit if can't find it or if the function is an alias
-
-$test_info = get_loc_proto($all_c, $opt['name'], $opt['source_loc']);
-
-if (!$test_info['found']) {
-	echo "\nExiting: Unable to find implementation of {$opt['name']} in {$opt['source_loc']}\n";
-	if ($test_info['falias']) {
-		//But it may be aliased to something else
-		echo "\n{$test_info['name']}() is an alias of {$test_info['alias']}() --- Write test cases for this instead \n";
-	}
-	exit();
-}
-if ($test_info['falias']) {
-	//If this function is  falias'd to another function tell the test case writer about them
-	echo "\nNote: {$test_info['name']}() is an alias of {$test_info['alias']}() \n";
-}
-if ($test_info['error'] != NULL) {
-	echo $test_info['error']."\n";
-	exit();
-}
-
-$test_info['proto'] = $test_info['return_type']." ". $test_info['name']."(".$test_info['params'].")";
-
-
-//Set the test sections array - may want more in this later?
-
-$sections = array('--TEST--', 
-			'--FILE--', 
-			'--EXPECTF--' 
-			);
-
-//Parse the parameter list to get the information we need to build code
-
-$names = array();
-$types = array();
-$num_opt_args = 0;
-$num_args = 0;
-
-$parse_success = parse_params($test_info['params'], $names, $types, $num_args, $num_opt_args);
-
-if(!$parse_success) { 
-	echo "Unable to parse function parameter list: {$test_info['params']}. Will only generate template test\n";
-}
-
-if((!$parse_success) || ($opt['include_block'] != NULL)) {
-	//EITHER 
-	//     	parse_params returns false (failed) so just generate template code
-	// OR
-	//      If the user has given a file to import PHP code from - don't attempt to generate code
-	//
-	echo "\nGenerating test case for ".$test_info['name']."()\n\n";
-	if($opt['basic_gen']) {
-        	$test_case = gen_template($test_info, $sections, 'basic', $opt['include_block']);
-	}
-	elseif ($opt['error_gen']) {
-        	$test_case = gen_template($test_info, $sections, 'error', $opt['include_block']);
-	}
-	elseif ($opt['variation_gen']) {
-        	$test_case = gen_template($test_info, $sections, 'variation', $opt['include_block']);
-	}
-	exit();
-}
-
-
-// parse params succeded - so set up the function arguments to be used in test generation
-
-$test_info['arg_c'] = $num_args;
-$test_info['optional_args'] = $num_opt_args;
-if ($num_args > 0) {
-	$test_info['arg_det'] = array_combine($names, $types);
-}
-
-/* DEBUG HERE
-	var_dump($test_info);
-	exit();
-*/
-
-
-// Ready to generate test cases as required
-
-echo "\nGenerating test case for ".$test_info['name']."()\n\n";
-$test_case = array();
-if($opt['basic_gen']) {
-	$test_case = gen_basic_test($test_info, $sections, $test_case);
-}
-elseif ($opt['error_gen']) {
-	$test_case = gen_error_test($test_info, $sections, $test_case);
-}
-elseif ($opt['variation_gen']) {
-	//generates a number of tests 
-	gen_variation_test($test_info, $sections);
-}
-/*
- * END OF MAIN CODE SECTION
- */
-/*
- * Function to read the contents of a PHP into an array
- * Arguments:
- *	File name => file name with PHP code in it
- * 	$test_case => test case array to be appended to
- * Returns:
- *	$test_case
- */
-function read_include_file($file_name, $test_case) {
-	$fp = fopen($file_name, "r");
-	
-	$code_block = file($file_name);
-	
-	fclose($fp);
-	
-	//strip PHP tags and blank lines from start of file
-	foreach ($code_block as $line) {
-		if (preg_match("/<\?php/", $line)){
-			array_shift($code_block);
-			break;
-		}else if(preg_match("/^\s*$/",$line)) {
-			array_shift($code_block);
-		}else {
-			break;
-		}
-	}
-	
-	//Strip PHP tags and blank lines from the end of the code
-	$last = count($code_block) -1;	
-	for($j = 0; $j <= $last; $j++) {
-		$i = $last - $j;
-		$line = $code_block[$i];
-		if(preg_match("/\?>/", $line)) {
-			array_pop($code_block);
-			break;
-		}else if(preg_match("/^\s*$/",$line)) {
-			array_pop($code_block);
-		}else {
-			break;
-		}
-
-	}
-
-	// Append the lines of code to the test case array and return
-	foreach($code_block as $line) {
-		array_push($test_case, $line);
-	}
-	return $test_case;
-}
-		
-/* 
- * Generates basic functionality testcase and writes it out to a file.
- * Arguments:
- *	$fn_det =>  array containing details of the function,
- *	$sections => The test case sections (eg --TEST--) as an array
- * 		The test case code as arrays keyed by section.
- * Returns:
- * 	The test case code as an array of arrays, indexed by section                
- */
-function gen_basic_test($fn_det, $sections, $test_case) {
-	$name = $fn_det['name'];
-	$proto = $fn_det['proto'];
-	$desc = $fn_det['desc'];
-	$source_file = $fn_det['source_file'];
-	$arg_det = $fn_det['arg_det'];
-	$arg_c = $fn_det['arg_c'];
-	$optional_args = $fn_det['optional_args'];
-	$alias = $fn_det['alias'];
-
-	// get the test header
-	$test_case = gen_test_header($name, $proto, $desc, $source_file, "basic functionality", NULL, $alias, $test_case);
-
-	$test_case['--FILE--'] = gen_basic_test_code($name, $arg_det, $arg_c, $optional_args, $test_case['--FILE--']);
-
-	//End the script
-	$test_case = gen_test_trailer($test_case,'--EXPECTF--');
-	write_file($test_case, $name, 'basic', $sections);
-	return($test_case);
-}
-/* 
- * Function to scan recursively down a directory structure looking for all c files.
- * Input:
- * 	$dir - string path of top level directory
- * 	&$c_file_count - reference to a count of the number of files - init to 0, is updated with count after code is run
- * 	&$all_c - reference to list of all c files. Initialise to array, will contain file list after code is run
- * Output:
- * 	$all_c (see above)
- * 	$c_file_count (see above)
- */
-function dirlist($dir, &$c_file_count, &$all_c)
-{
-	$thisdir = dir($dir.'/'); //include the trailing slash
-	while(($file = $thisdir->read()) !== false) {
-		if ($file != '.' && $file != '..') {
-          		$path = $thisdir->path.$file;
-          			if(is_dir($path) == true) {
-                     			dirlist($path , $c_file_count , $all_c);
-            			} else {
-                 			if (preg_match("/\w+\.c$/", $file)) {
-               	      				$all_c[$c_file_count] = $path;
-               	      				$c_file_count++;
-                 			}
-            			}
-        	}
-    	}
-return;
-}
-/*
- * Function takes parameter list extracted from the proto comment and retuns a list 
- * of names and types
- * Arguments:
- * 	$param_list (string) = > list of arguments and types
- * 	$names => reference to an array of variable names
- * 	$types => reference to an array of variable
- * 	$nm_args => reference to number of function argumants
- * 	$num_opt_args => reference to number of optional arguments
- * Returns:
- * 	True if have been able to parse string $param_list, false if not.
- */ 
-function parse_params($param_list, &$names, &$types, &$num_args, &$num_opt_args) {
-	$opt_args = false;
-	$num_mand_args =0;
-	$num_opt_args = 0;
-	$num_args = 0;
-	$opt_params = NULL;
-
-        //remove all commas
-        $param_list = preg_replace("/,/", "", $param_list);
-
-        //deal with void
-        if(preg_match("/\s*void\s*/", $param_list)) {
-                return true; 
-        }
-
-        // extract mandatory parameters and  optional parameters
-        if (preg_match("/^(.*?)\[\s*(.*)\]\s*(.*?)$/", $param_list, $matches)) {
-                $param_list = $matches[1].$matches[3];
-                $opt_params = $matches[2];
-
-                // Extract nested optional parameters
-		$temp_opt_params = $opt_params;
-                while (preg_match("/(.+?)\s*\[\s*(.*)\]/",$temp_opt_params, $matches)) {
-                	$opt_params = $matches[1]." ".$matches[2];
-                	$temp_opt_params = $opt_params;
-                }
-        }
-
-        // seperate parameter list into array of types and names 
-	if ($param_list != "") {
-       		$param_list = chop($param_list);
-       		$param_array = explode(" ", $param_list);
-
-		$num_mand_args = count($param_array)/2;
-		//check that this is an even number and quit if not, means we have failed to parse correctly
-		if((round($num_mand_args) * 2) != count($param_array)) {return false;}
-
-       		$j = 0;
-       		for($i=0; $i<count($param_array); $i=$i+2) {
-			$j = $i + 1;
-			$types[$i] = $param_array[$i];
-			// If the variable is a reference remove the & from the variable name
-			$names[$i] = preg_replace("/&/", "", $param_array[$j]);
-       		}
-	}
-        //initialise optional arguments
-        if ($opt_params != NULL) {
-	       	$opt_array = explode(" ", $opt_params);
-
-		$num_opt_args = count($opt_array)/2;
-		//check that this is an even number and quit if not, means we have failed to parse correctly
-		if((round($num_opt_args) * 2) != count($opt_array)) {return false;}
-
-        	$j = 0;
-       		for($i=0; $i<count($opt_array); $i=$i+2) {
-				$j = $i + 1;
-				array_push($types, $opt_array[$i]);
-				// If the variable is a reference remove the & from the variable name
-				array_push($names, preg_replace("/&/", "", $opt_array[$j]));
-            	}
-        }
-	$num_args = $num_mand_args + $num_opt_args;
-	return true;
-}
-/*
- * Generates code for an array which contains invalid data types.
- * For example, if the variable being tested is of type "float" this code will 
- * generate an array of data whose type does not include float
- *  
- * Arguments:
- * 	$array_name => name of the array that should be returned
- * 	$var_type =>  data type of the argument
- * 	Array of code - will be appended to
- * Returns:
- * 	$code_block with appended lines of code to initialse the array of data
- */
-function gen_array_with_diff_values($var_type,  $array_name, $code_block) {
-	//generate the array with all different values, skip those of the same type as $var_type 
-
-	// integer values
-	$variation_array['int'] = array(
-		"'int 0' => 0",
-  		"'int 1' => 1",
-  		"'int 12345' => 12345",
-  		"'int -12345' => -2345"
-		);
-
-	// float values
-	$variation_array['float'] = array(
-  		"'float 10.5' => 10.5",
-  		"'float -10.5' => -10.5",
-  		"'float 12.3456789000e10' => 12.3456789000e10",
-  		"'float -12.3456789000e10' => -12.3456789000e10",
-  		"'float .5' => .5"
-		);
-
-	// array values
-	$variation_array['array'] = array(
-		"'empty array' => array()",
-		"'int indexed array' => \$index_array",
-		"'associative array' => \$assoc_array",
-		"'nested arrays' => array('foo', \$index_array, \$assoc_array)",
-		);
-
-	// null vlaues
-	$variation_array['null'] = array(
-		"'uppercase NULL' => NULL",
-		"'lowercase null' => null"
-		);
-
-	// boolean values
-	$variation_array['boolean'] = array(
-		"'lowercase true' => true",
-		"'lowercase false' =>false",
-		"'uppercase TRUE' =>TRUE",
-		"'uppercase FALSE' =>FALSE"
-		);
-
-	// empty data
-	$variation_array['empty'] = array(
-		"'empty string DQ' => \"\"",
-		"'empty string SQ' => ''"
-		);
-
-	// string values
-	$variation_array['string'] = array(
-		"'string DQ' => \"string\"",
-		"'string SQ' => 'string'",
-		"'mixed case string' => \"sTrInG\"",
-		"'heredoc' => \$heredoc"
-		);
-
-	// object data
-	$variation_array['object'] = array(
-		"'instance of classWithToString' => new classWithToString()",
-		"'instance of classWithoutToString' => new classWithoutToString()"
-		);
-
-
-	// undefined variable
-	$variation_array['undefined'] = array(
-  		"'undefined var' => @\$undefined_var"	
-		);
-
-	// unset variable
-	$variation_array['unset'] = array(
-		"'unset var' => @\$unset_var"
-		);
-
-
- 	//Write out the code block for the variation array
-        $blank_line = "";
-        array_push($code_block, "\$$array_name = array(");
-        foreach ($variation_array as $type => $data) {
-                if($type != $var_type) {
-                        array_push($code_block, $blank_line);
-                        $comment = "      // $type data";
-                        array_push($code_block,$comment);
-                        foreach ($variation_array[$type] as $entry) {
-                                $line = "      ".$entry.",";
-                                array_push($code_block, $line);
-                        }
-                }
-        }
-	array_push($code_block, ");");
-	return $code_block;
-}
-
-/*
- * Generate variation testcases and writes them to file(s)
- * 	1) generate variation for each argument where different invalid argument values are passed
- * 	2) generate a vartiation template
- * Arguments:
- * 	$fn_det => array containing details of the function,
- * 	$sections => list of test sections, eg '--TEST--', etc
- * Returns:
- * 	Nothing at the moment - should be tru for success/false for fail?
- * 
-*/
-function gen_variation_test($fn_det, $sections) {
-
-        $name = $fn_det['name'];
-        $proto = $fn_det['proto'];
-        $desc = $fn_det['desc'];
-        $source_file = $fn_det['source_file'];
-        $arg_det = $fn_det['arg_det'];
-        $arg_c = $fn_det['arg_c'];
-        $optional_args = $fn_det['optional_args'];
-        $alias = $fn_det['alias'];
-
-	$test_case = array();
-
-	$test_case = gen_template($fn_det, $sections, 'variation');
-
-	// if the function has zero argument then quit here because we only need the template
-	if($arg_c == 0) {
-		return;
-	}
-
-	// generate a sequence of other tests which loop over each function arg trying different values
-	$name_seq = 1;
-	$arg_count = 1;
-	if($arg_c > 0) {
-		for($i = 0; $i < $arg_c; $i++) {
-			//generate a different variation test case for each argument
-			$test_case = array();
-
-			$test_case = gen_test_header($name, $proto, $desc, 
-                                     $source_file, "usage variation","", $alias, $test_case);
-
-			// add variation code
-			$test_case['--FILE--'] = gen_variation_diff_arg_values_test($name, $arg_det, $arg_count, $test_case['--FILE--']);
-
-			// end the script
-			$test_case = gen_test_trailer($test_case, '--EXPECTF--');
-			$tc_name = 'variation'.$name_seq;
-			write_file($test_case, $name, $tc_name, $sections);
-
-			$arg_count ++; // next time generate the code for next argument of the function;
-			$name_seq ++; // next seqence number for variation test name
-		}
-	}
-}
-/* 
- * Generate code for testcase header. The following test sections are added: 
- * --TEST--  & --FILE--
- * Arguments:
- * 	$fn_name => name of the function
- * 	$proto => $fn_name function prototype
- * 	$desc => short description of $fn_name function
- * 	$source_file => location of the file that implements $fn_name function
- * 	$type_msg => Message to indicate what type of testing is being done : "error_conditions", "basic functionality", etc
- * 	$extra_msg => Additional message that will be printed to indicate what specifics are being tested in this file. 
- * 	$alias => list any functions that are aliased to this
- * 	$test_sections => an array of arays of testcase code, keyed by section
- * Returns:
- * 	$test_sections
- */ 
-function gen_test_header($fn_name, $proto, $desc, $source_file, $type_msg, $extra_msg, $alias, $test_sections) {
-	$msg = "$type_msg";
-	if($extra_msg != NULL)
-  		$msg = "$msg - $extra_msg";
-
-
-
-	$test_sections['--TEST--'] = array("Test $fn_name() function : $type_msg $extra_msg"
-				);
-
-	$test_sections['--FILE--'] = array ("<?php",
-					"/* Prototype  : $proto",
-					" * Description: $desc",
-					" * Source code: $source_file",
-					" * Alias to functions: $alias",
- 					" */",
- 					"",
-					"echo \"*** Testing $fn_name() : $type_msg ***\\n\";",
-					""
-					);
-
-	return $test_sections;
-}
-/*
- * Generate error testcase and writes it to a file
- * 	1. Generates more than expected no. of argument case
- * 	2. Generates less than expected no. of argument case
- * Arguments:
- * 	$fn_det =>  array containing details of the function
- * 	$sections => The test case sections (eg --TEST--) as amn array
- * 	$test_case => The test case code as arrays keyed by section.
- * Returns:
- * 	The test case code as an array of arrays, indexed by section
- */
-function gen_error_test($fn_det, $sections, $test_case) {
-        $name = $fn_det['name'];
-        $proto = $fn_det['proto'];
-        $desc = $fn_det['desc'];
-        $source_file = $fn_det['source_file'];
-        $arg_det = $fn_det['arg_det'];
-        $arg_c = $fn_det['arg_c'];
-        $optional_args = $fn_det['optional_args'];
-        $alias = $fn_det['alias'];
-
-
-	// get the test header 
-	$test_case = gen_test_header($name, $proto, $desc, $source_file, "error conditions", NULL, $alias, $test_case);
-
-	if($fn_det['arg_c'] == 0 ) {
-		//If the function expects zero arguments generate a one arg test case and quit
-		$test_case['--FILE--'] = gen_one_arg_code($name, "extra_arg", "int" , $test_case['--FILE--']);
-
-	} else if (($fn_det['arg_c'] - $fn_det['optional_args']) == 1) { 
-		//If the function expects one argument generate a zero arg test case and two arg test case 
-		$test_case['--FILE--'] = gen_zero_arg_error_case($name, $test_case['--FILE--']);
-		$test_case['--FILE--'] = gen_morethanexpected_arg_error_case($name, $arg_det, $test_case['--FILE--']);
-	} else {
-		$test_case['--FILE--'] = gen_morethanexpected_arg_error_case($name, $arg_det, $test_case['--FILE--']);
-		$test_case['--FILE--'] = gen_lessthanexpected_arg_error_case($name, $arg_det, $arg_c, $optional_args, $test_case['--FILE--']);
-	}
-	// End the script
-	$test_case = gen_test_trailer($test_case, '--EXPECTF--');
-	write_file($test_case, $name, 'error', $sections);
-	return($test_case);
-}
-/*
- * Add the final lines of the testcase, the default is set to be EXPECTF.
- * Arguments: 
- * 	$test_case - An aray of arrays keyed by test section
- * 	$section_key - Type of EXPECT section, defaults to EXPECTF
- * Returns:
- * 	$test_case - completed test cases code as an array of arrays keyed by section
- */
-function gen_test_trailer($test_case, $section_key = "--EXPECTF--") {
-	//Complete the --FILE-- section
-	array_push($test_case['--FILE--'], "");
-	array_push($test_case['--FILE--'], "?>\n===DONE===");
-
-	//add a new key for the expect section
-	$test_case[$section_key]=array();
-	array_push($test_case[$section_key], "Expected output goes here"); 
-	array_push($test_case[$section_key], "===DONE==="); 
-
-	return $test_case;
-}
-/*
- * Writes test case code to a file
- * Arguments:
- * 	$test_case => Array of arrays of test sections, keyed by section
- * 	$function_name => Name of functio that tests are being generated for
- * 	$type => basic/error/variation
- * 	$test_sections => keys to $test_case
- * 	$seq = > sequence number, may be appended to file name
- * Returns:
- * 	Nothing at the moment - should be true/false depending on success
- */
-function write_file($test_case, $function_name, $type, $test_sections, $seq="") {
-	$file_name = $function_name."_".$type.$seq.".phpt";
-
-	$fp = fopen($file_name, 'w');
-	
-	foreach($test_sections as $section) {
-		if(array_key_exists($section, $test_case)) {
-		fwrite($fp, $section."\n");
-       			if(count($test_case[$section]) >0 ){
-                		foreach($test_case[$section] as $line_of_code) {
-					fwrite($fp, $line_of_code."\n");
-				}
-                	}
-		}
-        }
-	fclose($fp);
-}
-/* 
- * Generate code for testing different invalid values against an argument of the function 
- * Arguments:
- * 	$fn_name => name of the function
- * 	$arg_det => details of the each argument, stored in an array in the form of 'nameofargument' => 'typeofargument'
- * 	$which_arg => a numeric value starting from 1 indicating the argument of the 
- * 		function ( in $arg_det ) for which the case needs to be generated
- * 	$code_block => array of code which will be appended to
- * Returns:
- * 	$code_block
- */
-function gen_variation_diff_arg_values_test($fn_name, $arg_det, $which_arg, $code_block) {
-
-	$names = array_keys($arg_det);
-	$types = array_values($arg_det);
-
-	$blank_line = "";
-
-	// decrement the $which_arg so that its matches with  the index of $types
-	$which_arg--;
-	
-	//generate code to define error handler
-	$code_block = add_error_handler($code_block);
-
-	// generate code to initialise arguments that won't be substituted
-	array_push($code_block, "// Initialise function arguments not being substituted (if any)");
-	for($i = 0; $i < count($types); $i ++) {
-		if ($i != $which_arg) { // do not generate initialization code for the argument which is being tested
-			$i_stmt = get_variable_init_statement($types[$i], $names[$i]);
-                	array_push($code_block, $i_stmt);
-		}
-	}
-	array_push($code_block, $blank_line);
-	
-
-	// generate code to unset a variable
-	array_push($code_block, "//get an unset variable");
-	array_push($code_block, "\$unset_var = 10;");
-	array_push($code_block, "unset (\$unset_var);");
-	array_push($code_block, $blank_line);
-	
-	//define some classes
-	$code_block = define_classes($code_block);
-	
-	//add heredoc string
-	array_push($code_block, "// heredoc string");
-	array_push($code_block, "\$heredoc = <<<EOT");
-	array_push($code_block, "hello world");
-	array_push($code_block, "EOT;");
-	array_push($code_block, $blank_line);
-	
-	//add arrays
-	array_push($code_block, "// add arrays");
-	array_push($code_block, "\$index_array = array (1, 2, 3);");
-	array_push($code_block, "\$assoc_array = array ('one' => 1, 'two' => 2);");
-	array_push($code_block, $blank_line);
-	
-
-	//generate code for an array of values to iterate over
-	array_push($code_block, "//array of values to iterate over");
-	$code_block = gen_array_with_diff_values($types[$which_arg], 'inputs', $code_block);
-
-	//generate code for loop to iterate over array values
-	array_push($code_block, $blank_line);
-
-	array_push($code_block, "// loop through each element of the array for $names[$which_arg]");
-	array_push($code_block, $blank_line);
-	
-	array_push($code_block, "foreach(\$inputs as \$key =>\$value) {");
-	array_push($code_block, "      echo \"\\n--\$key--\\n\";");
-
-        // prepare the function call
-
-        // use all arguments including the optional ones to construct a single function call
-        $var_name = array();
-        foreach ($names as $nm) {
-                array_push($var_name, "$".$nm);
-        }
-	$var_name[$which_arg] = "\$value";
-        $all_args = implode(", ", $var_name);
-
-        array_push ($code_block, "      var_dump( $fn_name($all_args) );");
-	array_push ($code_block, "};");
-
-  
-	return $code_block;
-}
-/*
- * Generate code for testing more than expected no. of argument for error testcase
- * Arguments:
- *  	$fn_name => name of the function
- *  	$arg_det => details of the each argument, stored in an array in the form of 'nameofargument' => 'typeofargument'
- *  	$code_block => an array of code that will be appended to
- * Returns:
- *  	$code_block
- */
-function gen_morethanexpected_arg_error_case($fn_name, $arg_det ,$code_block) {
-	array_push($code_block, "");
-	array_push($code_block, "//Test $fn_name with one more than the expected number of arguments");
-	array_push($code_block, "echo \"\\n-- Testing $fn_name() function with more than expected no. of arguments --\\n\";");
-
-	$names = array_keys($arg_det);
-	$types = array_values($arg_det);
-  
-	//Initialise expected arguments
-	for($i = 0; $i < count($types); $i ++) {
-		$i_stmt = get_variable_init_statement($types[$i], $names[$i]); 
-		array_push($code_block, $i_stmt); 
-	}
-
-	// get the extra argument init statement
-	$i_stmt = get_variable_init_statement("int", "extra_arg"); 
-	array_push($code_block, $i_stmt); 
-
-	$var_name = array();
-	foreach ($names as $nm) {
-		array_push($var_name, "$".$nm);
-	}
-	$all_args = implode(", ", $var_name);
-
-	array_push($code_block, "var_dump( $fn_name($all_args, \$extra_arg) );");
-
-	return $code_block;
-}
-
-/* 
- * Generate code for testing less than expected no. of mandatory arguments for error testcase
- * Arguments:
- *  	$fn_name => name of the function
- *  	$arg_det => details of the each argument, stored in an array in the form of 'nameofargument' => 'typeofargument'
- *  	$arg_c =>  total count of arguments that $fn_name takes
- *  	$optional_args => total count of optional arguments that $fn_name takes
- *  	$code_block => an array of code that will be appended to
- * Returns:
- *  	$code_block
- */
-function gen_lessthanexpected_arg_error_case($fn_name, $arg_det, $arg_c, $optional_args, $code_block) {
-
-	$names = array_keys($arg_det);
-	$types = array_values($arg_det);
-
-	// check for no. of  mandatory arguments
-	// if there are no mandatory arguments - return 
-	// the code_block unchanged
-	$mandatory_args = $arg_c - $optional_args;
-	if($mandatory_args < 1) {
-		return ($code_block);
-	}
-
-	//Discard optional arguments and last mandatory arg
-	for ($i = 0; $i < $optional_args; $i++) {
-		$discard_n = array_pop($names);
-		$discard_v = array_pop($types);
-	}
-	$discard_n = array_pop($names);
-	$discard_v = array_pop($types);
-
-	array_push($code_block, "");
-	array_push($code_block, "// Testing $fn_name with one less than the expected number of arguments");
-        array_push($code_block, "echo \"\\n-- Testing $fn_name() function with less than expected no. of arguments --\\n\";");
-
-	for($i = 0; $i < count($names); $i ++) {
-		$i_stmt = get_variable_init_statement($types[$i], $names[$i]); 
-		array_push($code_block, $i_stmt);
-	}
-
-	$all_args = "";
-	if ($mandatory_args > 1) {
- 		$var_name = array();
-        	foreach ($names as $nm) {
-               		array_push($var_name, "$".$nm);
-        	}
-        	$all_args = implode(", ", $var_name);
-	}
-
-        array_push($code_block, "var_dump( $fn_name($all_args) );");
-
-        return $code_block;
-}
-/* 
- * Generates code for initalizing a given variable with value of same type
- * Arguments:
- * 	$var_type => data type of variable
- * 	$var_name => name of the variable
- * Returns:
- *	$code_block
- */
-function get_variable_init_statement( $var_type, $var_name ) {
-	$code = "";
-	if ($var_type == "int") {
-		$code = "\$$var_name = 10;";
-	} else if($var_type == "float") {
-		$code = "\$$var_name = 10.5;";
-	} else if($var_type == "array") {
-		$code = "\$$var_name = array(1, 2);";
-	} else if($var_type == "string") {
-		$code = "\$$var_name = 'string_val';";
-	} else if($var_type == "object") {
-		$code = "\$$var_name = new stdclass();";
-	} else if($var_type == 'bool' || $var_type == 'boolean') {
-		$code = "\$$var_name = true;";
-	} else if($var_type == 'mixed') {
-	// take a guess at int
-		$code = "\$$var_name = 1;";
-	} else {
-	$code = "\n//WARNING: Unable to initialise $var_name of type $var_type\n";
-}
-  return $code;
-}
-/* 
- * Generate code for function with one argument
- * Arguments:
- *  	$fn_name => name of the function
- *  	$arg_name => name of the argument
- *  	$arg_type => data type of the argument
- *  	$code_block => an array of code that will be appended to
- * Returns:
- *  	$code_block
- */
-function gen_one_arg_code($fn_name, $arg_name, $arg_type, $code_block) {
-	//Initialse the argument
-	$arg_one_init = get_variable_init_statement($arg_type, $arg_name);
-
-        //push code onto the array $code_block
-        array_push ($code_block, "// One argument");
-        array_push ($code_block, "echo \"\\n-- Testing $fn_name() function with one argument --\\n\";");
-        array_push ($code_block, "$arg_one_init;");
-        array_push ($code_block, "var_dump( $fn_name(\$$arg_name) );");
-  return $code_block;
-}
-/*  
- * Generates code for basic functionality test. The generated code
- * will test the function with it's mandatory arguments and with all optional arguments.
- * Arguments:
- *	$fn_name => name of the function
- *	$arg_det => details of the each argument, stored in an array in the form of 'nameofargument' => 'typeofargument'
- *	$arg_c =>  total count of arguments that $fn_name takes
- *	$optional_args. $optional_args => total count of optional arguments that $fn_name takes
- *	$code_block - an array of code that will be appended to
- * Returns:
- * 	$code_block with appends
- */
-function gen_basic_test_code($fn_name, $arg_det, $arg_c, $optional_args, $code_block) {
-	if($arg_c == 0) {
-		//Just generate Zero arg test case and return
-		$code_block = gen_zero_arg_error_case($fn_name, $code_block);
-		return $code_block;
-	}
-	$names = array_keys($arg_det);
-	$types = array_values($arg_det);
-  
-	// prepare code to initialize all reqd. arguments
-	array_push ($code_block, "");
-	array_push ($code_block, "// Initialise all required variables");
-	for($i = 0; $i < $arg_c; $i ++) {
-		$i_stmt = get_variable_init_statement($types[$i], $names[$i]);
-		array_push($code_block, $i_stmt);
-	}
-
-
-	// prepare the function calls
-
-	// all arguments including the optional ones 
-	$var_name = array();
-        foreach ($names as $nm) {
-                array_push($var_name, "$".$nm);
-        }
-        $all_args = implode(", ", $var_name);
-
-	array_push ($code_block, "");
-	array_push ($code_block, "// Calling $fn_name() with all possible arguments");
-        array_push ($code_block, "var_dump( $fn_name($all_args) );");
-
-	//now remove  the optional arguments and call the function with mandatory arguments only
-	if ($optional_args != 0) {
-		for ($i=0; $i < $optional_args; $i++) {
-			$discard_n = array_pop($var_name);
-		}
-		$args = implode(", ", $var_name);
-		array_push ($code_block, "");
-		array_push ($code_block, "// Calling $fn_name() with mandatory arguments");
-       		array_push ($code_block, "var_dump( $fn_name($args) );");
-	}	
-	return $code_block;
-}
-
-/*
- * Function to parse command line arguments
- * Returns:
- * 	$opt_array => array of options
- */
-function initialise_opt() {
-	$opt=array();
-	$opt['source_loc'] = NULL;
-	$opt['name'] = NULL;
-	$opt['error_gen'] = false;
-	$opt['basic_gen'] = false;
-	$opt['variation_gen'] = false;
-	$opt['include_block'] = NULL;
-	return $opt;
-}
-function parse_args ($arglist, $opt) 
-{
-        for($j = 1; $j<count($arglist); $j++) {
-                switch ($arglist[$j])
-                {
-                        case    '-s':
-                                $j++;
-                                $opt['source_loc'] = $arglist[$j];
-                                break;
-
-                        case    '-f':
-                                $j++;
-                                $opt['name'] = $arglist[$j];
-                                break;
-
-                        case    '-e':
-                                $opt['error_gen'] = true;
-                                break;
-
-                        case    '-b':
-                                $opt['basic_gen'] = true;
-                                break;
-
-                        case    '-v':
-                                $opt['variation_gen'] = true;
-                                break;
-                                
-                        case    '-i':
-								$j++;
-                                $opt['include_block'] = $arglist[$j];
-                                break;
-                                
-                        case	'-h':
-								print_opts();
-								break;
-
-                        default:
-                                echo "Command line option $arglist[$j] not recognised\n";
-                                print_opts();
-                }
-
-        }
-        return $opt;
-}
-/*
- * Function to check that source directory given for PHP source actually conatins PHP source
- */
-function check_source($src) 
-{
-        $ext_loc = $src."/ext";
-        if(!is_dir($ext_loc)) {
-                echo "A PHP source location is required, $src does not appear to be a valid source location\n";
-                print_opts();
-        }
-}
-/*
- * Function to check that a file name exists
- */
-function check_file($f) 
-{
-        if(!is_file($f)) {
-                echo "$f is not a valid file name \n";
-                print_opts();
-        }
-}
-/*
- * Function to check thet either a file name, a list of files or a function area has been supplied
- */
-function check_fname ($f)
-{
-        if($f == NULL ) { 
-                echo "Require a function name \n";
-                print_opts();
-        }
-}
-/*
- * Function to check that the user has requested a type of test case
- */
-function check_testcase($e, $v, $b) {
-        if(!$v && !$e && !$b) { 
-                echo "Need to specify which type of test to generate\n";
-                print_opts();
-        }
-}
-/*
- * Function to print out help text if any of the input data is incorrect
- */
-function print_opts() {
-		echo "\nUsage:\n";
-		echo "      php generate_phpt.php -s <location_of_source_code> -f <function_name> -b|e|v [-i file]\n\n";
-        echo "-s location_of_source_code ....... Top level directory of PHP source\n";
-        echo "-f function_name ................. Name of PHP function, eg cos\n";
-        echo "-b ............................... Generate basic tests\n";
-        echo "-e ............................... Generate error tests\n";
-        echo "-v ............................... Generate variation tests\n";
-        echo "-i file_containing_include_block.. Block of PHP code to be included in the test case\n";
-        echo "-h ............................... Print this message\n";
-        exit;
-}
-/* 
- * Generates a general testcase template and create the testcase file,
- * No code is added other than header and trailer
- * Arguments:
- *	$fn_det => Array with function details
- * 	$sections => List of test sections eg '--TEST--', '--FILE--'..
- * 	$type =>  basic/error/variation 
- * 	$php_file => name of file to import PHP code from
- * Returns:
- * 	$test_case => an array containing the complete test case
- */
-function gen_template($fn_det, $sections, $type, $php_file=NULL) {
-        $name = $fn_det['name'];
-        $proto = $fn_det['proto'];
-        $desc = $fn_det['desc'];
-        $source_file = $fn_det['source_file'];
-        $alias = $fn_det['alias'];
-
-	$test_case = array();
-
-	// get the test header and write into the file
-	$test_case = gen_test_header($name, $proto, $desc, $source_file, $type, "",$alias, $test_case);
-
-	// write the message to indicate the start of addition of code in the template file
-	if ($php_file == NULl) {
-		$msg = "\n // add test code here \n";
-		array_push($test_case['--FILE--'], $msg);
-	}else{
-		$test_case['--FILE--'] = read_include_file($php_file, $test_case['--FILE--']);
-	}
-
-	// end the script
-	$test_case = gen_test_trailer($test_case);
-	write_file($test_case, $name, $type, $sections);
-	return ($test_case);
-}
-/* 
- * Generate code for testing zero argument case for error testcase
- * Arguments:
- * 	$fn_name => name of the function
- * 	$code_block => array of code which will be appended to
- * Returns:
- * 	$code_block
- */ 
-function gen_zero_arg_error_case($fn_name, $code_block) {
-	//push code onto the array $code_block
-	array_push ($code_block, "// Zero arguments");
-	array_push ($code_block, "echo \"\\n-- Testing $fn_name() function with Zero arguments --\\n\";");
-	array_push ($code_block, "var_dump( $fn_name() );");
-  return $code_block;
-}
-function get_loc_proto($all_c, $fname, $source) {
-//get location 
-    $test_info['name'] = $fname;
-    $test_info['source_file'] = NULL;
-    $test_info['return_type'] = NULL;
-    $test_info['params'] = NULL;
-    $test_info['falias'] = false;
-    $test_info['found'] = false;
-    $test_info['alias'] = NULL;
-    $test_info['error'] = NULL;
-  
-    $escaped_source = preg_replace("/\\\/", "\\\\\\", $source);
-    $escaped_source = preg_replace("/\//", "\\\/", $escaped_source);
-    
-    
-	for ($i=0; $i<count($all_c); $i++)
-	{ 
-		$strings=file_get_contents(chop($all_c[$i]));
-		if (preg_match ("/FUNCTION\($fname\)/",$strings))
-		{
-			//strip build specific part of the implementation file name
-			preg_match("/$escaped_source\/(.*)$/", $all_c[$i], $tmp);
-			$test_info['source_file'] = $tmp[1];
-			//get prototype information
-			if (preg_match("/\/\*\s+{{{\s*proto\s+(\w*)\s*$fname\(\s*(.*)\s*\)(\n|)\s*(.*?)(\*\/|\n)/", $strings, $matches)) {
-				$test_info['return_type'] = $matches[1];
-				$test_info['params'] = $matches[2];
-				$test_info['desc'] = $matches[4];
-			}
-			else {
-				$test_info['error'] = "\nFailed to  parse prototype for $fname in $all_c[$i]".
-				"\nEither the {{{proto comment is too hard to parse, or ".
-				"\nthe real implementation is in an alias.\n";
-			}
-			$test_info['found'] = true;
-			if ((preg_match ("/FALIAS\($fname,\s*(\w+),.*\)/",$strings, $alias_name)) 
-			 || (preg_match ("/FALIAS\((\w+),\s*$fname.*\)/",$strings, $alias_name))) {
-			// There is another alias referred to in the same C source file. Make a note of it.
-			$test_info['falias'] = true;
-				if ( $test_info['alias'] != NULL) {
-                               		$test_info['alias']  = $test_info['alias']." ".$alias_name[1];
-                        	} else {
-                                	$test_info['alias'] = $alias_name[1];
-                        	}
-			}
-		}
-		elseif ((preg_match ("/FALIAS\($fname,\s*(\w+),.*\)/",$strings, $alias_name)) 
-		 || (preg_match ("/FALIAS\((\w+),\s*$fname.*\)/",$strings, $alias_name))) {
-			// There is an alias to the function in a different file from the main function definition - make a note of it
-			$test_info['falias'] = true;
-			if ( $test_info['alias'] != NULL) {
-				$test_info['alias']  = $test_info['alias']." ".$alias_name[1];
-			} else {
-				$test_info['alias'] = $alias_name[1];
-			}
-		}
-		//Some functions are in their own files and not declared using FUNTION/FALIAS. 
-		//If we haven't found either FUNCTION or FALIAS try just looking for the prototype 
-		elseif (preg_match ("/\/\*\s+{{{\s*proto\s+(\w*)\s*$fname\(\s*(.*)\s*\)(\n|)\s*(.*)\*\//", $strings, $matches)) {
-                        $test_info['return_type'] = $matches[1];
-                        $test_info['params'] = $matches[2];
-                        $test_info['desc'] = $matches[4];
-                        $test_info['found'] = true;
-			preg_match("/$escaped_source\/(.*)$/", $all_c[$i], $tmp);
-                        $test_info['source_file']= $tmp[1];
-                        //break;
-		}
-	}
-	return $test_info;
-}
-function add_error_handler($cb) {
-	array_push($cb, "// Define error handler");
-	array_push($cb, "function test_error_handler(\$err_no, \$err_msg, \$filename, \$linenum, \$vars) {");
-	array_push($cb, "	if (error_reporting() != 0) {");
-	array_push($cb, "		// report non-silenced errors");
-	array_push($cb, "		echo \"Error: \$err_no - \$err_msg, \$filename(\$linenum)\\n\";");
-	array_push($cb, "	}");
-	array_push($cb, "}");
-	array_push($cb, "set_error_handler('test_error_handler');");
-	array_push($cb, "");
-	
-	return $cb;
-	
-}
-
-function define_classes($cb) {
-	array_push($cb,"// define some classes");
-	array_push($cb,"class classWithToString");
-	array_push($cb,"{");
-	array_push($cb,"	public function __toString() {");
-	array_push($cb,"		return \"Class A object\";");
-	array_push($cb,"	}");
-	array_push($cb,"}");
-	array_push($cb,"");
-	array_push($cb,"class classWithoutToString");
-	array_push($cb,"{");
-	array_push($cb,"}");
-	array_push($cb,"");
-	
-	return $cb;
-}
-?>
author	Zoe Slattery <zoe@php.net>	2009-05-07 09:21:43 +0000
committer	Zoe Slattery <zoe@php.net>	2009-05-07 09:21:43 +0000
commit	cba448a9d358451338d57c5e45f7c7e06f3143d2 (patch)
tree	df77a5d196aca30ffeb295d7dd5e79dc2429422a /scripts
parent	903f306a60fddda0c7faf824d9252b08add34456 (diff)
download	php-git-cba448a9d358451338d57c5e45f7c7e06f3143d2.tar.gz