tests/HTMLPurifier/GeneratorTest.php

   1 <?php
   2
   3 class HTMLPurifier_GeneratorTest extends HTMLPurifier_Harness
   4 {
   5
   6     /**
   7      * Entity lookup table to help for a few tests.
   8      */
   9     private $_entity_lookup;
  10
  11     public function __construct()
  12     {
  13         parent::__construct();
  14         $this->_entity_lookup = HTMLPurifier_EntityLookup::instance();
  15     }
  16
  17     public function setUp()
  18     {
  19         parent::setUp();
  20         $this->config->set('Output.Newline', "\n");
  21     }
  22
  23     /**
  24      * Creates a generator based on config and context member variables.
  25      */
  26     protected function createGenerator()
  27     {
  28         return new HTMLPurifier_Generator($this->config, $this->context);
  29     }
  30
  31     protected function assertGenerateFromToken($token, $html)
  32     {
  33         $generator = $this->createGenerator();
  34         $result = $generator->generateFromToken($token);
  35         $this->assertIdentical($result, $html);
  36     }
  37
  38     public function test_generateFromToken_text()
  39     {
  40         $this->assertGenerateFromToken(
  41             new HTMLPurifier_Token_Text('Foobar.<>'),
  42             'Foobar.&lt;&gt;'
  43         );
  44     }
  45
  46     public function test_generateFromToken_startWithAttr()
  47     {
  48         $this->assertGenerateFromToken(
  49             new HTMLPurifier_Token_Start('a',
  50                 array('href' => 'dyn?a=foo&b=bar')
  51             ),
  52             '<a href="dyn?a=foo&amp;b=bar">'
  53         );
  54     }
  55
  56     public function test_generateFromToken_end()
  57     {
  58         $this->assertGenerateFromToken(
  59             new HTMLPurifier_Token_End('b'),
  60             '</b>'
  61         );
  62     }
  63
  64     public function test_generateFromToken_emptyWithAttr()
  65     {
  66         $this->assertGenerateFromToken(
  67             new HTMLPurifier_Token_Empty('br',
  68                 array('style' => 'font-family:"Courier New";')
  69             ),
  70             '<br style="font-family:&quot;Courier New&quot;;" />'
  71         );
  72     }
  73
  74     public function test_generateFromToken_startNoAttr()
  75     {
  76         $this->assertGenerateFromToken(
  77             new HTMLPurifier_Token_Start('asdf'),
  78             '<asdf>'
  79         );
  80     }
  81
  82     public function test_generateFromToken_emptyNoAttr()
  83     {
  84         $this->assertGenerateFromToken(
  85             new HTMLPurifier_Token_Empty('br'),
  86             '<br />'
  87         );
  88     }
  89
  90     public function test_generateFromToken_error()
  91     {
  92         $this->expectError('Cannot generate HTML from non-HTMLPurifier_Token object');
  93         $this->assertGenerateFromToken( null, '' );
  94     }
  95
  96     public function test_generateFromToken_unicode()
  97     {
  98         $theta_char = $this->_entity_lookup->table['theta'];
  99         $this->assertGenerateFromToken(
 100             new HTMLPurifier_Token_Text($theta_char),
 101             $theta_char
 102         );
 103     }
 104
 105     public function test_generateFromToken_backtick()
 106     {
 107         $this->assertGenerateFromToken(
 108             new HTMLPurifier_Token_Start('img', array('alt' => '`foo')),
 109             '<img alt="`foo ">'
 110         );
 111     }
 112
 113     public function test_generateFromToken_backtickDisabled()
 114     {
 115         $this->config->set('Output.FixInnerHTML', false);
 116         $this->assertGenerateFromToken(
 117             new HTMLPurifier_Token_Start('img', array('alt' => '`')),
 118             '<img alt="`">'
 119         );
 120     }
 121
 122     public function test_generateFromToken_backtickNoChange()
 123     {
 124         $this->assertGenerateFromToken(
 125             new HTMLPurifier_Token_Start('img', array('alt' => '`foo` bar')),
 126             '<img alt="`foo` bar">'
 127         );
 128     }
 129
 130     public function assertGenerateAttributes($attr, $expect, $element = false)
 131     {
 132         $generator = $this->createGenerator();
 133         $result = $generator->generateAttributes($attr, $element);
 134         $this->assertIdentical($result, $expect);
 135     }
 136
 137     public function test_generateAttributes_blank()
 138     {
 139         $this->assertGenerateAttributes(array(), '');
 140     }
 141
 142     public function test_generateAttributes_basic()
 143     {
 144         $this->assertGenerateAttributes(
 145             array('href' => 'dyn?a=foo&b=bar'),
 146             'href="dyn?a=foo&amp;b=bar"'
 147         );
 148     }
 149
 150     public function test_generateAttributes_doubleQuote()
 151     {
 152         $this->assertGenerateAttributes(
 153             array('style' => 'font-family:"Courier New";'),
 154             'style="font-family:&quot;Courier New&quot;;"'
 155         );
 156     }
 157
 158     public function test_generateAttributes_singleQuote()
 159     {
 160         $this->assertGenerateAttributes(
 161             array('style' => 'font-family:\'Courier New\';'),
 162             'style="font-family:\'Courier New\';"'
 163         );
 164     }
 165
 166     public function test_generateAttributes_multiple()
 167     {
 168         $this->assertGenerateAttributes(
 169             array('src' => 'picture.jpg', 'alt' => 'Short & interesting'),
 170             'src="picture.jpg" alt="Short &amp; interesting"'
 171         );
 172     }
 173
 174     public function test_generateAttributes_specialChar()
 175     {
 176         $theta_char = $this->_entity_lookup->table['theta'];
 177         $this->assertGenerateAttributes(
 178             array('title' => 'Theta is ' . $theta_char),
 179             'title="Theta is ' . $theta_char . '"'
 180         );
 181     }
 182
 183
 184     public function test_generateAttributes_minimized()
 185     {
 186         $this->config->set('HTML.Doctype', 'HTML 4.01 Transitional');
 187         $this->assertGenerateAttributes(
 188             array('compact' => 'compact'), 'compact', 'menu'
 189         );
 190     }
 191
 192     public function test_generateFromTokens()
 193     {
 194         $this->assertGeneration(
 195             array(
 196                 new HTMLPurifier_Token_Start('b'),
 197                 new HTMLPurifier_Token_Text('Foobar!'),
 198                 new HTMLPurifier_Token_End('b')
 199             ),
 200             '<b>Foobar!</b>'
 201         );
 202
 203     }
 204
 205     protected function assertGeneration($tokens, $expect)
 206     {
 207         $generator = new HTMLPurifier_Generator($this->config, $this->context);
 208         $result = $generator->generateFromTokens($tokens);
 209         $this->assertIdentical($expect, $result);
 210     }
 211
 212     public function test_generateFromTokens_Scripting()
 213     {
 214         $this->assertGeneration(
 215             array(
 216                 new HTMLPurifier_Token_Start('script'),
 217                 new HTMLPurifier_Token_Text('alert(3 < 5);'),
 218                 new HTMLPurifier_Token_End('script')
 219             ),
 220             "<script><!--//--><![CDATA[//><!--\nalert(3 < 5);\n//--><!]]></script>"
 221         );
 222     }
 223
 224     public function test_generateFromTokens_Scripting_missingCloseTag()
 225     {
 226         $this->assertGeneration(
 227             array(
 228                 new HTMLPurifier_Token_Start('script'),
 229                 new HTMLPurifier_Token_Text('alert(3 < 5);'),
 230             ),
 231             "<script>alert(3 &lt; 5);"
 232         );
 233     }
 234
 235     public function test_generateFromTokens_Scripting_doubleBlock()
 236     {
 237         $this->assertGeneration(
 238             array(
 239                 new HTMLPurifier_Token_Start('script'),
 240                 new HTMLPurifier_Token_Text('alert(3 < 5);'),
 241                 new HTMLPurifier_Token_Text('foo();'),
 242                 new HTMLPurifier_Token_End('script')
 243             ),
 244             "<script>alert(3 &lt; 5);foo();</script>"
 245         );
 246     }
 247
 248     public function test_generateFromTokens_Scripting_disableWrapper()
 249     {
 250         $this->config->set('Output.CommentScriptContents', false);
 251         $this->assertGeneration(
 252             array(
 253                 new HTMLPurifier_Token_Start('script'),
 254                 new HTMLPurifier_Token_Text('alert(3 < 5);'),
 255                 new HTMLPurifier_Token_End('script')
 256             ),
 257             "<script>alert(3 &lt; 5);</script>"
 258         );
 259     }
 260
 261     public function test_generateFromTokens_XHTMLoff()
 262     {
 263         $this->config->set('HTML.XHTML', false);
 264
 265         // omit trailing slash
 266         $this->assertGeneration(
 267             array( new HTMLPurifier_Token_Empty('br') ),
 268             '<br>'
 269         );
 270
 271         // there should be a test for attribute minimization, but it is
 272         // impossible for something like that to happen due to our current
 273         // definitions! fix it later
 274
 275         // namespaced attributes must be dropped
 276         $this->assertGeneration(
 277             array( new HTMLPurifier_Token_Start('p', array('xml:lang'=>'fr')) ),
 278             '<p>'
 279         );
 280
 281     }
 282
 283     public function test_generateFromTokens_TidyFormat()
 284     {
 285         // abort test if tidy isn't loaded
 286         if (!extension_loaded('tidy')) return;
 287
 288         // just don't test; Tidy is exploding on me.
 289         return;
 290
 291         $this->config->set('Core.TidyFormat', true);
 292         $this->config->set('Output.Newline', "\n");
 293
 294         // nice wrapping please
 295         $this->assertGeneration(
 296             array(
 297                 new HTMLPurifier_Token_Start('div'),
 298                 new HTMLPurifier_Token_Text('Text'),
 299                 new HTMLPurifier_Token_End('div')
 300             ),
 301             "<div>\n  Text\n</div>\n"
 302         );
 303
 304     }
 305
 306     public function test_generateFromTokens_sortAttr()
 307     {
 308         $this->config->set('Output.SortAttr', true);
 309
 310         $this->assertGeneration(
 311             array( new HTMLPurifier_Token_Start('p', array('b'=>'c', 'a'=>'d')) ),
 312             '<p a="d" b="c">'
 313         );
 314
 315     }
 316
 317 }
 318
 319 // vim: et sw=4 sts=4