[Summary view] [Print] [Text view]

   1  <?php
   2  /**
   3   * @package WACT_TESTS
   4   * @version $Id: template_badhtml.test.php,v 1.10 2004/11/12 21:25:14 jeffmoore Exp $
   5   */
   6  
   7  require_once WACT_ROOT . 'template/template.inc.php';
   8  
   9  /**
  10  * These tests are all malformed HTML.  They test the ability of the parser to
  11  * handle garbage input.
  12  * @package WACT_TESTS
  13  */
  14  class BadHtmlTestCase extends UnitTestCase {
  15      function BadHtmlTestCase($name = 'BadHtmlTestCase') {
  16          $this->UnitTestCase($name);
  17      }
  18  
  19      function testWactEndTagRequired() {
  20          $Template = '<core:BLOCK Variable="Value">'; // ENDTAG_REQUIRED
  21  
  22          RegisterTestingTemplate('/badhtml/endtagrequired.html', $Template);        
  23          $Page =& new Template('/badhtml/endtagrequired.html');
  24          $output = $Page->capture();
  25  
  26          $this->assertError();
  27          $this->swallowErrors();
  28      }
  29  
  30      function testWactSelfCloseRequired() {
  31          $Template = '<core:BLOCK Variable="Value" />'; // ENDTAG_REQUIRED
  32  
  33          RegisterTestingTemplate('/badhtml/wactselfcloserequired.html', $Template);        
  34          $Page =& new Template('/badhtml/wactselfcloserequired.html');
  35          $output = $Page->capture();
  36  
  37          $this->assertEqual($output, '');
  38      }
  39  
  40      function testExtraClose() {
  41          // We use input becase input is ENTAG_FORBIDDEN
  42          $Template = '<form runat="server"><input type="text"></input></form>';
  43  
  44          RegisterTestingTemplate('/tags/form/controls/input/extraclose.html', $Template);        
  45          $Page =& new Template('/tags/form/controls/input/extraclose.html');
  46          $output = $Page->capture();
  47  
  48          $this->assertError();
  49          $this->swallowErrors();
  50      }
  51  
  52      function testWactLonelyClose() {
  53          $Template = '</core:block>';
  54  
  55          RegisterTestingTemplate('/badhtml/wactlonelyclose.html', $Template);        
  56          $Page =& new Template('/badhtml/wactlonelyclose.html');
  57          $output = $Page->capture();
  58          $this->assertEqual($output, '</core:block>');
  59      }
  60  
  61      function testWactLonelyCloseForbidden() {
  62          $Template = '</input>'; // ENDTAG_FORBIDDEN
  63  
  64          RegisterTestingTemplate('/badhtml/wactlonelycloseforbid.html', $Template);        
  65          $Page =& new Template('/badhtml/wactlonelycloseforbid.html');
  66          $output = $Page->capture();
  67  
  68          $this->assertError();
  69          $this->swallowErrors();
  70      }
  71  
  72      function testLonelyClose() {
  73          $Template = '</tag>';
  74  
  75          RegisterTestingTemplate('/badhtml/lonelyclose.html', $Template);        
  76          $Page =& new Template('/badhtml/lonelyclose.html');
  77          $output = $Page->capture();
  78  
  79          $this->assertEqual($output, '</tag>');
  80      }
  81  
  82      function testWactSelfCloseExtraClose() {
  83          $Template = '<core:SET Variable="Value" /></core:SET>';
  84  
  85          RegisterTestingTemplate('/badhtml/wactselfcloseextraclose.html', $Template);
  86          $Page =& new Template('/badhtml/wactselfcloseextraclose.html');
  87          $output = $Page->capture();
  88  
  89          $this->assertError();
  90          $this->swallowErrors();
  91      }
  92  
  93      function testAttributeEntity_lt() {
  94  
  95          $Template = '<tag attribute="<">contents</tag>';
  96  
  97          RegisterTestingTemplate('/badhtml/attributeentity_lt.html', $Template);        
  98          $Page =& new Template('/badhtml/attributeentity_lt.html');
  99          $output = $Page->capture();
 100          $this->assertEqual($output, $Template);
 101      }
 102  
 103      function testAttributeEntity_gt() {
 104  
 105          $Template = '<tag attribute=">">contents</tag>';
 106  
 107          RegisterTestingTemplate('/badhtml/attributeentity_gt.html', $Template);        
 108          $Page =& new Template('/badhtml/attributeentity_gt.html');
 109          $output = $Page->capture();
 110          $this->assertEqual($output, $Template);
 111      }
 112  
 113      function testAttributeEntity_quot() {
 114  
 115          $Template = '<tag attribute="\'test\'">contents</tag>';
 116  
 117          RegisterTestingTemplate('/badhtml/attributeentity_quot.html', $Template);        
 118          $Page =& new Template('/badhtml/attributeentity_quot.html');
 119          $output = $Page->capture();
 120          $this->assertEqual($output, $Template);
 121      }
 122  
 123      function testAttributeEntity_amp() {
 124  
 125          $Template = '<tag attribute="&">contents</tag>';
 126  
 127          RegisterTestingTemplate('/badhtml/attributeentity_amp.html', $Template);        
 128          $Page =& new Template('/badhtml/attributeentity_amp.html');
 129          $output = $Page->capture();
 130          $this->assertEqual($output, $Template);
 131      }
 132  
 133      function XtestContentEntity_lt() {
 134  
 135          $Template = '<body><</body>';
 136  
 137          RegisterTestingTemplate('/badhtml/contententity_lt.html', $Template);        
 138          $Page =& new Template('/badhtml/contententity_lt.html');
 139          $output = $Page->capture();
 140          $this->assertEqual($output, $Template);        
 141      }
 142  
 143      function testContentEntity_gt() {
 144  
 145          $Template = '<body>></body>';
 146  
 147          RegisterTestingTemplate('/badhtml/contententity_gt.html', $Template);        
 148          $Page =& new Template('/badhtml/contententity_gt.html');
 149          $output = $Page->capture();
 150          $this->assertEqual($output, $Template);        
 151      }
 152  
 153      function testContentEntity_quot() {
 154  
 155          $Template = '<body>"</body>';
 156  
 157          RegisterTestingTemplate('/badhtml/contententity_quot.html', $Template);        
 158          $Page =& new Template('/badhtml/contententity_quot.html');
 159          $output = $Page->capture();
 160          $this->assertEqual($output, $Template);        
 161      }
 162  
 163      function testContentEntity_amp() {
 164  
 165          $Template = '<body>&</body>';
 166  
 167          RegisterTestingTemplate('/badhtml/contententity_amp.html', $Template);        
 168          $Page =& new Template('/badhtml/contententity_amp.html');
 169          $output = $Page->capture();
 170          $this->assertEqual($output, $Template);        
 171      }
 172  
 173      function XtestEmptyClose() {
 174  
 175          $Template = '<body></></body>';
 176  
 177          RegisterTestingTemplate('/badhtml/emptyclose.html', $Template);        
 178          $Page =& new Template('/badhtml/emptyclose.html');
 179          $output = $Page->capture();
 180          $this->assertEqual($output, $Template);        
 181      }
 182  
 183      function XtestEmptyOpen() {
 184  
 185          $Template = '<body><></body>';
 186  
 187          RegisterTestingTemplate('/badhtml/emptyopen.html', $Template);        
 188          $Page =& new Template('/badhtml/emptyopen.html');
 189          $output = $Page->capture();
 190          $this->assertEqual($output, $Template);        
 191      }
 192  
 193      function testDoubleClose() {
 194  
 195          $Template = '<html><body></body/><html>';
 196  
 197          RegisterTestingTemplate('/badhtml/doubleclose.html', $Template);        
 198          $Page =& new Template('/badhtml/doubleclose.html');
 199          $output = $Page->capture();
 200          $this->assertEqual($output, '<html><body></body/><html>');
 201      }
 202  
 203      function testCloseAttribute() {
 204  
 205          $Template = '<body></body attribute="test">';
 206  
 207          RegisterTestingTemplate('/badhtml/closeattribute.html', $Template);        
 208          $Page =& new Template('/badhtml/closeattribute.html');
 209          $output = $Page->capture();
 210          $this->assertEqual($output, $Template);        
 211      }
 212  
 213      function XtestTruncatedTag1() {
 214  
 215          $Template = '<';
 216  
 217          RegisterTestingTemplate('/badhtml/trunc_tag1.html', $Template);        
 218          $Page =& new Template('/badhtml/trunc_tag1.html');
 219          $output = $Page->capture();
 220          $this->assertEqual($output, $Template);        
 221      }
 222  
 223      function testTruncatedTag2() {
 224  
 225          $Template = '<bo';
 226  
 227          RegisterTestingTemplate('/badhtml/trunc_tag2.html', $Template);        
 228          $Page =& new Template('/badhtml/trunc_tag2.html');
 229          $output = $Page->capture();
 230          $this->assertEqual($output, "<bo");
 231      }
 232  
 233      function testTruncatedClose1() {
 234  
 235          $Template = '<body color="#999999">hello</';
 236  
 237          RegisterTestingTemplate('/badhtml/trunc_close1.html', $Template);        
 238          $Page =& new Template('/badhtml/trunc_close1.html');
 239          $output = $Page->capture();
 240          $this->assertEqual($output, '<body color="#999999">hello</');
 241      }
 242  
 243      function testTruncatedClose2() {
 244  
 245          $Template = '<body color="#999999">hello</body';
 246  
 247          RegisterTestingTemplate('/badhtml/trunc_close2.html', $Template);        
 248          $Page =& new Template('/badhtml/trunc_close2.html');
 249          $output = $Page->capture();
 250          $this->assertEqual($output, '<body color="#999999">hello</body');        
 251      }
 252  
 253      function testTruncatedClose3() {
 254  
 255          $Template = '<body color="#999999">hello</bo';
 256  
 257          RegisterTestingTemplate('/badhtml/trunc_close3.html', $Template);        
 258          $Page =& new Template('/badhtml/trunc_close3.html');
 259          $output = $Page->capture();
 260          $this->assertEqual($output, '<body color="#999999">hello</bo');        
 261      }
 262  
 263      function testTruncatedValue() {
 264  
 265          $Template = '<body color="#99';
 266  
 267          RegisterTestingTemplate('/badhtml/trunc_value.html', $Template);        
 268          $Page =& new Template('/badhtml/trunc_value.html');
 269          $output = $Page->capture();
 270          $this->assertEqual($output, '<body color="#99');
 271      }
 272  
 273      function testTruncatedContent() {
 274  
 275          $Template = '<body color="#999999">hello';
 276  
 277          RegisterTestingTemplate('/badhtml/trunc_content.html', $Template);        
 278          $Page =& new Template('/badhtml/trunc_content.html');
 279          $output = $Page->capture();
 280          $this->assertEqual($output, $Template);        
 281      }
 282  
 283      function testWactAttributeEntity_lt() {
 284  
 285          $Template = '<body><core:block id="test" attribute="<">contents</core:block></body>';
 286  
 287          RegisterTestingTemplate('/badhtml/wact_attributeentity_lt.html', $Template);        
 288          $Page =& new Template('/badhtml/wact_attributeentity_lt.html');
 289          $output = $Page->capture();
 290          $this->assertEqual($output, '<body>contents</body>');        
 291      }
 292  
 293      function testWactAttributeEntity_gt() {
 294  
 295          $Template = '<body><core:block id="test" attribute=">">contents</core:block></body>';
 296  
 297          RegisterTestingTemplate('/badhtml/wact_attributeentity_gt.html', $Template);        
 298          $Page =& new Template('/badhtml/wact_attributeentity_gt.html');
 299          $output = $Page->capture();
 300          $this->assertEqual($output, '<body>contents</body>');        
 301      }
 302  
 303      function testWactAttributeEntity_quot() {
 304  
 305          $Template = '<body><core:block id="test" attribute="\'test\'">contents</core:block></body>';
 306  
 307          RegisterTestingTemplate('/badhtml/wact_attributeentity_quot.html', $Template);        
 308          $Page =& new Template('/badhtml/wact_attributeentity_quot.html');
 309          $output = $Page->capture();
 310  
 311          $this->assertEqual($output, '<body>contents</body>');        
 312      }
 313  
 314      function testWactAttributeEntity_amp() {
 315  
 316          $Template = '<body><core:block id="test" attribute="&">contents</core:block></body>';
 317  
 318          RegisterTestingTemplate('/badhtml/wact_attributeentity_amp.html', $Template);        
 319          $Page =& new Template('/badhtml/wact_attributeentity_amp.html');
 320          $output = $Page->capture();
 321          $this->assertEqual($output, '<body>contents</body>');        
 322      }
 323  
 324      function XtestWactContentEntity_lt() {
 325  
 326          $Template = '<body><core:block id="test"><</core:block></body>';
 327  
 328          RegisterTestingTemplate('/badhtml/wact_contententity_lt.html', $Template);        
 329          $Page =& new Template('/badhtml/wact_contententity_lt.html');
 330          $output = $Page->capture();
 331          $this->assertEqual($output, '<body><</body>');        
 332      }
 333  
 334      function testWactContentEntity_gt() {
 335  
 336          $Template = '<body><core:block id="test">></core:block></body>';
 337  
 338          RegisterTestingTemplate('/badhtml/wact_contententity_gt.html', $Template);        
 339          $Page =& new Template('/badhtml/wact_contententity_gt.html');
 340          $output = $Page->capture();
 341          $this->assertEqual($output, '<body>></body>');        
 342      }
 343  
 344      function testWactContentEntity_quot() {
 345  
 346          $Template = '<body><core:block id="test">"</core:block></body>';
 347  
 348          RegisterTestingTemplate('/badhtml/wact_contententity_quot.html', $Template);        
 349          $Page =& new Template('/badhtml/wact_contententity_quot.html');
 350          $output = $Page->capture();
 351          $this->assertEqual($output, '<body>"</body>');
 352          
 353      }
 354  
 355      function testWactContentEntity_amp() {
 356  
 357          $Template = '<body><core:block id="test">&</core:block></body>';
 358  
 359          RegisterTestingTemplate('/badhtml/wact_contententity_amp.html', $Template);        
 360          $Page =& new Template('/badhtml/wact_contententity_amp.html');
 361          $output = $Page->capture();
 362          $this->assertEqual($output, '<body>&</body>');        
 363      }
 364  
 365      function testWactTruncatedClose1() {
 366  
 367          $Template = '<body><core:block id="test">Content</';
 368  
 369          RegisterTestingTemplate('/badhtml/wact_trunc_close1.html', $Template);        
 370          $Page =& new Template('/badhtml/wact_trunc_close1.html');
 371          $output = $Page->capture();
 372  
 373          $this->assertError();
 374          $this->swallowErrors();
 375          // Closing tag not found for tag 'core:block' in template file '/Library/WebServer/Documents/wact/tests/cases/web_tests/badhtml/templates/source/wact_trunc_close1.html' on line 7.
 376      }
 377  
 378      function testWactTruncatedClose2() {
 379  
 380          $Template = '<body><core:block id="test">Content</core:block';
 381  
 382          RegisterTestingTemplate('/badhtml/wact_trunc_close2.html', $Template);        
 383          $Page =& new Template('/badhtml/wact_trunc_close2.html');
 384          $output = $Page->capture();
 385  
 386          $this->assertError();
 387          $this->swallowErrors();
 388          // Closing tag not found for tag 'core:block' in template file '/Library/WebServer/Documents/wact/tests/cases/web_tests/badhtml/templates/source/wact_trunc_close1.html' on line 7.
 389      }
 390  
 391      function testWactTruncatedClose3() {
 392  
 393          $Template = '<body><core:block id="test">Content</core:blo';
 394  
 395          RegisterTestingTemplate('/badhtml/wact_trunc_close3.html', $Template);        
 396          $Page =& new Template('/badhtml/wact_trunc_close3.html');
 397          $output = $Page->capture();
 398  
 399          $this->assertError();
 400          $this->swallowErrors();
 401          // Closing tag not found for tag 'core:block' in template file '/Library/WebServer/Documents/wact/tests/cases/web_tests/badhtml/templates/source/wact_trunc_close2.html' on line 7.
 402      }
 403  
 404      function testWactTruncatedValue() {
 405  
 406          $Template = '<body><core:block id="test';
 407  
 408          RegisterTestingTemplate('/badhtml/wact_trunc_value.html', $Template);        
 409          $Page =& new Template('/badhtml/wact_trunc_value.html');
 410          $output = $Page->capture();
 411          $this->assertEqual($output, '<body><core:block id="test');
 412      }
 413  
 414      function testWactTruncatedContent() {
 415  
 416          $Template = '<body><core:block id="test">content';
 417  
 418          RegisterTestingTemplate('/badhtml/wact_trunc_content.html', $Template);        
 419          $Page =& new Template('/badhtml/wact_trunc_content.html');
 420          $output = $Page->capture();
 421  
 422          $this->assertError();
 423          $this->swallowErrors();
 424          // Closing tag not found for tag 'core:block' in template file '/Library/WebServer/Documents/wact/tests/cases/web_tests/badhtml/templates/source/wact_trunc_content.html' on line 7.
 425      }
 426  
 427      function testTruncatedAttribute() {
 428  
 429          $Template = '<body col';
 430  
 431          RegisterTestingTemplate('/badhtml/trunc_attribute.html', $Template);        
 432          $Page =& new Template('/badhtml/trunc_attribute.html');
 433          $output = $Page->capture();
 434          $this->assertEqual($output, '<body col');        
 435      }
 436  
 437      function testWactTruncatedAttribute() {
 438  
 439          $Template = '<body><core:block id';
 440  
 441          RegisterTestingTemplate('/badhtml/wact_trunc_attribute.html', $Template);        
 442          $Page =& new Template('/badhtml/wact_trunc_attribute.html');
 443          $output = $Page->capture();
 444          $this->assertEqual($output, '<body><core:block id');
 445      }
 446  
 447  }
 448  ?>