[Summary view] [Print] [Text view]

   1  <?php
   2  /**
   3  * @package WACT_TESTS
   4  * @version $Id: expression.test.php,v 1.13 2004/11/12 21:25:15 jeffmoore Exp $
   5  */
   6  /**
   7  * Includes
   8  */
   9  
  10  require_once WACT_ROOT . 'template/compiler/templatecompiler.inc.php';
  11  
  12  Mock::Generate('CompilerComponent', 'MockCompilerComponent');
  13  Mock::Generate('CodeWriter', 'MockCodeWriter');
  14  Mock::Generate('DataBindingExpression', 'MockDataBindingExpression');
  15  
  16  Mock::generatePartial(
  17          'Expression',
  18          'ExpressionPartialMock',
  19          array('createValue'));
  20  
  21  /**
  22  * @package WACT_TESTS
  23  */
  24  class ExpressionTestCase extends UnitTestCase {
  25  	function ExpressionTestCase($name = 'Expression test cases') {
  26          parent::UnitTestCase($name);
  27      }
  28  
  29      function testCreateValueInteger() {
  30          $expression =& new Expression('29', new MockCompilerComponent($this), 'raw');
  31          $this->assertTrue($expression->isConstant());
  32          $this->assertEqual($expression->getValue(), 29);
  33      }
  34  
  35      function testCreateValueFloat() {
  36          $expression =& new Expression('1.5', new MockCompilerComponent($this), 'raw');
  37          $this->assertTrue($expression->isConstant());
  38          $this->assertEqual($expression->getValue(), 1.5);
  39      }
  40  
  41      function testCreateValueNegInteger() {
  42          $expression =& new Expression('-29', new MockCompilerComponent($this), 'raw');
  43          $this->assertTrue($expression->isConstant());
  44          $this->assertEqual($expression->getValue(), -29);
  45      }
  46  
  47      function testCreateValueNegFloat() {
  48          $expression =& new Expression('-1.5', new MockCompilerComponent($this), 'raw');
  49          $this->assertTrue($expression->isConstant());
  50          $this->assertEqual($expression->getValue(), -1.5);
  51      }
  52  
  53      function testCreateValueSingleString() {
  54          $expression =& new Expression("'hello'", new MockCompilerComponent($this), 'raw');
  55          $this->assertTrue($expression->isConstant());
  56          $this->assertEqual($expression->getValue(), 'hello');
  57      }
  58  
  59      function testCreateValueDoubleString() {
  60          $expression =& new Expression('"hello"', new MockCompilerComponent($this), 'raw');
  61          $this->assertTrue($expression->isConstant());
  62          $this->assertEqual($expression->getValue(), 'hello');
  63      }
  64  
  65  }
  66  
  67  class ExpressionPartialTestCase extends UnitTestCase {
  68  	function ExpressionPartialTestCase($name = 'ExpressionPartialTestCase') {
  69          parent::UnitTestCase($name);
  70      }
  71      
  72  	function setUp() {
  73          $this->DBE =& new MockDataBindingExpression($this);
  74  
  75          $this->expression = &new ExpressionPartialMock($this);
  76          $this->expression->setReturnReference('createValue', $this->DBE);
  77          $this->expression->expectOnce('createValue');
  78      }
  79      
  80  	function tearDown() {
  81          $this->expression->tally();
  82          $this->DBE->tally();
  83          unset($this->expression);
  84          unset($this->DBE);
  85      }
  86  
  87  	function testConstruction() {
  88          $this->expression->Expression('Test', new MockCompilerComponent($this), 'raw');
  89      }
  90  
  91      function testMissingFilter() {
  92          $this->expression->Expression('Test|testingfilter', new MockCompilerComponent($this), 'raw');
  93          $this->assertError();
  94          $this->swallowErrors();
  95      }
  96  
  97      function testInvalidFilter() {
  98          $this->expression->Expression('Test|99', new MockCompilerComponent($this));
  99          $this->assertError();
 100          $this->swallowErrors();
 101      }
 102  
 103  	function testIsConstant() {
 104          $this->DBE->setReturnValue('IsConstant', TRUE);
 105          $this->DBE->expectOnce('IsConstant');
 106          $this->expression->Expression('Test', new MockCompilerComponent($this), 'raw');
 107          $this->assertTrue($this->expression->isConstant());
 108      }
 109  
 110  	function testGetValue() {
 111          $this->DBE->setReturnValue('getValue', 'hello');
 112          $this->DBE->expectOnce('getValue');
 113          $this->expression->Expression('Test', new MockCompilerComponent($this), 'raw');
 114          $this->assertEqual($this->expression->getValue(), 'hello');
 115      }
 116  
 117  	function testGeneratePreStatement() {
 118          $this->DBE->expectOnce('generatePreStatement');
 119          $this->expression->Expression('Test', new MockCompilerComponent($this), 'raw');
 120          $this->expression->generatePreStatement(new MockCodeWriter($this));
 121      }
 122  
 123  	function testGenerateExpression() {
 124          $this->DBE->expectOnce('generateExpression');
 125          $this->expression->Expression('Test', new MockCompilerComponent($this), 'raw');
 126          $this->expression->generateExpression(new MockCodeWriter($this));
 127      }
 128  
 129  	function testGeneratePostStatement() {
 130          $this->DBE->expectOnce('generatePostStatement');
 131          $this->expression->Expression('Test', new MockCompilerComponent($this), 'raw');
 132          $this->expression->generatePostStatement(new MockCodeWriter($this));
 133      }
 134  
 135  	function testPrepare() {
 136          $this->DBE->expectOnce('prepare');
 137          $this->expression->Expression('Test', new MockCompilerComponent($this), 'raw');
 138          $this->expression->prepare(new MockCodeWriter($this));
 139      }
 140  
 141  }
 142  
 143  class ExpressionValueParserTestCase extends UnitTestCase {
 144  	function ExpressionValueParserTestCase($name = 'ExpressionValueParserTestCase') {
 145          parent::UnitTestCase($name);
 146      }
 147  	function testInteger() {
 148          $expression = '23';
 149          $Parser = & new ExpressionValueParser($expression);
 150          $this->assertEqual($Parser->ValueType,EXPRESSION_VALUE_INT);
 151          $this->assertIdentical($Parser->Value,23);
 152      }
 153  	function testFloat() {
 154          $expression = '23.35';
 155          $Parser = & new ExpressionValueParser($expression);
 156          $this->assertEqual($Parser->ValueType,EXPRESSION_VALUE_FLOAT);
 157          $this->assertIdentical($Parser->Value,23.35);
 158      }
 159  	function testStringDoubleQuote() {
 160          $expression = '"Test"';
 161          $Parser = & new ExpressionValueParser($expression);
 162          $this->assertEqual($Parser->ValueType,EXPRESSION_VALUE_STRING);
 163          $this->assertIdentical($Parser->Value,'Test');
 164      }
 165  	function testStringSingleQuote() {
 166          $expression = "'Test'";
 167          $Parser = & new ExpressionValueParser($expression);
 168          $this->assertEqual($Parser->ValueType,EXPRESSION_VALUE_STRING);
 169          $this->assertIdentical($Parser->Value,'Test');
 170      }
 171  	function testDataBinding() {
 172          $expression = 'Variable';
 173          $Parser = & new ExpressionValueParser($expression);
 174          $this->assertEqual($Parser->ValueType,EXPRESSION_VALUE_DATABINDING);
 175          $this->assertIdentical($Parser->Value,'Variable');
 176      }
 177      /**
 178      * In theory ExpressionValueParser should never be asked to parse this
 179      * it already having been broken up by createTree
 180  
 181      function testDataBindingStringString() {
 182          $expression = '"stringA"|"stringB"';
 183          $Parser = & new ExpressionValueParser($expression);
 184          $this->assertEqual($Parser->ValueType,EXPRESSION_VALUE_DATABINDING);
 185          $this->assertIdentical($Parser->Value,'"stringA"|"stringB"');
 186      }
 187      function testDataBindingStringInt() {
 188          $expression = '"string"|23';
 189          $Parser = & new ExpressionValueParser($expression);
 190          $this->assertEqual($Parser->ValueType,EXPRESSION_VALUE_DATABINDING);
 191          $this->assertIdentical($Parser->Value,'"string"|23');
 192      }
 193      */
 194  }
 195  
 196  class ExpressionFilterFindingParserTestCase extends UnitTestCase {
 197  	function ExpressionFilterFindingParserTestCase($name = 'ExpressionFilterFindingParserTestCase') {
 198          parent::UnitTestCase($name);
 199      }
 200  	function testSingleValue() {
 201          $expression = 'value';
 202          $Parser = & new ExpressionFilterFindingParser($expression);
 203          $this->assertEqual($Parser->Filters,array('value'));
 204      }
 205  	function testTwoValues() {
 206          $expression = 'valueA|valueB';
 207          $Parser = & new ExpressionFilterFindingParser($expression);
 208          $this->assertEqual($Parser->Filters,array('valueA','valueB'));
 209      }
 210  	function testDoubleQuoteValueDelimiter() {
 211          $expression = 'valueA|"A|B"';
 212          $Parser = & new ExpressionFilterFindingParser($expression);
 213          $this->assertEqual($Parser->Filters,array('valueA','"A|B"'));
 214      }
 215  	function testSingleQuoteValueDelimiter() {
 216          $expression = 'valueA|\'A|B\'';
 217          $Parser = & new ExpressionFilterFindingParser($expression);
 218          $this->assertEqual($Parser->Filters,array('valueA','\'A|B\''));
 219      }
 220  	function testNoValue() {
 221          $expression = '';
 222          $Parser = & new ExpressionFilterFindingParser($expression);
 223          $this->assertEqual($Parser->Filters,array());
 224      }
 225  	function testNoValueWithDelimiter() {
 226          $expression = '|';
 227          $Parser = & new ExpressionFilterFindingParser($expression);
 228          $this->assertEqual($Parser->Filters,array());
 229      }
 230  	function testNoValueWithTwoDelimiters() {
 231          $expression = '||';
 232          $Parser = & new ExpressionFilterFindingParser($expression);
 233          $this->assertEqual($Parser->Filters,array());
 234      }
 235  	function testValueWithNoValue() {
 236          $expression = 'valueA|valueB|';
 237          $Parser = & new ExpressionFilterFindingParser($expression);
 238          $this->assertEqual($Parser->Filters,array('valueA','valueB'));
 239      }
 240  	function testValueWithNoValueStartingDelimiter() {
 241          $expression = '|valueA|valueB|';
 242          $Parser = & new ExpressionFilterFindingParser($expression);
 243          $this->assertEqual($Parser->Filters,array('valueA','valueB'));
 244      }
 245  	function testTwoDoubleQuotes() {
 246          $expression = 'filterA:"x\'1"|filterB:"y\'2"';
 247          $Parser = & new ExpressionFilterFindingParser($expression);
 248          $this->assertEqual($Parser->Filters,array('filterA:"x\'1"','filterB:"y\'2"'));    
 249      }
 250      
 251  	function testTwoSingleQuotes() {
 252          $expression = 'filterA:\'x"1\'|filterB:\'y"2\'';
 253          $Parser = & new ExpressionFilterFindingParser($expression);
 254          $this->assertEqual($Parser->Filters,array('filterA:\'x"1\'','filterB:\'y"2\''));        
 255      }    
 256  }
 257  
 258  class ExpressionFilterParserTestCase extends UnitTestCase {
 259  
 260  	function ExpressionFilterParserTestCase($name = 'ExpressionFilterParserTestCase') {
 261          parent::UnitTestCase($name);
 262      }
 263  
 264  	function testName() {
 265          $expression = 'filter';
 266          $Parser = & new ExpressionFilterParser($expression);
 267          $this->assertEqual($Parser->Name,'filter');
 268      }
 269  
 270  	function testEmptyName() {
 271          $expression = '';
 272          $Parser = & new ExpressionFilterParser($expression);
 273          $this->assertEqual($Parser->Name,NULL);
 274      }
 275  
 276  	function testInvalidName() {
 277          $expression = '"filter"';
 278          $Parser = & new ExpressionFilterParser($expression);
 279          $this->assertEqual($Parser->Name,NULL);
 280      }
 281  
 282  	function testNoArgs() {
 283          $expression = 'filter';
 284          $Parser = & new ExpressionFilterParser($expression);
 285          $this->assertEqual($Parser->Name,'filter');
 286          $this->assertEqual($Parser->Args,NULL);
 287      }
 288  
 289  	function testNoArgsWithDelimiter() {
 290          $expression = 'filter:';
 291          $Parser = & new ExpressionFilterParser($expression);
 292          $this->assertEqual($Parser->Name,'filter');
 293          $this->assertEqual($Parser->Args,array());
 294      }
 295  
 296  	function testNoArgsWithComma() {
 297          $expression = 'filter,';
 298          $Parser = & new ExpressionFilterParser($expression);
 299          $this->assertEqual($Parser->Name,'filter');
 300          $this->assertEqual($Parser->Args,NULL);
 301      }
 302  
 303  	function testOneArg() {
 304          $expression = 'filter:arg';
 305          $Parser = & new ExpressionFilterParser($expression);
 306          $this->assertEqual($Parser->Name,'filter');
 307          $this->assertEqual($Parser->Args,array('arg'));
 308      }
 309  
 310  	function testTwoArgs() {
 311          $expression = 'filter:argA,argB';
 312          $Parser = & new ExpressionFilterParser($expression);
 313          $this->assertEqual($Parser->Name,'filter');
 314          $this->assertEqual($Parser->Args,array('argA','argB'));
 315      }
 316  
 317  	function testDoubleQuotesArgDelimiter() {
 318          $expression = 'filter:argA,"x:y"';
 319          $Parser = & new ExpressionFilterParser($expression);
 320          $this->assertEqual($Parser->Name,'filter');
 321          $this->assertEqual($Parser->Args,array('argA','"x:y"'));
 322      }
 323  
 324  	function testSingleQuotesArgDelimiter() {
 325          $expression = 'filter:argA,\'x:y\'';
 326          $Parser = & new ExpressionFilterParser($expression);
 327          $this->assertEqual($Parser->Name,'filter');
 328          $this->assertEqual($Parser->Args,array('argA','\'x:y\''));
 329      }
 330  
 331  	function testDoubleQuotesArgSeperator() {
 332          $expression = 'filter:argA,"x,y"';
 333          $Parser = & new ExpressionFilterParser($expression);
 334          $this->assertEqual($Parser->Name,'filter');
 335          $this->assertEqual($Parser->Args,array('argA','"x,y"'));
 336      }
 337  
 338  	function testSingleQuotesArgSeperator() {
 339          $expression = 'filter:argA,\'x,y\'';
 340          $Parser = & new ExpressionFilterParser($expression);
 341          $this->assertEqual($Parser->Name,'filter');
 342          $this->assertEqual($Parser->Args,array('argA','\'x,y\''));
 343      }
 344      
 345  	function testTwoDoubleQuotes() {
 346          $expression = 'filter:"x\'1","y\'2"';
 347          $Parser = & new ExpressionFilterParser($expression);
 348          $this->assertEqual($Parser->Name,'filter');
 349          $this->assertEqual($Parser->Args,array('"x\'1"','"y\'2"'));    
 350      }
 351      
 352  	function testTwoSingleQuotes() {
 353          $expression = 'filter:\'x"1\',\'y"2\'';
 354          $Parser = & new ExpressionFilterParser($expression);
 355          $this->assertEqual($Parser->Name,'filter');
 356          $this->assertEqual($Parser->Args,array('\'x"1\'','\'y"2\''));        
 357      }
 358  
 359  }
 360  ?>