--- /dev/null
+<?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>
--- /dev/null
+<?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);
+
+?>
--- /dev/null
+$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
--- /dev/null
+$variation_array = array(
+ 'lowercase true' => true,
+ 'lowercase false' =>false,
+ 'uppercase TRUE' =>TRUE,
+ 'uppercase FALSE' =>FALSE,
+ );
\ No newline at end of file
--- /dev/null
+ *
+ */
\ No newline at end of file
--- /dev/null
+/**
+ *
\ No newline at end of file
--- /dev/null
+$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
--- /dev/null
+$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
--- /dev/null
+$variation_array = array (
+ 'int 0' => 0,
+ 'int 1' => 1,
+ 'int 12345' => 12345,
+ 'int -12345' => -2345,
+ );
\ No newline at end of file
--- /dev/null
+}
\ No newline at end of file
--- /dev/null
+foreach ( $variation_array as $var ) {
\ No newline at end of file
--- /dev/null
+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
--- /dev/null
+if (PHP_INT_SIZE != 4) die("skip this test is for 32bit platforms only");
--- /dev/null
+if (PHP_INT_SIZE != 8) die("skip this test is for 64bit platforms only");
--- /dev/null
+if (substr(PHP_OS, 0, 3) != 'WIN') die("skip this test is for Windows platforms only");
--- /dev/null
+if (substr(PHP_OS, 0, 3) == 'WIN') die("skip this test is not for Windows platforms");
--- /dev/null
+$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
--- /dev/null
+<?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++;
+ }
+
+}
+?>
--- /dev/null
+<?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
--- /dev/null
+<?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
--- /dev/null
+<?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
--- /dev/null
+<?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
--- /dev/null
+<?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
--- /dev/null
+<?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
--- /dev/null
+<?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
--- /dev/null
+<?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
--- /dev/null
+<?php
+
+ class gtMissingArgumentException extends RuntimeException
+ {
+ }
+
+?>
--- /dev/null
+<?php
+
+ class gtMissingOptionsException extends RuntimeException
+ {
+ }
+
+?>
\ No newline at end of file
--- /dev/null
+<?php
+
+ class gtUnknownOptionException extends RuntimeException
+ {
+ }
+
+?>
--- /dev/null
+<?php
+
+class gtUnknownSectionException extends RuntimeException
+ {
+ }
+?>
\ No newline at end of file
--- /dev/null
+<?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
--- /dev/null
+<?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
--- /dev/null
+<?php
+
+/**
+ * parent class for preconditions
+ *
+ */
+abstract class gtPreCondition {
+
+ abstract public function check($clo);
+
+ abstract public function getMessage();
+
+}
+?>
\ No newline at end of file
--- /dev/null
+<?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
--- /dev/null
+<?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
--- /dev/null
+<?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
--- /dev/null
+<?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
--- /dev/null
+<?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
--- /dev/null
+<?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
--- /dev/null
+<?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
--- /dev/null
+<?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
--- /dev/null
+<?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
--- /dev/null
+<?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
--- /dev/null
+<?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
--- /dev/null
+<?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
--- /dev/null
+<?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
--- /dev/null
+<?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
--- /dev/null
+<?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
--- /dev/null
+<?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
--- /dev/null
+<?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
--- /dev/null
+
+<?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
--- /dev/null
+<?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
--- /dev/null
+<?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
--- /dev/null
+
+Please supply a function or method name to be tested.
+
--- /dev/null
+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
--- /dev/null
+
+You have given a class name but not supplied a method name to test.
+The method name is required.
+
--- /dev/null
+
+Please specify basic, error or variation tests.
+
--- /dev/null
+
+The class name is not a valid PHP class name.
+Check that the extension containing the class is loaded.
+
--- /dev/null
+
+The function name is not a valid PHP function name.
+Check that the extension containing the function is loaded.
+
--- /dev/null
+
+The method name is not a valid PHP method name.
+Check that the extension containing the method is loaded.
+
--- /dev/null
+<?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
--- /dev/null
+<?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
--- /dev/null
+<?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
--- /dev/null
+<?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
--- /dev/null
+<?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
--- /dev/null
+<?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
--- /dev/null
+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
--- /dev/null
+<?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
--- /dev/null
+<?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
--- /dev/null
+<?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
--- /dev/null
+<?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
--- /dev/null
+<?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
--- /dev/null
+<?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
--- /dev/null
+<?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
--- /dev/null
+<?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
--- /dev/null
+<?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
--- /dev/null
+<?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
+++ /dev/null
-<?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;
-}
-?>
projects / php / commitdiff