Annotation of embedaddon/php/scripts/dev/generate-phpt.phar, revision 1.1
1.1 ! misho 1: <?php
! 2: Phar::mapPhar('generate-phpt.phar');
! 3: require 'phar://generate-phpt.phar/generate-phpt.php';
! 4: __HALT_COMPILER(); ?>
! 5:
! 6:
: & generate-phpt.php5 J5 ;& gtFunction.php J eGh&
! 7: gtText.php& J& Y& gtClassMap.php J B& texts/unknownMethod.txtl Jl 2_& texts/unknownClass.txti Ji op& texts/testTypeNotSpecified.txt2 J2 ? & texts/help.txt? J? o& texts/methodNotSpecified.txtc Jc &*l& & texts/functionOrMethodNotSpecified.txt8 J8 & texts/unknownFunction.txtr Jr ș& gtCodeSnippet.phpq Jq >1& gtAutoload.php7 J7 ˶& setup/gtCommandLineOptions.php) J) {& ) setup/preconditions/gtIsValidFunction.php& J& t& - setup/preconditions/gtIsSpecifiedTestType.phpp& Jp& ?Sܶ& * setup/preconditions/gtIfClassHasMethod.php& J& 5
! 8: & 5 setup/preconditions/gtIsSpecifiedFunctionOrMethod.php& J&
m& ' setup/preconditions/gtIsValidMethod.php2 J2 & & setup/preconditions/gtIsValidClass.php& J& ۧq& setup/gtPreConditionList.phpr Jr I& setup/gtOptionalSections.php J a?ж& / setup/exceptions/gtMissingArgumentException.phpO JO ´k& . setup/exceptions/gtUnknownSectionException.phpJ JJ & - setup/exceptions/gtUnknownOptionException.phpM JM y˶& . setup/exceptions/gtMissingOptionsException.phpL JL 9o & setup/gtPreCondition.php J Ay& gtTestCaseWriter.php& J& ËhS& gtMethod.php J g& codeSnippets/commentEnd.txt J U& codeSnippets/skipifwin.txtW JW ?& codeSnippets/commentStart.txt J n@& codeSnippets/float.txt J C0& codeSnippets/string.txt J 1& codeSnippets/loopStart.txt& J& ʕ& codeSnippets/skipifnotwin.txtX JX 5Yn& codeSnippets/array.txt& J& GJ& codeSnippets/loopClose.txt& J& & codeSnippets/boolean.txt J ?& codeSnippets/skipifnot64b.txtJ JJ pŶ& codeSnippets/skipif64btxtJ JJ |"˶& $ codeSnippets/emptyUnsetUndefNull.txt J !& codeSnippets/object.txtY JY |& codeSnippets/int.txtz Jz B& gtTestSubject.php J Pe& ' testcase/gtVariationContainerMethod.php3 J3 x& " testcase/gtBasicTestCaseMethod.php J O& testcase/gtErrorTestCase.php J & testcase/gtTestCase.php J "@& $ testcase/gtBasicTestCaseFunction.phpH JH x%& $ testcase/gtErrorTestCaseFunction.php J 1&& ( testcase/gtVariationTestCaseFunction.php J 5_& ) testcase/gtVariationContainerFunction.php; J; a& " testcase/gtErrorTestCaseMethod.php J "& testcase/gtBasicTestCase.phpu Ju UK%& ! testcase/gtVariationContainer.php J (=;& testcase/gtVariationTestCase.php J C& & testcase/gtVariationTestCaseMethod.php& J& j\& <?php
! 9: /**
! 10: * Main code for test case generation
! 11: */
! 12:
! 13: require_once dirname(__FILE__) . '/gtAutoload.php';
! 14:
! 15: //Version check. Will not run on less than PHP53;
! 16:
! 17: list($major, $minor, $bug) = explode(".", phpversion(), 3);
! 18: if($major == 5) {
! 19: if($minor < 3) { die("Sorry, you need PHP version 5.3 or greater to run this.\n"); }
! 20: }
! 21: if ($major < 5) { die ("Seriously, you need to upgrade you PHP level\n"); }
! 22:
! 23:
! 24: $options = new gtCommandLineOptions();
! 25: $optionalSections = new gtOptionalSections();
! 26:
! 27: try{
! 28: $options->parse($argv);
! 29: } catch (exception $e) {
! 30: echo $e->getMessage()."\n";
! 31: die();
! 32: }
! 33:
! 34: if($options->hasOption('h')) {
! 35: die(gtText::get('help'));
! 36: }
! 37:
! 38: try {
! 39: $preConditions = new gtPreConditionList();
! 40: $preConditions->check($options);
! 41: } catch (exception $e) {
! 42: echo $e->getMessage()."\n";
! 43: die();
! 44: }
! 45:
! 46: if($options->hasOption('s')) {
! 47: $optionalSections->setOptions($options);
! 48: }
! 49:
! 50:
! 51:
! 52: if($options->hasOption('c')) {
! 53: $name = $options->getOption('c')."_".$options->getOption('m');
! 54: $method = new gtMethod($options->getOption('c'), $options->getOption('m'));
! 55:
! 56: $method->setArgumentNames();
! 57: $method->setArgumentLists();
! 58: $method->setInitialisationStatements();
! 59:
! 60: $method->setConstructorArgumentNames();
! 61: $method->setConstructorInitStatements();
! 62: $method->setConstructorArgumentList();
! 63: }
! 64:
! 65: if($options->hasOption('f')) {
! 66: $name = $options->getOption('f');
! 67: $function = new gtFunction($name);
! 68: $function->setArgumentNames();
! 69: $function->setArgumentLists();
! 70: $function->setInitialisationStatements();
! 71: }
! 72:
! 73:
! 74: if($options->hasOption('b')) {
! 75: if($options->hasOption('c')) {
! 76: $testCase = gtBasicTestCase::getInstance($optionalSections, 'method');
! 77: $testCase->setMethod($method);
! 78: } else {
! 79: $testCase = gtBasicTestCase::getInstance($optionalSections);
! 80: $testCase->setFunction($function);
! 81: }
! 82:
! 83: $testCase->constructTestCase();
! 84: gtTestCaseWriter::write($name, $testCase->toString(), 'b');
! 85: }
! 86:
! 87: if($options->hasOption('e')) {
! 88: if($options->hasOption('c')) {
! 89: $testCase = gtErrorTestCase::getInstance($optionalSections, 'method');
! 90: $testCase->setMethod($method);
! 91: } else {
! 92: $testCase = gtErrorTestCase::getInstance($optionalSections);
! 93: $testCase->setFunction($function);
! 94: }
! 95:
! 96: $testCase->constructTestCase();
! 97: gtTestCaseWriter::write($name, $testCase->toString(), 'e');
! 98: }
! 99:
! 100:
! 101:
! 102: if($options->hasOption('v')) {
! 103: if($options->hasOption('c')) {
! 104: $testCaseContainer = gtVariationContainer::getInstance($optionalSections, 'method');
! 105: $testCaseContainer->setMethod($method);
! 106: } else {
! 107: $testCaseContainer = gtVariationContainer::getInstance ($optionalSections);
! 108: $testCaseContainer->setFunction($function);
! 109: }
! 110:
! 111: $testCaseContainer->constructAll();
! 112:
! 113: $tests = $testCaseContainer->getVariationTests();
! 114:
! 115: $count = 1;
! 116: foreach($tests as $test) {
! 117: gtTestCaseWriter::write($name, $test, 'v', $count);
! 118: $count++;
! 119: }
! 120:
! 121: }
! 122: ?>
! 123: <?php
! 124:
! 125: /**
! 126: * Class reperesents a single PHP function.
! 127: *
! 128: */
! 129: class gtFunction extends gtTestSubject {
! 130:
! 131: private $functionName;
! 132:
! 133: /**
! 134: * Set the name of the name of the function
! 135: *
! 136: * @param string $functionName
! 137: */
! 138: public function __construct($functionName) {
! 139: $this->functionName = $functionName;
! 140: }
! 141:
! 142:
! 143: /**
! 144: * Get the names of function argments and initialise mandatory and optional argument arrays
! 145: *
! 146: */
! 147: public function setArgumentNames() {
! 148: $function= new ReflectionFunction($this->functionName);
! 149:
! 150: foreach ($function->getParameters() as $i => $param) {
! 151: if($param->isOptional()) {
! 152: $this->optionalArgumentNames[] = $param->getName();
! 153: } else {
! 154: $this->mandatoryArgumentNames[] = $param->getName();
! 155: }
! 156: }
! 157: }
! 158:
! 159:
! 160: /**
! 161: * Return the name of the function
! 162: *
! 163: * @return string
! 164: */
! 165: public function getName() {
! 166: return $this->functionName;
! 167: }
! 168:
! 169: }
! 170: ?><?php
! 171:
! 172: /**
! 173: * Get a text message
! 174: *
! 175: */
! 176: class gtText
! 177: {
! 178:
! 179: /**
! 180: * Get the text message and return it
! 181: *
! 182: * @param string $name
! 183: * @return string
! 184: */
! 185: public static function get($name) {
! 186: $filename = dirname(__FILE__) . '/texts/' . $name . '.txt';
! 187:
! 188: if (!file_exists($filename)) {
! 189: throw new LogicException('The text ' . $name . ' does not exist');
! 190: }
! 191:
! 192: return file_get_contents($filename);
! 193: }
! 194: }
! 195:
! 196: ?><?php
! 197:
! 198: $gtClassMap = array(
! 199:
! 200: 'gtCodeSnippet' => 'gtCodeSnippet.php',
! 201: 'gtTestSubject' => 'gtTestSubject.php',
! 202: 'gtFunction' => 'gtFunction.php',
! 203: 'gtMethod' => 'gtMethod.php',
! 204: 'gtTestCaseWriter' => 'gtTestCaseWriter.php',
! 205: 'gtText' => 'gtText.php',
! 206:
! 207:
! 208:
! 209: 'gtCommandLineOptions' => 'setup/gtCommandLineOptions.php',
! 210: 'gtOptionalSections' => 'setup/gtOptionalSections.php',
! 211: 'gtMissingArgumentException' => 'setup/exceptions/gtMissingArgumentException.php',
! 212: 'gtUnknownOptionException' => 'setup/exceptions/gtUnknownOptionException.php',
! 213: 'gtUnknownSectionException' => 'setup/exceptions/gtUnknownSectionException.php',
! 214: 'gtMissingOptionsException' => 'setup/exceptions/gtMissingOptionsException.php',
! 215:
! 216: 'gtPreCondition' => 'setup/gtPreCondition.php',
! 217: 'gtPreConditionList' => 'setup/gtPreConditionList.php',
! 218: 'gtIsSpecifiedTestType' => 'setup/preconditions/gtIsSpecifiedTestType.php',
! 219: 'gtIfClassHasMethod' => 'setup/preconditions/gtIfClassHasMethod.php',
! 220: 'gtIsSpecifiedFunctionOrMethod' => 'setup/preconditions/gtIsSpecifiedFunctionOrMethod.php',
! 221: 'gtIsValidClass' => 'setup/preconditions/gtIsValidClass.php',
! 222: 'gtIsValidMethod' => 'setup/preconditions/gtIsValidMethod.php',
! 223: 'gtIsValidFunction' => 'setup/preconditions/gtIsValidFunction.php',
! 224:
! 225:
! 226: 'gtTestCase' => 'testcase/gtTestCase.php',
! 227: 'gtVariationTestCase' => 'testcase/gtVariationTestCase.php',
! 228: 'gtVariationTestCaseFunction' => 'testcase/gtVariationTestCaseFunction.php',
! 229: 'gtVariationTestCaseMethod' => 'testcase/gtVariationTestCaseMethod.php',
! 230:
! 231: 'gtBasicTestCase' => 'testcase/gtBasicTestCase.php',
! 232: 'gtBasicTestCaseFunction' => 'testcase/gtBasicTestCaseFunction.php',
! 233: 'gtBasicTestCaseMethod' => 'testcase/gtBasicTestCaseMethod.php',
! 234:
! 235: 'gtErrorTestCase' => 'testcase/gtErrorTestCase.php',
! 236: 'gtErrorTestCaseFunction' => 'testcase/gtErrorTestCaseFunction.php',
! 237: 'gtErrorTestCaseMethod' => 'testcase/gtErrorTestCaseMethod.php',
! 238:
! 239: 'gtVariationContainer' => 'testcase/gtVariationContainer.php',
! 240: 'gtVariationContainerMethod' => 'testcase/gtVariationContainerMethod.php',
! 241: 'gtVariationContainerFunction' => 'testcase/gtVariationContainerFunction.php',
! 242: );
! 243: ?>
! 244: The method name is not a valid PHP method name.
! 245: Check that the extension containing the method is loaded.
! 246:
! 247:
! 248: The class name is not a valid PHP class name.
! 249: Check that the extension containing the class is loaded.
! 250:
! 251:
! 252: Please specify basic, error or variation tests.
! 253:
! 254: Usage:
! 255: 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]
! 256:
! 257: Where:
! 258: -f function_name ................. Name of PHP function, eg cos
! 259: -c class name .....................Name of class, eg DOMDocument
! 260: -m method name ....................Name of method, eg createAttribute
! 261: -b ............................... Generate basic tests
! 262: -e ............................... Generate error tests
! 263: -v ............................... Generate variation tests
! 264: -s sections....................... Create optional sections, colon separated list
! 265: -k skipif key..................... Skipif option, only used if -s skipif is used.
! 266: -x extension.......................Skipif option, specify extension to check for
! 267: -h ............................... Print this message
! 268:
! 269: You have given a class name but not supplied a method name to test.
! 270: The method name is required.
! 271:
! 272:
! 273: Please supply a function or method name to be tested.
! 274:
! 275:
! 276: The function name is not a valid PHP function name.
! 277: Check that the extension containing the function is loaded.
! 278:
! 279: <?php
! 280:
! 281: /**
! 282: * Retrieves code snippets for adding to test cases
! 283: *
! 284: */
! 285: class gtCodeSnippet
! 286: {
! 287:
! 288: /**
! 289: * get the code snippet and initialise an array with it
! 290: *
! 291: * @param string $name
! 292: * @return array
! 293: */
! 294: public static function get($name) {
! 295:
! 296: $filename = dirname(__FILE__) . '/codeSnippets/' . $name . '.txt';
! 297:
! 298: if (!file_exists($filename)) {
! 299: throw new LogicException('The code snippet ' . $name . ' does not exist');
! 300: }
! 301:
! 302: $lines = file($filename);
! 303: foreach($lines as $l) {
! 304: $array[] = rtrim($l);
! 305: }
! 306: return $array;
! 307: }
! 308:
! 309:
! 310: /**
! 311: * Append the code snippet on to an existing array
! 312: *
! 313: * @param string $name
! 314: * @param array $array
! 315: * @return array
! 316: */
! 317: public static function append($name, $array) {
! 318: $filename = dirname(__FILE__) . '/codeSnippets/' . $name . '.txt';
! 319:
! 320: if (!file_exists($filename)) {
! 321: throw new LogicException('The code snippet ' . $name . ' does not exist');
! 322: }
! 323:
! 324: $text = file($filename);
! 325: foreach ($text as $t) {
! 326: $array[] = rtrim($t);
! 327: }
! 328:
! 329: return $array;
! 330: }
! 331:
! 332:
! 333: /**
! 334: * Appends blank entries on to an array
! 335: *
! 336: * @param int $numberOfLines
! 337: * @param array $array
! 338: * @return array
! 339: */
! 340: public static function appendBlankLines($numberOfLines, $array) {
! 341:
! 342: for ($i=0; $i< $numberOfLines; $i++) {
! 343: $array[] = "";
! 344: }
! 345:
! 346: return $array;
! 347: }
! 348:
! 349: }
! 350: ?><?php
! 351:
! 352:
! 353: gtAutoload::init();
! 354:
! 355: /**
! 356: * Autoloader using a map file (gtClassMap.php)
! 357: * defining the file to load each class from.
! 358: */
! 359: class gtAutoload
! 360: {
! 361: /**
! 362: * @var array
! 363: */
! 364: protected static $classMap;
! 365:
! 366: /**
! 367: * @var string
! 368: */
! 369: protected static $classPath;
! 370:
! 371:
! 372: /**
! 373: * Initialize the autoloader
! 374: *
! 375: * @return null
! 376: */
! 377: public static function init()
! 378: {
! 379: self::$classPath = dirname(__FILE__);
! 380:
! 381: if (substr(self::$classPath, -1) != '/') {
! 382: self::$classPath .= '/';
! 383: }
! 384:
! 385: if (file_exists(self::$classPath . 'gtClassMap.php')) {
! 386: include self::$classPath . 'gtClassMap.php';
! 387: self::$classMap = $gtClassMap;
! 388: }
! 389:
! 390: if (function_exists('__autoload')) {
! 391: spl_autoload_register('__autoload');
! 392: }
! 393:
! 394: spl_autoload_register(array('gtAutoload', 'autoload'));
! 395: }
! 396:
! 397:
! 398: /**
! 399: * Autoload method
! 400: *
! 401: * @param string $class Class name to autoload
! 402: * @return null
! 403: */
! 404: public static function autoload($class)
! 405: {
! 406: if (isset(self::$classMap[$class])) {
! 407: include self::$classPath . self::$classMap[$class];
! 408: }
! 409: }
! 410: }
! 411:
! 412: ?><?php
! 413:
! 414: /**
! 415: * Parse command line options
! 416: *
! 417: */
! 418: class gtCommandLineOptions {
! 419:
! 420: protected $shortOptions = array(
! 421: 'b',
! 422: 'e',
! 423: 'v',
! 424: 'h',
! 425: );
! 426:
! 427: protected $shortOptionsWithArgs = array(
! 428: 'c',
! 429: 'm',
! 430: 'f',
! 431: 'i',
! 432: 's',
! 433: 'x',
! 434: 'k',
! 435: );
! 436:
! 437: protected $options;
! 438:
! 439: protected function isShortOption($arg)
! 440: {
! 441: return (substr($arg, 0, 1) == '-') && (substr($arg, 1, 1) != '-');
! 442: }
! 443:
! 444: public function isValidOptionArg($array, $index) {
! 445: if (!isset($array[$index]))
! 446: {
! 447: return false;
! 448: }
! 449: return substr($array[$index], 0, 1) != '-';
! 450: }
! 451:
! 452:
! 453: public function parse($argv)
! 454: {
! 455: if(count($argv) < 2) {
! 456: throw new gtMissingOptionsException('Command line options are required');
! 457: }
! 458:
! 459: for ($i=1; $i<count($argv); $i++) {
! 460:
! 461: if ($this->isShortOption($argv[$i])) {
! 462: $option = substr($argv[$i], 1);
! 463: } else {
! 464: throw new gtUnknownOptionException('Unrecognised command line option ' . $argv[$i]);
! 465: }
! 466:
! 467: if (!in_array($option, array_merge($this->shortOptions, $this->shortOptionsWithArgs)))
! 468: {
! 469: throw new gtUnknownOptionException('Unknown option ' . $argv[$i]);
! 470: }
! 471:
! 472: if (in_array($option, $this->shortOptions)) {
! 473: $this->options[$option] = true;
! 474: continue;
! 475: }
! 476:
! 477: if (!$this->isValidOptionArg($argv, $i + 1))
! 478: {
! 479: throw new gtMissingArgumentException('Missing argument for command line option ' . $argv[$i]);
! 480: }
! 481:
! 482: $i++;
! 483: $this->options[$option] = $argv[$i];
! 484: }
! 485: }
! 486:
! 487: /**
! 488: *
! 489: */
! 490: public function getOption($option)
! 491: {
! 492: if (!isset($this->options[$option])) {
! 493: return false;
! 494: }
! 495: return $this->options[$option];
! 496: }
! 497:
! 498:
! 499: /**
! 500: * Check whether an option exists
! 501: */
! 502: public function hasOption($option)
! 503: {
! 504: return isset($this->options[$option]);
! 505: }
! 506:
! 507:
! 508: }
! 509: ?><?php
! 510:
! 511: /**
! 512: * Check that the function name is valid
! 513: *
! 514: */
! 515: class gtIsValidFunction extends gtPreCondition {
! 516:
! 517: public function check( $clo) {
! 518: if($clo->hasOption('f') ) {
! 519: $function = $clo->getOption('f');
! 520: $functions = get_defined_functions();
! 521: if( in_array( $function, $functions['internal'] ) ) {
! 522: return true;
! 523: }
! 524: return false;
! 525: }
! 526: return true;
! 527: }
! 528:
! 529: public function getMessage() {
! 530: return gtText::get('unknownFunction');
! 531: }
! 532: }
! 533: ?><?php
! 534:
! 535: /**
! 536: * Check that b|c|v is specified
! 537: *
! 538: */
! 539: class gtIsSpecifiedTestType extends gtPreCondition {
! 540:
! 541: public function check( $clo) {
! 542: if($clo->hasOption('b') || $clo->hasOption('e') || $clo->hasOption('v') ) {
! 543:
! 544: return true;
! 545: }
! 546: return false;
! 547: }
! 548:
! 549: public function getMessage() {
! 550: return gtText::get('testTypeNotSpecified');
! 551: }
! 552: }
! 553: ?><?php
! 554:
! 555: /**
! 556: * If use has requested a class check that method is specified
! 557: *
! 558: */
! 559: class gtIfClassHasMethod extends gtPreCondition {
! 560:
! 561: public function check( $clo) {
! 562: if($clo->hasOption('c')) {
! 563: if(!$clo->hasOption('m')) {
! 564: return false;
! 565: }
! 566: return true;
! 567: }
! 568: return true;
! 569: }
! 570:
! 571: public function getMessage() {
! 572: return gtText::get('methodNotSpecified');
! 573: }
! 574:
! 575: }
! 576: ?><?php
! 577:
! 578: /**
! 579: * Check that either a method or a function is specified
! 580: *
! 581: */
! 582: class gtIsSpecifiedFunctionOrMethod extends gtPreCondition {
! 583:
! 584: public function check( $clo) {
! 585: if($clo->hasOption('f') || $clo->hasOption('m')) {
! 586:
! 587: return true;
! 588: }
! 589: return false;
! 590: }
! 591:
! 592: public function getMessage() {
! 593: return gtText::get('functionOrMethodNotSpecified');
! 594: }
! 595: }
! 596: ?><?php
! 597:
! 598: /**
! 599: * Check that teh method name is valid
! 600: *
! 601: */
! 602: class gtIsValidMethod extends gtPreCondition {
! 603:
! 604: public function check( $clo) {
! 605: if($clo->hasOption('m') ) {
! 606: $className = $clo->getOption('c');
! 607: $class = new ReflectionClass($className);
! 608: $methods = $class->getMethods();
! 609: foreach($methods as $method) {
! 610: if($clo->getOption('m') == $method->getName()) {
! 611: return true;
! 612: }
! 613: }
! 614: return false;
! 615: }
! 616: return true;
! 617: }
! 618:
! 619: public function getMessage() {
! 620: return gtText::get('unknownMethod');
! 621: }
! 622: }
! 623: ?><?php
! 624:
! 625: /**
! 626: * Check that the class name is valid
! 627: *
! 628: */
! 629: class gtIsValidClass extends gtPreCondition {
! 630:
! 631: public function check( $clo) {
! 632: if($clo->hasOption('c') ) {
! 633: $className = $clo->getOption('c');
! 634: if( in_array( $className, get_declared_classes() ) ) {
! 635: return true;
! 636: }
! 637: return false;
! 638: }
! 639: return true;
! 640: }
! 641:
! 642: public function getMessage() {
! 643: return gtText::get('unknownClass');
! 644: }
! 645: }
! 646: ?><?php
! 647:
! 648: /**
! 649: * List of preconditions.
! 650: *
! 651: */
! 652: class gtPreConditionList {
! 653:
! 654: private $preConditions = array(
! 655: 'gtIsSpecifiedTestType',
! 656: 'gtIsSpecifiedFunctionOrMethod',
! 657: 'gtIfClassHasMethod',
! 658: 'gtIsValidClass',
! 659: 'gtIsValidFunction',
! 660: 'gtIsValidMethod',
! 661: );
! 662:
! 663:
! 664: /**
! 665: * Create an instance of each pre-condition and run their check methods
! 666: *
! 667: */
! 668: public function check($clo) {
! 669: foreach ($this->preConditions as $preCon) {
! 670: $checkThis = new $preCon;
! 671: if(!$checkThis->check($clo)) {
! 672: echo $checkThis->getMessage();
! 673: die(gtText::get('help'));
! 674: }
! 675: }
! 676: }
! 677: }
! 678: ?><?php
! 679: class gtOptionalSections {
! 680:
! 681: private $optSections = array(
! 682: 'skipif' => false,
! 683: 'ini' => false,
! 684: 'clean' => false,
! 685: 'done' => false,
! 686: );
! 687:
! 688: private $skipifKey = '';
! 689: private $skipifExt = '';
! 690:
! 691:
! 692: public function setOptions($commandLineOptions) {
! 693: if($commandLineOptions->hasOption('s')) {
! 694: $options = explode(':', $commandLineOptions->getOption('s'));
! 695:
! 696: foreach($options as $option) {
! 697:
! 698: if(array_key_exists($option, $this->optSections )) {
! 699: $this->optSections[$option] = true;
! 700: } else {
! 701: throw new gtUnknownSectionException('Unrecognised optional section');
! 702: }
! 703: }
! 704:
! 705: if($commandLineOptions->hasOption('k')) {
! 706: $this->skipifKey = $commandLineOptions->getOption('k');
! 707: }
! 708:
! 709: if($commandLineOptions->hasOption('x')) {
! 710: $this->skipifExt = $commandLineOptions->getOption('x');
! 711: }
! 712:
! 713: }
! 714: }
! 715:
! 716:
! 717:
! 718: public function getOptions() {
! 719: return $this->optSections;
! 720: }
! 721:
! 722:
! 723: public function getSkipifKey() {
! 724: return $this->skipifKey;
! 725: }
! 726:
! 727: public function getSkipifExt() {
! 728: return $this->skipifExt;
! 729: }
! 730:
! 731: public function hasSkipif() {
! 732: return $this->optSections['skipif'];
! 733: }
! 734:
! 735: public function hasSkipifKey() {
! 736: if($this->skipifKey != '') {
! 737: return true;
! 738: }
! 739: return false;
! 740: }
! 741:
! 742: public function hasSkipifExt() {
! 743: if($this->skipifExt != '') {
! 744: return true;
! 745: }
! 746: return false;
! 747: }
! 748: public function hasIni() {
! 749: return $this->optSections['ini'];
! 750: }
! 751:
! 752: public function hasClean() {
! 753: return $this->optSections['clean'];
! 754: }
! 755:
! 756: public function hasDone() {
! 757: return $this->optSections['done'];
! 758: }
! 759:
! 760:
! 761: }
! 762: ?><?php
! 763:
! 764: class gtMissingArgumentException extends RuntimeException
! 765: {
! 766: }
! 767:
! 768: ?>
! 769: <?php
! 770:
! 771: class gtUnknownSectionException extends RuntimeException
! 772: {
! 773: }
! 774: ?><?php
! 775:
! 776: class gtUnknownOptionException extends RuntimeException
! 777: {
! 778: }
! 779:
! 780: ?>
! 781: <?php
! 782:
! 783: class gtMissingOptionsException extends RuntimeException
! 784: {
! 785: }
! 786:
! 787: ?><?php
! 788:
! 789: /**
! 790: * parent class for preconditions
! 791: *
! 792: */
! 793: abstract class gtPreCondition {
! 794:
! 795: abstract public function check($clo);
! 796:
! 797: abstract public function getMessage();
! 798:
! 799: }
! 800: ?><?php
! 801:
! 802: /**
! 803: * Writes a single test case to a file
! 804: *
! 805: */
! 806: class gtTestCaseWriter {
! 807:
! 808: public static function write($name, $string, $type, $count = 0) {
! 809: if ($type == 'b') {
! 810: $fileName = $name."_basic.phpt";
! 811: }
! 812:
! 813: if ($type == 'e') {
! 814: $fileName = $name."_error.phpt";
! 815: }
! 816:
! 817: if ($type == 'v') {
! 818: $fileName = $name."_variation".$count.".phpt";
! 819: }
! 820:
! 821: $fh = fopen($fileName, 'w');
! 822: fwrite ($fh, $string);
! 823: fclose($fh);
! 824: }
! 825: }
! 826: ?><?php
! 827:
! 828: /**
! 829: * Class for method under test (see gtFunction for non-OO tests)
! 830: */
! 831: class gtMethod extends gtTestSubject {
! 832:
! 833: private $className;
! 834: private $methodName;
! 835: private $constructorArgumentNames;
! 836: private $constructorArgumentList = '';
! 837: private $constructorInitialisationStatements;
! 838:
! 839:
! 840:
! 841: /**
! 842: * Construct gtMethod object from the class and method names
! 843: *
! 844: * @param string $className
! 845: * @param string $methodName
! 846: */
! 847: public function __construct($className, $methodName) {
! 848: $this->className = $className;
! 849: $this->methodName = $methodName;
! 850: }
! 851:
! 852:
! 853: /**
! 854: * Set the names of the class constructor arguments. Take only mandatory argument names.
! 855: *
! 856: */
! 857: public function setConstructorArgumentNames() {
! 858: $reflectionClass = new ReflectionClass($this->className);
! 859: $constructor = $reflectionClass->getConstructor();
! 860: foreach($constructor->getParameters() as $i => $param) {
! 861: //if(!$param->isOptional()) {
! 862: $this->constructorArgumentNames[] = $param->getName();
! 863: //}
! 864: }
! 865: }
! 866:
! 867:
! 868: /**
! 869: * Set the names of the mandatory and optional arguments to the method
! 870: *
! 871: */
! 872: public function setArgumentNames() {
! 873:
! 874: $methodClass = new reflectionMethod($this->className, $this->methodName);
! 875: $parameters = $methodClass->getParameters();
! 876:
! 877: foreach ($methodClass->getParameters() as $i => $param) {
! 878: if($param->isOptional()) {
! 879: $this->optionalArgumentNames[] = $param->getName();
! 880: } else {
! 881: $this->mandatoryArgumentNames[] = $param->getName();
! 882: }
! 883:
! 884: }
! 885: }
! 886:
! 887:
! 888: /**
! 889: * Return the list of constructor argument names
! 890: *
! 891: * @return array
! 892: */
! 893: public function getConstructorArgumentNames() {
! 894: return $this->constructorArgumentNames;
! 895: }
! 896:
! 897: /**
! 898: * Return the name of the method
! 899: *
! 900: * @return string
! 901: */
! 902: public function getName() {
! 903: return $this->methodName;
! 904: }
! 905:
! 906:
! 907: /**
! 908: * Return the name of the class
! 909: *
! 910: * @return string
! 911: */
! 912: public function getClassName() {
! 913: return $this->className;
! 914: }
! 915:
! 916: /**
! 917: * Set the list of arguments to be passed to the constructor
! 918: *
! 919: */
! 920: public function setConstructorArgumentList() {
! 921: if(count ($this->constructorArgumentNames) > 0) {
! 922:
! 923: for( $i = 0; $i < count( $this->constructorArgumentNames ); $i++) {
! 924: $this->constructorArgumentList .= "\$".$this->constructorArgumentNames[$i].", ";
! 925: }
! 926: $this->constructorArgumentList = substr($this->constructorArgumentList, 0, -2);
! 927: }
! 928: }
! 929:
! 930:
! 931: /**
! 932: * Return the list of the arguments to be passed to the constructor
! 933: *
! 934: * @return string
! 935: */
! 936: public function getConstructorArgumentList() {
! 937: return $this->constructorArgumentList;
! 938: }
! 939:
! 940:
! 941: /**
! 942: * Set up the source statements that initialise constructor arguments;
! 943: *
! 944: */
! 945: public function setConstructorInitStatements() {
! 946: if(count ($this->constructorArgumentNames) > 0) {
! 947: foreach( $this->constructorArgumentNames as $name) {
! 948: $this->constructorInitialisationStatements[] = "\$".$name." = ";
! 949: }
! 950: }
! 951:
! 952: }
! 953:
! 954:
! 955: /**
! 956: * Return the constructor initialisation statements
! 957: *
! 958: * @return array
! 959: */
! 960: public function getConstructorInitStatements() {
! 961: return $this->constructorInitialisationStatements;
! 962: }
! 963: }
! 964: ?> *
! 965: */if (substr(PHP_OS, 0, 3) == 'WIN') die("skip this test is not for Windows platforms");
! 966: /**
! 967: *$variation_array = array(
! 968: 'float 10.5' => 10.5,
! 969: 'float -10.5' => -10.5,
! 970: 'float 12.3456789000e10' => 12.3456789000e10,
! 971: 'float -12.3456789000e10' => -12.3456789000e10,
! 972: 'float .5' => .5,
! 973: );$heredoc = <<<EOT
! 974: hello world
! 975: EOT;
! 976:
! 977: $variation_array = array(
! 978: 'string DQ' => "string",
! 979: 'string SQ' => 'string',
! 980: 'mixed case string' => "sTrInG",
! 981: 'heredoc' => $heredoc,
! 982: );foreach ( $variation_array as $var ) {if (substr(PHP_OS, 0, 3) != 'WIN') die("skip this test is for Windows platforms only");
! 983: $index_array = array(1, 2, 3);
! 984: $assoc_array = array(1 => 'one', 2 => 'two');
! 985:
! 986: $variation_array = array(
! 987: 'empty array' => array(),
! 988: 'int indexed array' => $index_array,
! 989: 'associative array' => $assoc_array,
! 990: 'nested arrays' => array('foo', $index_array, $assoc_array),
! 991: );}$variation_array = array(
! 992: 'lowercase true' => true,
! 993: 'lowercase false' =>false,
! 994: 'uppercase TRUE' =>TRUE,
! 995: 'uppercase FALSE' =>FALSE,
! 996: );if (PHP_INT_SIZE != 8) die("skip this test is for 64bit platforms only");
! 997: if (PHP_INT_SIZE != 4) die("skip this test is for 32bit platforms only");
! 998: $unset_var = 10;
! 999: unset($unset_var);
! 1000:
! 1001: $variation_array = array(
! 1002: 'unset var' => @$unset_var,
! 1003: 'undefined var' => @$undefined_var,
! 1004: 'empty string DQ' => "",
! 1005: 'empty string SQ' => '',
! 1006: 'uppercase NULL' => NULL,
! 1007: 'lowercase null' => null,
! 1008: );function test_error_handler($err_no, $err_msg, $filename, $linenum, $vars) {
! 1009: if (error_reporting() != 0) {
! 1010: // report non-silenced errors
! 1011: echo "Error: $err_no - $err_msg, $filename($linenum)\n";
! 1012: }
! 1013: }
! 1014: set_error_handler('test_error_handler');
! 1015:
! 1016:
! 1017:
! 1018: class classWithToString
! 1019: {
! 1020: public function __toString() {
! 1021: return "Class A object";
! 1022: }
! 1023: }
! 1024:
! 1025: class classWithoutToString
! 1026: {
! 1027: }
! 1028:
! 1029: $variation_array = array(
! 1030: 'instance of classWithToString' => new classWithToString(),
! 1031: 'instance of classWithoutToString' => new classWithoutToString(),
! 1032: );$variation_array = array (
! 1033: 'int 0' => 0,
! 1034: 'int 1' => 1,
! 1035: 'int 12345' => 12345,
! 1036: 'int -12345' => -2345,
! 1037: );<?php
! 1038: abstract class gtTestSubject {
! 1039:
! 1040: protected $optionalArgumentNames;
! 1041: protected $mandatoryArgumentNames;
! 1042:
! 1043: protected $extraArgumentList = '';
! 1044: protected $shortArgumentList = '';
! 1045:
! 1046: protected $allowedArgumentLists;
! 1047:
! 1048: protected $maximumArgumentList;
! 1049:
! 1050: protected $initialisationStatements;
! 1051:
! 1052:
! 1053: /** Return the list of all mandatory argument names
! 1054: *
! 1055: * @return array
! 1056: */
! 1057: public function getMandatoryArgumentNames() {
! 1058: return $this->mandatoryArgumentNames;
! 1059: }
! 1060:
! 1061:
! 1062: /**
! 1063: * Return the list of all optional argument names
! 1064: *
! 1065: * @return array
! 1066: */
! 1067: public function getOptionalArgumentNames() {
! 1068: return $this->optionalArgumentNames;
! 1069: }
! 1070:
! 1071: public function setArgumentLists() {
! 1072: $this->setValidArgumentLists();
! 1073: $this->setExtraArgumentList();
! 1074: $this->setShortArgumentList();
! 1075: }
! 1076:
! 1077: /**
! 1078: * Set the argument list to call the subject with. Adds one extra argument.
! 1079: *
! 1080: */
! 1081: public function setExtraArgumentList() {
! 1082: if(count ($this->mandatoryArgumentNames) > 0) {
! 1083: for( $i = 0; $i < count( $this->mandatoryArgumentNames ); $i++) {
! 1084: $this->extraArgumentList .= "\$".$this->mandatoryArgumentNames[$i].", ";
! 1085: }
! 1086: }
! 1087:
! 1088: if(count ($this->optionalArgumentNames) > 0) {
! 1089: for( $i = 0; $i < count( $this->optionalArgumentNames ); $i++) {
! 1090: $this->extraArgumentList .= "\$".$this->optionalArgumentNames[$i].", ";
! 1091: }
! 1092: }
! 1093:
! 1094: $this->extraArgumentList= $this->extraArgumentList. "\$extra_arg";
! 1095: }
! 1096:
! 1097:
! 1098: /**
! 1099: * Return the list of arguments as it appears in the function call
! 1100: *
! 1101: * @return string - list of arguments
! 1102: */
! 1103: public function getExtraArgumentList() {
! 1104: return $this->extraArgumentList;
! 1105: }
! 1106:
! 1107:
! 1108: /**
! 1109: * Set the list of function arguments to be one less that the number of mandatory arguments
! 1110: *
! 1111: */
! 1112: public function setShortArgumentList() {
! 1113:
! 1114: if(count ($this->mandatoryArgumentNames) > 0) {
! 1115: for( $i = 0; $i < count( $this->mandatoryArgumentNames ) - 1; $i++) {
! 1116: $this->shortArgumentList .= "\$".$this->mandatoryArgumentNames[$i].", ";
! 1117: }
! 1118: $this->shortArgumentList = substr($this->shortArgumentList, 0, -2);
! 1119: }
! 1120: }
! 1121:
! 1122:
! 1123: /**
! 1124: * Return the short list of arguments
! 1125: *
! 1126: * @return string - list of arguments
! 1127: */
! 1128: public function getShortArgumentList() {
! 1129: return $this->shortArgumentList;
! 1130: }
! 1131:
! 1132:
! 1133: /**
! 1134: * Construct the list of all possible ways to call the subject (function or method)
! 1135: *
! 1136: */
! 1137: public function setValidArgumentLists() {
! 1138: $this->allowedArgumentLists[0] = '';
! 1139: if(count ($this->mandatoryArgumentNames) > 0) {
! 1140: for( $i = 0; $i < count( $this->mandatoryArgumentNames ); $i++) {
! 1141: $this->allowedArgumentLists[0] .= "\$".$this->mandatoryArgumentNames[$i].", ";
! 1142: }
! 1143: }
! 1144:
! 1145: if(count ($this->optionalArgumentNames) > 0) {
! 1146: for( $i = 0; $i < count( $this->optionalArgumentNames ); $i++) {
! 1147: $this->allowedArgumentLists[] = $this->allowedArgumentLists[$i]."\$".$this->optionalArgumentNames[$i].", ";
! 1148: $this->allowedArgumentLists[$i] = substr ($this->allowedArgumentLists[$i], 0, -2);
! 1149: }
! 1150: }
! 1151:
! 1152: $this->allowedArgumentLists[count($this->allowedArgumentLists) -1 ] = substr($this->allowedArgumentLists[count($this->allowedArgumentLists) -1 ], 0, -2);
! 1153: }
! 1154:
! 1155:
! 1156: /**
! 1157: * Return the array of all possible sets of method/function arguments
! 1158: *
! 1159: * @return unknown
! 1160: */
! 1161: public function getValidArgumentLists() {
! 1162: return $this->allowedArgumentLists;
! 1163: }
! 1164:
! 1165:
! 1166: /**
! 1167: * Returns the argument list with teh greatest possible number of arguments.
! 1168: *
! 1169: * @return string
! 1170: */
! 1171: public function getMaximumArgumentList() {
! 1172: return end($this->allowedArgumentLists);
! 1173: }
! 1174:
! 1175:
! 1176: /**
! 1177: * Write initialisation statemenst for all the variables that might be used
! 1178: *
! 1179: */
! 1180: public function setInitialisationStatements() {
! 1181: if(count ($this->mandatoryArgumentNames) > 0) {
! 1182: foreach( $this->mandatoryArgumentNames as $name) {
! 1183: $this->initialisationStatements[] = "\$".$name." = ";
! 1184: }
! 1185: }
! 1186: if(count ($this->optionalArgumentNames) > 0) {
! 1187: foreach( $this->optionalArgumentNames as $name) {
! 1188: $this->initialisationStatements[] = "\$".$name." = ";
! 1189: }
! 1190: }
! 1191: }
! 1192:
! 1193: /**
! 1194: * Return the initialisation statements
! 1195: *
! 1196: * @return unknown
! 1197: */
! 1198: public function getInitialisationStatements() {
! 1199: return $this->initialisationStatements;
! 1200: }
! 1201: }
! 1202: ?><?php
! 1203: /**
! 1204: * Container for all possible variation test cases for a method
! 1205: */
! 1206: class gtVariationContainerMethod extends gtVariationContainer {
! 1207:
! 1208: protected $method;
! 1209: protected $optionalSections;
! 1210:
! 1211: public function __construct($osl) {
! 1212: $this->optionalSections = $osl;
! 1213: }
! 1214:
! 1215:
! 1216: /**
! 1217: * Sets the method to be tested
! 1218: *
! 1219: * @param gtMethod $method
! 1220: */
! 1221: public function setMethod(gtMethod $method) {
! 1222: $this->method = $method;
! 1223: }
! 1224:
! 1225:
! 1226: /**
! 1227: * Constructs all variation tests in $this_variationTests
! 1228: *
! 1229: */
! 1230: public function constructAll() {
! 1231:
! 1232: $numberOfArguments = count($this->method->getMandatoryArgumentNames()) + count($this->method->getOptionalArgumentNames());
! 1233:
! 1234: for($i = 1; $i <= $numberOfArguments; $i++) {
! 1235:
! 1236: foreach ($this->dataTypes as $d) {
! 1237:
! 1238: $testCase = gtVariationTestCase::getInstance($this->optionalSections, 'method');
! 1239: $testCase->setUp($this->method, $i, $d);
! 1240: $testCase->constructTestCase();
! 1241: $this->variationTests[] = $testCase->toString();
! 1242:
! 1243: }
! 1244: }
! 1245: }
! 1246: }
! 1247: ?><?php
! 1248:
! 1249: /**
! 1250: * Class for basic test case construction for class methods
! 1251: */
! 1252: class gtBasicTestCaseMethod extends gtBasicTestCase {
! 1253:
! 1254: public function __construct($opt) {
! 1255: $this->optionalSections = $opt;
! 1256: }
! 1257:
! 1258: /**
! 1259: * Set the method
! 1260: *
! 1261: * @param gtMethod $method
! 1262: */
! 1263: public function setMethod($method) {
! 1264: $this->subject = $method;
! 1265: }
! 1266:
! 1267: public function constructTestCase() {
! 1268: $this->constructCommonHeaders();
! 1269:
! 1270: $this->addBasicEcho();
! 1271:
! 1272: $this->constructorArgInit();
! 1273: $this->constructorCreateInstance();
! 1274:
! 1275: $this->constructSubjectCalls();
! 1276:
! 1277: $this->constructCommonClosing();
! 1278:
! 1279: }
! 1280:
! 1281: public function testHeader() {
! 1282: $this->testCase[] = "--TEST--";
! 1283: $this->testCase[] = "Test class ".$this->subject->getClassName()." method ".$this->subject->getName()."() by calling it with its expected arguments";
! 1284:
! 1285: }
! 1286:
! 1287: public function subjectCalls() {
! 1288: $lists = $this->subject->getValidArgumentLists();
! 1289:
! 1290: foreach($lists as $list){
! 1291: $this->testCase[] = "var_dump( \$class->".$this->subject->getName()."( ".$list." ) );";
! 1292: $this->testCase = gtCodeSnippet::appendBlankLines(1, $this->testCase );
! 1293: }
! 1294: $this->testCase = gtCodeSnippet::appendBlankLines(2, $this->testCase );
! 1295: }
! 1296:
! 1297: }
! 1298: ?><?php
! 1299:
! 1300: /**
! 1301: * Class for simple errors - one too many args and one too few
! 1302: */
! 1303:
! 1304: abstract class gtErrorTestCase extends gtTestCase {
! 1305:
! 1306: protected $shortArgumentList = '';
! 1307: protected $longArgumentList = '';
! 1308:
! 1309:
! 1310: /**
! 1311: * Return instance of either method or function error test case
! 1312: *
! 1313: * @param string $type
! 1314: * @return test case object
! 1315: */
! 1316: public static function getInstance($optionalSections, $type = 'function') {
! 1317:
! 1318: if($type == 'function') {
! 1319: return new gtErrorTestCaseFunction($optionalSections);
! 1320: }
! 1321: if($type =='method') {
! 1322: return new gtErrorTestCaseMethod($optionalSections);
! 1323: }
! 1324:
! 1325: }
! 1326:
! 1327: public function getShortArgumentList() {
! 1328: return $this->shortArgumentList;
! 1329: }
! 1330:
! 1331: public function getLongArgumentList() {
! 1332: return $this->longArgumentList;
! 1333: }
! 1334:
! 1335: public function constructSubjectCalls() {
! 1336: $this->argInit();
! 1337:
! 1338: //Initialise the additional argument
! 1339: $this->testCase[] = "\$extra_arg = ";
! 1340:
! 1341: $this->subjectCalls();
! 1342: }
! 1343:
! 1344: public function addErrorEcho() {
! 1345: $this->testCase[] = "echo \"*** Test by calling method or function with incorrect numbers of arguments ***\\n\"";
! 1346: $this->testCase = gtCodeSnippet::appendBlankLines(1, $this->testCase );
! 1347: }
! 1348: }
! 1349:
! 1350: ?><?php
! 1351:
! 1352: /**
! 1353: * Class for all test cases
! 1354: */
! 1355: abstract class gtTestCase {
! 1356:
! 1357:
! 1358: /**
! 1359: * The subject of the test, may be either a function (gtFunction) or a method (gtMethod)
! 1360: *
! 1361: * @var gtMethod or gtFunction
! 1362: */
! 1363: protected $subject;
! 1364:
! 1365:
! 1366: /**
! 1367: * Arry of strings containing the test case
! 1368: *
! 1369: * @var array
! 1370: */
! 1371: protected $testCase;
! 1372:
! 1373:
! 1374: /**
! 1375: * Object containing teh ooptional sections that may be added to the test case
! 1376: *
! 1377: * @var gtOptionalSections
! 1378: */
! 1379: protected $optionalSections;
! 1380:
! 1381:
! 1382: /**
! 1383: * Convert test case from array to string
! 1384: *
! 1385: * @return string
! 1386: */
! 1387: public function toString() {
! 1388: $testCaseString = "";
! 1389: foreach($this->testCase as $line) {
! 1390: $testCaseString .= $line."\n";
! 1391: }
! 1392: return $testCaseString;
! 1393: }
! 1394:
! 1395:
! 1396:
! 1397: /**
! 1398: * Returns test case as a array
! 1399: *
! 1400: * @return array
! 1401: */
! 1402: public function getTestCase() {
! 1403: return $this->testCase;
! 1404: }
! 1405:
! 1406:
! 1407: /**
! 1408: * Construct the common headers (title, file section..) of the test case
! 1409: *
! 1410: */
! 1411: public function ConstructCommonHeaders() {
! 1412: $this->testHeader();
! 1413:
! 1414: if($this->optionalSections->hasSkipif()) {
! 1415: $this->addSkipif();
! 1416: }
! 1417:
! 1418: if($this->optionalSections->hasIni()) {
! 1419: $this->addIni();
! 1420: }
! 1421:
! 1422: $this->fileOpening();
! 1423: }
! 1424:
! 1425:
! 1426: /**
! 1427: * Construct the common closing statements (clean, done, EXPECTF...)
! 1428: *
! 1429: */
! 1430: public function ConstructCommonClosing() {
! 1431: $this->fileClosing();
! 1432:
! 1433: if ($this->optionalSections->hasDone()) {
! 1434: $this->addDone();
! 1435: }
! 1436:
! 1437: if ($this->optionalSections->hasClean()) {
! 1438: $this->addClean();
! 1439: }
! 1440:
! 1441: $this->addExpectf();
! 1442: }
! 1443:
! 1444: /**
! 1445: * Start the FILE section of the test
! 1446: *
! 1447: */
! 1448: public function fileOpening() {
! 1449: $this->testCase[] = "--FILE--";
! 1450: $this->testCase[] = "<?php";
! 1451: $this->testCase = gtCodeSnippet::appendBlankLines(2, $this->testCase );
! 1452: }
! 1453:
! 1454:
! 1455: /**
! 1456: * Add contructor argument initialisation to test case
! 1457: *
! 1458: */
! 1459: public function constructorArgInit() {
! 1460: $conStatements = $this->subject->getConstructorInitStatements();
! 1461: foreach($conStatements as $statement) {
! 1462: $this->testCase[] = $statement;
! 1463: }
! 1464: }
! 1465:
! 1466:
! 1467: /**
! 1468: * Create instance of class in the test case
! 1469: *
! 1470: */
! 1471: public function constructorCreateInstance() {
! 1472: $constructorList = $this->subject->getConstructorArgumentList();
! 1473: $this->testCase[] = "\$class = new ".$this->subject->getClassName()."( ".$constructorList." );";
! 1474: $this->testCase = gtCodeSnippet::appendBlankLines(2, $this->testCase );
! 1475: }
! 1476:
! 1477:
! 1478: /**
! 1479: * Add function or method initilaisation statements to the test case
! 1480: *
! 1481: */
! 1482: public function argInit() {
! 1483: $statements = $this->subject->getInitialisationStatements();
! 1484: foreach($statements as $statement) {
! 1485: $this->testCase[] = $statement;
! 1486: }
! 1487: $this->testCase = gtCodeSnippet::appendBlankLines(2, $this->testCase );
! 1488: }
! 1489:
! 1490:
! 1491: /**
! 1492: * Add FILE section closing tag to teh test case
! 1493: *
! 1494: */
! 1495: public function fileClosing() {
! 1496: $this->testCase[] = "?>";
! 1497: }
! 1498:
! 1499:
! 1500: /**
! 1501: * Add a skipif section to the test case
! 1502: *
! 1503: */
! 1504: public function addSkipif() {
! 1505: $this->testCase[] = "--SKIPIF--";
! 1506: $this->testCase[] = "<?php";
! 1507: if($this->optionalSections->hasSkipifKey()) {
! 1508: $key = $this->optionalSections->getSkipifKey();
! 1509: //test standard skipif sections
! 1510: if($key == 'win') {
! 1511: $this->testCase = gtCodeSnippet::append('skipifwin', $this->testCase);
! 1512: }
! 1513: if($key == 'notwin' ) {
! 1514: $this->testCase = gtCodeSnippet::append('skipifnotwin', $this->testCase);
! 1515: }
! 1516:
! 1517: if($key == '64b' ) {
! 1518: $this->testCase = gtCodeSnippet::append('skipif64b', $this->testCase);
! 1519: }
! 1520:
! 1521: if($key == 'not64b' ) {
! 1522: $this->testCase = gtCodeSnippet::append('skipifnot64b', $this->testCase);
! 1523: }
! 1524: }
! 1525:
! 1526: if($this->optionalSections->hasSkipifExt()) {
! 1527: $ext = $this->optionalSections->getSkipifExt();
! 1528: $this->testCase[] = "if (!extension_loaded('$ext')) die ('skip $ext extension not available in this build');";
! 1529: }
! 1530: $this->testCase[] = "?>";
! 1531: }
! 1532:
! 1533:
! 1534: /**
! 1535: * Add an INI section to the test case
! 1536: *
! 1537: */
! 1538: public function addIni() {
! 1539: $this->testCase[] = "--INI--";
! 1540: $this->testCase[] = "";
! 1541: }
! 1542:
! 1543:
! 1544: /**
! 1545: * Add a clean section to the test case
! 1546: *
! 1547: */
! 1548: public function addClean() {
! 1549: $this->testCase[] = "--CLEAN--";
! 1550: $this->testCase[] = "<?php";
! 1551: $this->testCase[] = "?>";
! 1552: }
! 1553:
! 1554:
! 1555: /**
! 1556: * Add a ===DONE=== statement to the test case
! 1557: *
! 1558: */
! 1559: public function addDone() {
! 1560: $this->testCase[] = "===DONE===";
! 1561: }
! 1562:
! 1563:
! 1564: /**
! 1565: * Add an EXPECTF section
! 1566: *
! 1567: */
! 1568: public function addExpectf() {
! 1569: $this->testCase[] = "--EXPECTF--";
! 1570: if ($this->optionalSections->hasDone() ){
! 1571: $this->testCase[] = '===DONE===';
! 1572: }
! 1573: }
! 1574:
! 1575: public function getOpt() {
! 1576: return $this->optionalSections;
! 1577: }
! 1578: }
! 1579: ?><?php
! 1580:
! 1581: /**
! 1582: * Basic test case for a PHP function
! 1583: *
! 1584: */
! 1585: class gtBasicTestCaseFunction extends gtBasicTestCase {
! 1586:
! 1587:
! 1588: public function __construct($opt) {
! 1589: $this->optionalSections = $opt;
! 1590: }
! 1591:
! 1592: /**
! 1593: * Set the function name
! 1594: *
! 1595: * @param gtFunction $function
! 1596: */
! 1597: public function setFunction($function) {
! 1598: $this->subject = $function;
! 1599: }
! 1600:
! 1601: public function constructTestCase() {
! 1602: $this->constructCommonHeaders();
! 1603:
! 1604: $this->addBasicEcho();
! 1605:
! 1606: $this->constructSubjectCalls();
! 1607:
! 1608: $this->constructCommonClosing();
! 1609:
! 1610: }
! 1611:
! 1612:
! 1613: /**
! 1614: * Construct test case header
! 1615: *
! 1616: */
! 1617: public function testHeader() {
! 1618: //Opening section and start of test case array.
! 1619: $this->testCase[] = "--TEST--";
! 1620: $this->testCase[] = "Test function ".$this->subject->getName()."() by calling it with its expected arguments";
! 1621: }
! 1622:
! 1623: /**
! 1624: * Add the test section to call the function
! 1625: *
! 1626: */
! 1627: public function subjectCalls() {
! 1628: // Construct the argument list to pass to the function being tested
! 1629: $lists = $this->subject->getValidArgumentLists();
! 1630:
! 1631: foreach($lists as $list){
! 1632:
! 1633: $this->testCase = gtCodeSnippet::appendBlankLines(1, $this->testCase );
! 1634: $this->testCase[] = "var_dump(".$this->subject->getName()."( ".$list." ) );";
! 1635: }
! 1636: $this->testCase = gtCodeSnippet::appendBlankLines(2, $this->testCase );
! 1637: }
! 1638:
! 1639: }
! 1640: ?><?php
! 1641:
! 1642: /**
! 1643: * Error test case for a PHP function
! 1644: *
! 1645: */
! 1646: class gtErrorTestCaseFunction extends gtErrorTestCase {
! 1647:
! 1648: public function __construct($opt) {
! 1649: $this->optionalSections = $opt;
! 1650: }
! 1651:
! 1652: /**
! 1653: * Set the function name
! 1654: *
! 1655: * @param string $function
! 1656: */
! 1657: public function setFunction($function) {
! 1658: $this->subject = $function;
! 1659: }
! 1660:
! 1661:
! 1662: /**
! 1663: * Construct the test case as an array of strings
! 1664: *
! 1665: */
! 1666: public function constructTestCase() {
! 1667: $this->constructCommonHeaders();
! 1668:
! 1669: $this->addErrorEcho();
! 1670:
! 1671: $this->constructSubjectCalls();
! 1672:
! 1673: $this->constructCommonClosing();
! 1674:
! 1675: }
! 1676:
! 1677:
! 1678: public function testHeader() {
! 1679: $this->testCase[] = "--TEST--";
! 1680: $this->testCase[] = "Test function ".$this->subject->getName()."() by calling it more than or less than its expected arguments";
! 1681: }
! 1682:
! 1683: public function subjectCalls() {
! 1684: // Construct the argument lists to pass to the function being tested
! 1685: $list = $this->subject->getExtraArgumentList();
! 1686: $this->testCase = gtCodeSnippet::appendBlankLines(1, $this->testCase );
! 1687: $this->testCase[] = "var_dump(".$this->subject->getName()."( ".$list." ) );";
! 1688:
! 1689: $list = $this->subject->getShortArgumentList();
! 1690: $this->testCase = gtCodeSnippet::appendBlankLines(1, $this->testCase );
! 1691: $this->testCase[] = "var_dump(".$this->subject->getName()."( ".$list." ) );";
! 1692: $this->testCase = gtCodeSnippet::appendBlankLines(2, $this->testCase );
! 1693: }
! 1694:
! 1695: }
! 1696: ?><?php
! 1697:
! 1698: /**
! 1699: * Class for variation tests for a PHP function
! 1700: */
! 1701: class gtVariationTestCaseFunction extends gtVariationTestCase {
! 1702:
! 1703: protected $argumentNumber;
! 1704: protected $variationData;
! 1705: protected $testCase;
! 1706:
! 1707: public function __construct($opt) {
! 1708: $this->optionalSections = $opt;
! 1709: }
! 1710: /**
! 1711: * Set data neede to construct variation tests
! 1712: *
! 1713: * @param gtfunction $function
! 1714: * @param string $argumentNumber
! 1715: * @param string $variationData
! 1716: */
! 1717: public function setUp(gtfunction $function, $argumentNumber, $variationData) {
! 1718: $this->subject = $function;
! 1719: $this->argumentNumber = $argumentNumber;
! 1720: $this->variationData = $variationData;
! 1721:
! 1722: }
! 1723:
! 1724:
! 1725: /**
! 1726: * Constructs the test case as a array of strings
! 1727: *
! 1728: */
! 1729: public function constructTestCase() {
! 1730: $this->constructCommonHeaders();
! 1731:
! 1732: $this->addVariationEcho();
! 1733:
! 1734: $this->constructSubjectCalls();
! 1735:
! 1736: $this->constructCommonClosing();
! 1737:
! 1738: }
! 1739: public function testHeader() {
! 1740: $this->testCase[] = "--TEST--";
! 1741: $this->testCase[] = "Test function ".$this->subject->getName()."() by substituting argument ".$this->argumentNumber." with ".$this->variationData." values.";
! 1742: }
! 1743:
! 1744:
! 1745: public function subjectCalls() {
! 1746: $this->testCase = gtCodeSnippet::append('loopStart', $this->testCase);
! 1747:
! 1748: // Construct the argument list to pass to the function being tested
! 1749: $argumentList = explode(",", $this->subject->getMaximumArgumentList());
! 1750: $argumentList[$this->argumentNumber -1 ] = "\$var ";
! 1751: $list = implode(", ", $argumentList);
! 1752:
! 1753:
! 1754: $this->testCase[] = " var_dump(".$this->subject->getName()."( ".$list." ) );";
! 1755: $this->testCase = gtCodeSnippet::append('loopClose', $this->testCase);
! 1756: }
! 1757:
! 1758: }
! 1759: ?><?php
! 1760:
! 1761: /**
! 1762: * Container for all possible variation test cases of functions
! 1763: */
! 1764: class gtVariationContainerFunction extends gtVariationContainer {
! 1765:
! 1766: protected $function;
! 1767: protected $optionalSections;
! 1768:
! 1769: public function __construct($osl) {
! 1770: $this->optionalSections = $osl;
! 1771: }
! 1772:
! 1773: /**
! 1774: * Sets function being tested
! 1775: *
! 1776: * @param gtFunction $function
! 1777: */
! 1778: public function setFunction(gtFunction $function) {
! 1779: $this->function = $function;
! 1780: }
! 1781:
! 1782:
! 1783: /**
! 1784: * Constucts all possible variation testcases in array $this->variationTests
! 1785: *
! 1786: */
! 1787: public function constructAll() {
! 1788:
! 1789:
! 1790: $numberOfArguments = count($this->function->getMandatoryArgumentNames()) + count($this->function->getOptionalArgumentNames());
! 1791: for($i = 1; $i <= $numberOfArguments; $i++) {
! 1792: foreach ($this->dataTypes as $d) {
! 1793: $testCase = gtVariationTestCase::getInstance($this->optionalSections);
! 1794: $testCase->setUp($this->function, $i, $d);
! 1795: $testCase->constructTestCase();
! 1796: $this->variationTests[] = $testCase->toString();
! 1797: }
! 1798: }
! 1799: }
! 1800: }
! 1801: ?><?php
! 1802:
! 1803: /**
! 1804: * Error test case for a PHP method
! 1805: *
! 1806: */
! 1807: class gtErrorTestCaseMethod extends gtErrorTestCase {
! 1808:
! 1809: public function __construct($opt) {
! 1810: $this->optionalSections = $opt;
! 1811: }
! 1812: private $method;
! 1813:
! 1814: /**
! 1815: * Set the method name
! 1816: *
! 1817: * @param string $method
! 1818: */
! 1819: public function setMethod($method) {
! 1820: $this->subject = $method;
! 1821: }
! 1822:
! 1823:
! 1824: /**
! 1825: * Construct the test case as an array of strings
! 1826: *
! 1827: */
! 1828: public function constructTestCase() {
! 1829: $this->constructCommonHeaders();
! 1830:
! 1831: $this->addErrorEcho();
! 1832:
! 1833: $this->constructorArgInit();
! 1834: $this->constructorCreateInstance();
! 1835:
! 1836: $this->constructSubjectCalls();
! 1837:
! 1838: $this->constructCommonClosing();
! 1839: }
! 1840:
! 1841: public function testHeader() {
! 1842: $this->testCase[] = "--TEST--";
! 1843: $this->testCase[] = "Test class ".$this->subject->getClassName()." method ".$this->subject->getName()."() by calling it more than or less than its expected arguments";
! 1844: }
! 1845:
! 1846: public function subjectCalls() {
! 1847:
! 1848: // Construct the argument list to pass to the method being tested
! 1849: $list = $this->subject->getExtraArgumentList();
! 1850: $this->testCase = gtCodeSnippet::appendBlankLines(1, $this->testCase );
! 1851: $this->testCase[] = "var_dump(".$this->subject->getName()."( ".$list." ) );";
! 1852:
! 1853: $list = $this->subject->getShortArgumentList();
! 1854: $this->testCase = gtCodeSnippet::appendBlankLines(1, $this->testCase );
! 1855: $this->testCase[] = "var_dump(".$this->subject->getName()."( ".$list." ) );";
! 1856:
! 1857: }
! 1858: }
! 1859: ?><?php
! 1860:
! 1861: /**
! 1862: * Class for basic test case construction
! 1863: */
! 1864:
! 1865: abstract class gtBasicTestCase extends gtTestCase {
! 1866:
! 1867: protected $subject;
! 1868:
! 1869:
! 1870: /**
! 1871: * Returns an instance of a test case for a method or a function
! 1872: *
! 1873: * @param string $type
! 1874: * @return test case object
! 1875: */
! 1876: public static function getInstance($optionalSections, $type = 'function') {
! 1877: if($type == 'function') {
! 1878: return new gtBasicTestCaseFunction($optionalSections);
! 1879: }
! 1880: if($type =='method') {
! 1881: return new gtBasicTestCaseMethod($optionalSections);
! 1882: }
! 1883: }
! 1884:
! 1885: public function constructSubjectCalls() {
! 1886: $this->argInit();
! 1887: $this->subjectCalls();
! 1888: }
! 1889:
! 1890: public function addBasicEcho() {
! 1891: $this->testCase[] = "echo \"*** Test by calling method or function with its expected arguments ***\\n\"";
! 1892: $this->testCase = gtCodeSnippet::appendBlankLines(1, $this->testCase );
! 1893: }
! 1894: }
! 1895: ?><?php
! 1896:
! 1897: /**
! 1898: * Container for all possible variation test cases
! 1899: */
! 1900: abstract class gtVariationContainer {
! 1901:
! 1902: protected $variationTests;
! 1903:
! 1904: protected $dataTypes = array (
! 1905: 'array',
! 1906: 'boolean',
! 1907: 'emptyUnsetUndefNull',
! 1908: 'float',
! 1909: 'int',
! 1910: 'object',
! 1911: 'string',
! 1912: );
! 1913:
! 1914:
! 1915:
! 1916: /**
! 1917: * Return an instance of a containers for either function or method tests
! 1918: *
! 1919: * @param string $type
! 1920: * @return variation test container
! 1921: */
! 1922: public static function getInstance ($optionalSections, $type = 'function') {
! 1923:
! 1924: if($type == 'function') {
! 1925: return new gtVariationContainerFunction($optionalSections);
! 1926: }
! 1927: if($type =='method') {
! 1928: return new gtVariationContainerMethod($optionalSections);
! 1929: }
! 1930:
! 1931: }
! 1932:
! 1933:
! 1934: public function constructAll() {
! 1935: }
! 1936:
! 1937:
! 1938: /**
! 1939: * Returns all varaition tests as an array of arrays
! 1940: *
! 1941: * @return string
! 1942: */
! 1943: public function getVariationTests() {
! 1944: return $this->variationTests;
! 1945: }
! 1946:
! 1947: }
! 1948: ?>
! 1949: <?php
! 1950:
! 1951: /**
! 1952: * Class for extended variations. Needs 'data type' and argument to vary
! 1953: */
! 1954:
! 1955: abstract class gtVariationTestCase extends gtTestCase {
! 1956:
! 1957:
! 1958: /**
! 1959: * Returns an instance of a test case for a method or a function
! 1960: *
! 1961: * @param string $type
! 1962: * @return test case object
! 1963: */
! 1964: public static function getInstance($optionalSections, $type = 'function') {
! 1965:
! 1966: if($type == 'function') {
! 1967: return new gtVariationTestCaseFunction($optionalSections);
! 1968: }
! 1969: if($type =='method') {
! 1970: return new gtVariationTestCaseMethod($optionalSections);
! 1971: }
! 1972:
! 1973: }
! 1974:
! 1975: public function argInitVariation() {
! 1976: $statements = $this->subject->getInitialisationStatements();
! 1977: for($i=0; $i<count($statements); $i++) {
! 1978: if($i != ( $this->argumentNumber -1) ) {
! 1979: $this->testCase[] = $statements[$i];
! 1980: }
! 1981: }
! 1982: $this->testCase = gtCodeSnippet::appendBlankLines(2, $this->testCase );
! 1983: }
! 1984:
! 1985: public function addVariationCode() {
! 1986: $this->testCase = gtCodeSnippet::append($this->variationData, $this->testCase);
! 1987: $this->testCase = gtCodeSnippet::appendBlankLines(2, $this->testCase );
! 1988: }
! 1989:
! 1990: public function constructSubjectCalls() {
! 1991: $this->argInitVariation();
! 1992: $this->addVariationCode();
! 1993: $this->subjectCalls();
! 1994: }
! 1995:
! 1996: public function addVariationEcho() {
! 1997: $this->testCase[] = "echo \"*** Test substituting argument ".$this->argumentNumber." with ".$this->variationData." values ***\\n\";";
! 1998: $this->testCase = gtCodeSnippet::appendBlankLines(1, $this->testCase );
! 1999: }
! 2000:
! 2001: }
! 2002: ?><?php
! 2003:
! 2004: /**
! 2005: * Class for variation tests for a PHP method
! 2006: */
! 2007: class gtVariationTestCaseMethod extends gtVariationTestCase {
! 2008:
! 2009: protected $subject;
! 2010: protected $argumentNumber;
! 2011: protected $variationData;
! 2012: protected $testCase;
! 2013:
! 2014: public function __construct($opt) {
! 2015: $this->optionalSections = $opt;
! 2016: }
! 2017:
! 2018: /**
! 2019: * Set data neede to construct variation tests
! 2020: *
! 2021: * @param gtMethod $method
! 2022: * @param string $argumentNumber
! 2023: * @param string $variationData
! 2024: */
! 2025: public function setUp(gtMethod $method, $argumentNumber, $variationData) {
! 2026: $this->subject = $method;
! 2027: $this->argumentNumber = $argumentNumber;
! 2028: $this->variationData = $variationData;
! 2029: }
! 2030:
! 2031:
! 2032: /**
! 2033: * Constructs the test case as a array of strings
! 2034: *
! 2035: */
! 2036: public function constructTestCase() {
! 2037: $this->constructCommonHeaders();
! 2038:
! 2039: $this->addVariationEcho();
! 2040:
! 2041: $this->constructorArgInit();
! 2042: $this->constructorCreateInstance();
! 2043:
! 2044: $this->constructSubjectcalls();
! 2045: $this->constructCommonClosing();
! 2046:
! 2047: }
! 2048:
! 2049: public function testHeader() {
! 2050: $this->testCase[] = "--TEST--";
! 2051: $this->testCase[] = "Test class ".$this->subject->getClassName()." method ".$this->subject->getName()."() by substituting argument ".$this->argumentNumber." with ".$this->variationData." values.";
! 2052: }
! 2053:
! 2054: public function subjectCalls() {
! 2055: $this->testCase = gtCodeSnippet::append('loopStart', $this->testCase);
! 2056: // Construct the argument list to pass to the method being tested
! 2057: $argumentList = explode(",", $this->subject->getMaximumArgumentList());
! 2058: $argumentList[$this->argumentNumber -1 ] = "\$var ";
! 2059: $list = implode(", ", $argumentList);
! 2060:
! 2061:
! 2062: $this->testCase[] = " var_dump(\$class->".$this->subject->getName()."( ".$list." ) );";
! 2063: $this->testCase = gtCodeSnippet::append('loopClose', $this->testCase);
! 2064:
! 2065: }
! 2066:
! 2067: }
! 2068:
! 2069: ?>:yD7`_gDU GBMB
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to generate-phpt.phar CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / scripts / dev