[1.2.0]

- Partially finished migrating to new Context object (done in r485).
- Created HTMLPurifier_Harness to assist with testing, ChildDefTest migrated to that framework.

git-svn-id: http://htmlpurifier.org/svnroot/htmlpurifier/trunk@484 48356398-32a2-884e-a903-53898d9a118a

tests/HTMLPurifier/ChildDefTest.php

@@ -1,122 +1,78 @@
 <?php
 
+require_once 'HTMLPurifier/Harness.php';
+
 require_once 'HTMLPurifier/ChildDef.php';
 require_once 'HTMLPurifier/Lexer/DirectLex.php';
 require_once 'HTMLPurifier/Generator.php';
 
-class HTMLPurifier_ChildDefTest extends UnitTestCase
+class HTMLPurifier_ChildDefTest extends HTMLPurifier_Harness
 {
     
-    var $def;
-    var $lex;
-    var $gen;
-    
-    function HTMLPurifier_ChildDefTest() {
-        // it is vital that the tags be treated as literally as possible
-        $this->lex = new HTMLPurifier_Lexer_DirectLex();
-        $this->gen = new HTMLPurifier_Generator();
-        parent::UnitTestCase();
-    }
-    
-    function assertSeries($inputs, $expect, $config, $context = array()) {
-        foreach ($inputs as $i => $input) {
-            
-            if (!isset($context[$i])) {
-                $context[$i] = null;
-            }
-            if (!isset($config[$i])) {
-                $config[$i] = HTMLPurifier_Config::createDefault();
-            }
-            
-            $tokens = $this->lex->tokenizeHTML($input, $config[$i]);
-            $result = $this->def->validateChildren($tokens, $config[$i], $context[$i]);
-            
-            if (is_bool($expect[$i])) {
-                $this->assertIdentical($expect[$i], $result, "Test $i: %s");
-            } else {
-                $result_html = $this->gen->generateFromTokens($result, $config[$i]);
-                $this->assertIdentical($expect[$i], $result_html, "Test $i: %s");
-                paintIf($result_html, $result_html != $expect[$i]);
-            }
-        }
+    function setUp() {
+        $this->obj       = null;
+        $this->func      = 'validateChildren';
+        $this->to_tokens = true;
+        $this->to_html   = true;
     }
     
     function test_custom() {
         
-        $this->def = new HTMLPurifier_ChildDef_Custom(
-            '(a, b?, c*, d+, (a, b)*)');
+        $this->obj = new HTMLPurifier_ChildDef_Custom('(a,b?,c*,d+,(a,b)*)');
         
-        $inputs = array();
-        $expect = array();
-        $config = array();
+        $this->assertResult('', false);
+        $this->assertResult('<a /><a />', false);
         
-        $inputs[0] = '';
-        $expect[0] = false;
+        $this->assertResult('<a /><b /><c /><d /><a /><b />');
+        $this->assertResult('<a /><d>Dob</d><a /><b>foo</b>'.
+          '<a href="moo" /><b>foo</b>');
         
-        $inputs[1] = '<a /><b /><c /><d /><a /><b />';
-        $expect[1] = true;
-        
-        $inputs[2] = '<a /><d>Dob</d><a /><b>foo</b><a href="moo" /><b>foo</b>';
-        $expect[2] = true;
-        
-        $inputs[3] = '<a /><a />';
-        $expect[3] = false;
-        
-        $this->assertSeries($inputs, $expect, $config);
     }
     
     function test_table() {
         
-        // currently inactive, awaiting augmentation
-        
         // the table definition
-        $this->def = new HTMLPurifier_ChildDef_Table();
+        $this->obj = new HTMLPurifier_ChildDef_Table();
         
         $inputs = $expect = $config = array();
         
-        $inputs[0] = '';
-        $expect[0] = false;
+        $this->assertResult('', false);
         
         // we're using empty tags to compact the tests: under real circumstances
         // there would be contents in them
         
-        $inputs[1] = '<tr />';
-        $expect[1] = true;
-        
-        $inputs[2] = '<caption /><col /><thead /><tfoot /><tbody>'.
-            '<tr><td>asdf</td></tr></tbody>';
-        $expect[2] = true;
-        
-        $inputs[3] = '<col /><col /><col /><tr />';
-        $expect[3] = true;
+        $this->assertResult('<tr />');
+        $this->assertResult('<caption /><col /><thead /><tfoot /><tbody>'.
+            '<tr><td>asdf</td></tr></tbody>');
+        $this->assertResult('<col /><col /><col /><tr />');
         
         // mixed up order
-        $inputs[4] = '<col /><colgroup /><tbody /><tfoot /><thead /><tr>1</tr><caption /><tr />';
-        $expect[4] = '<caption /><col /><colgroup /><thead /><tfoot /><tbody /><tr>1</tr><tr />';
+        $this->assertResult(
+          '<col /><colgroup /><tbody /><tfoot /><thead /><tr>1</tr><caption /><tr />',
+          '<caption /><col /><colgroup /><thead /><tfoot /><tbody /><tr>1</tr><tr />');
         
         // duplicates of singles
         // - first caption serves
         // - trailing tfoots/theads get turned into tbodys
-        $inputs[5] = '<caption>1</caption><caption /><tbody /><tbody /><tfoot>1</tfoot><tfoot />';
-        $expect[5] = '<caption>1</caption><tfoot>1</tfoot><tbody /><tbody /><tbody />';
+        $this->assertResult(
+          '<caption>1</caption><caption /><tbody /><tbody /><tfoot>1</tfoot><tfoot />',
+          '<caption>1</caption><tfoot>1</tfoot><tbody /><tbody /><tbody />'
+        );
         
         // errant text dropped (until bubbling is implemented)
-        $inputs[6] = 'foo';
-        $expect[6] = false;
+        $this->assertResult('foo', false);
         
         // whitespace sticks to the previous element, last whitespace is
         // stationary
-        $inputs[7] = "\n   <tr />\n  <tr />\n ";
-        $expect[7] = true;
-        
-        $inputs[8] = "\n\t<tbody />\n\t\t<tfoot />\n\t\t\t";
-        $expect[8] = "\n\t\t<tfoot />\n\t<tbody />\n\t\t\t";
-        
-        $this->assertSeries($inputs, $expect, $config);
+        $this->assertResult("\n   <tr />\n  <tr />\n ");
+        $this->assertResult(
+          "\n\t<tbody />\n\t\t<tfoot />\n\t\t\t",
+          "\n\t\t<tfoot />\n\t<tbody />\n\t\t\t"
+        );
         
     }
     
-    function test_parsing() {
+    function testParsing() {
         
         $def = new HTMLPurifier_ChildDef_Required('foobar | bang |gizmo');
         $this->assertEqual($def->elements,
@@ -132,92 +88,78 @@ class HTMLPurifier_ChildDefTest extends UnitTestCase
             'href' => true
            ,'src'  => true
           ));
+        
     }
     
     function test_required_pcdata_forbidden() {
         
-        $this->def = new HTMLPurifier_ChildDef_Required('dt | dd');
-        $inputs = $expect = $config = array();
+        $this->obj = new HTMLPurifier_ChildDef_Required('dt | dd');
         
-        $inputs[0] = '';
-        $expect[0] = false;
-        
-        $inputs[1] = '<dt>Term</dt>Text in an illegal location'.
-                     '<dd>Definition</dd><b>Illegal tag</b>';
-        
-        $expect[1] = '<dt>Term</dt><dd>Definition</dd>';
-        
-        $inputs[2] = 'How do you do!';
-        $expect[2] = false;
+        $this->assertResult('', false);
+        $this->assertResult(
+          '<dt>Term</dt>Text in an illegal location'.
+             '<dd>Definition</dd><b>Illegal tag</b>',
+          '<dt>Term</dt><dd>Definition</dd>');
+        $this->assertResult('How do you do!', false);
         
         // whitespace shouldn't trigger it
-        $inputs[3] = "\n<dd>Definition</dd>       ";
-        $expect[3] = true;
+        $this->assertResult("\n<dd>Definition</dd>       ");
         
-        $inputs[4] ='<dd>Definition</dd>       <b></b>       ';
-        $expect[4] = '<dd>Definition</dd>              ';
-        
-        $inputs[5] = "\t      ";
-        $expect[5] = false;
-        
-        $this->assertSeries($inputs, $expect, $config);
+        $this->assertResult(
+          '<dd>Definition</dd>       <b></b>       ',
+          '<dd>Definition</dd>              '
+        );
+        $this->assertResult("\t      ", false);
         
     }
     
     function test_required_pcdata_allowed() {
-        $this->def = new HTMLPurifier_ChildDef_Required('#PCDATA | b');
         
-        $inputs = $expect = $config = array();
+        $this->obj = new HTMLPurifier_ChildDef_Required('#PCDATA | b');
         
-        $inputs[0] = '<b>Bold text</b><img />';
-        $expect[0] = '<b>Bold text</b>';
+        $this->assertResult('<b>Bold text</b><img />', '<b>Bold text</b>');
         
         // with child escaping on
-        $inputs[1] = '<b>Bold text</b><img />';
-        $expect[1] = '<b>Bold text</b>&lt;img /&gt;';
-        $config[1] = HTMLPurifier_Config::createDefault();
-        $config[1]->set('Core', 'EscapeInvalidChildren', true);
+        $this->assertResult(
+            '<b>Bold text</b><img />',
+            '<b>Bold text</b>&lt;img /&gt;',
+            array(
+              'Core.EscapeInvalidChildren' => true
+            )
+        );
         
-        $this->assertSeries($inputs, $expect, $config);
     }
     
     function test_optional() {
-        $this->def = new HTMLPurifier_ChildDef_Optional('b | i');
         
-        $inputs = $expect = $config = array();
+        $this->obj = new HTMLPurifier_ChildDef_Optional('b | i');
         
-        $inputs[0] = '<b>Bold text</b><img />';
-        $expect[0] = '<b>Bold text</b>';
+        $this->assertResult('<b>Bold text</b><img />', '<b>Bold text</b>');
+        $this->assertResult('Not allowed text', '');
         
-        $inputs[1] = 'Not allowed text';
-        $expect[1] = '';
-        
-        $this->assertSeries($inputs, $expect, $config);
     }
     
     function test_chameleon() {
         
-        $this->def = new HTMLPurifier_ChildDef_Chameleon(
-            'b | i', // allowed only when in inline context
+        $this->obj = new HTMLPurifier_ChildDef_Chameleon(
+            'b | i',      // allowed only when in inline context
             'b | i | div' // allowed only when in block context
         );
         
-        $inputs = $expect = $config = array();
-        $context = array();
+        $this->assertResult(
+            '<b>Allowed.</b>', true,
+            array(), array('ParentType' => 'inline')
+        );
         
-        $inputs[0] = '<b>Allowed.</b>';
-        $expect[0] = true;
-        $context[0] = 'inline';
+        $this->assertResult(
+            '<div>Not allowed.</div>', '',
+            array(), array('ParentType' => 'inline')
+        );
         
-        $inputs[1] = '<div>Not allowed.</div>';
-        $expect[1] = '';
-        $context[1] = 'inline';
-        
-        $inputs[2] = '<div>Allowed.</div>';
-        $expect[2] = true;
-        $context[2] = 'block';
-        
-        $this->assertSeries($inputs, $expect, $config, $context);
+        $this->assertResult(
+            '<div>Allowed.</div>', true,
+            array(), array('ParentType' => 'block')
+        );
         
     }
     

tests/HTMLPurifier/EncoderTest.php

@@ -31,10 +31,11 @@ class HTMLPurifier_EncoderTest extends UnitTestCase
     
     function test_convertToUTF8() {
         $config = HTMLPurifier_Config::createDefault();
+        $context = new HTMLPurifier_Context();
         
         // UTF-8 means that we don't touch it
         $this->assertIdentical(
-            $this->Encoder->convertToUTF8("\xF6", $config),
+            $this->Encoder->convertToUTF8("\xF6", $config, $context),
             "\xF6" // this is invalid
         );
         $this->assertNoErrors();
@@ -43,14 +44,14 @@ class HTMLPurifier_EncoderTest extends UnitTestCase
         
         // Now it gets converted
         $this->assertIdentical(
-            $this->Encoder->convertToUTF8("\xF6", $config),
+            $this->Encoder->convertToUTF8("\xF6", $config, $context),
             "\xC3\xB6"
         );
         
         $config->set('Test', 'ForceNoIconv', true);
         
         $this->assertIdentical(
-            $this->Encoder->convertToUTF8("\xF6", $config),
+            $this->Encoder->convertToUTF8("\xF6", $config, $context),
             "\xC3\xB6"
         );
         
@@ -58,10 +59,11 @@ class HTMLPurifier_EncoderTest extends UnitTestCase
     
     function test_convertFromUTF8() {
         $config = HTMLPurifier_Config::createDefault();
+        $context = new HTMLPurifier_Context();
         
         // UTF-8 means that we don't touch it
         $this->assertIdentical(
-            $this->Encoder->convertFromUTF8("\xC3\xB6", $config),
+            $this->Encoder->convertFromUTF8("\xC3\xB6", $config, $context),
             "\xC3\xB6"
         );
         
@@ -69,14 +71,14 @@ class HTMLPurifier_EncoderTest extends UnitTestCase
         
         // Now it gets converted
         $this->assertIdentical(
-            $this->Encoder->convertFromUTF8("\xC3\xB6", $config),
+            $this->Encoder->convertFromUTF8("\xC3\xB6", $config, $context),
             "\xF6"
         );
         
         $config->set('Test', 'ForceNoIconv', true);
         
         $this->assertIdentical(
-            $this->Encoder->convertFromUTF8("\xC3\xB6", $config),
+            $this->Encoder->convertFromUTF8("\xC3\xB6", $config, $context),
             "\xF6"
         );
         

tests/HTMLPurifier/Harness.php

@@ -0,0 +1,107 @@
+<?php
+
+/**
+ * General-purpose test-harness that makes testing functions that require
+ * configuration and context objects easier when those two parameters are
+ * meaningless.  See HTMLPurifier_ChildDefTest for a good example of usage.
+ */
+class HTMLPurifier_Harness extends UnitTestCase
+{
+    
+    /**
+     * Instance of the object that will execute the method
+     */
+    var $obj;
+    
+    /**
+     * Name of the function to be executed
+     */
+    var $func;
+    
+    /**
+     * Whether or not the method deals in tokens. If set to true, assertResult()
+     * will transparently convert HTML to and back from tokens.
+     */
+    var $to_tokens = false;
+    
+    /**
+     * Whether or not to convert tokens back into HTML before performing
+     * equality check, has no effect on bools.
+     */
+    var $to_html = false;
+    
+    /**
+     * Instance of an HTMLPurifier_Lexer implementation.
+     */
+    var $lexer;
+    
+    /**
+     * Instance of HTMLPurifier_Generator
+     */
+    var $generator;
+    
+    function HTMLPurifier_Harness() {
+        $this->lexer     = new HTMLPurifier_Lexer_DirectLex();
+        $this->generator = new HTMLPurifier_Generator();
+        parent::UnitTestCase();
+    }
+    
+    /**
+     * Asserts a specific result from a one parameter + config/context function
+     * @param $input Input parameter
+     * @param $expect Expectation
+     * @param $config_array Configuration array in form of
+     *                      Namespace.Directive => Value or an actual config
+     *                      object.
+     * @param $context_array Context array in form of Key => Value or an actual
+     *                       context object.
+     */
+    function assertResult($input, $expect = true,
+        $config_array = array(), $context_array = array()
+    ) {
+        
+        // setup config object
+        $config  = HTMLPurifier_Config::createDefault();
+        foreach ($config_array as $key => $value) {
+            list($namespace, $directive) = explode('.', $key);
+            $config->set($namespace, $directive, $value);
+        }
+        
+        // setup context object
+        $context = new HTMLPurifier_Context();
+        foreach ($context_array as $key => $value) {
+            $context->register($key, $value);
+        }
+        
+        if ($this->to_tokens && is_string($input)) {
+            $input = $this->lexer->tokenizeHTML($input, $config, $context);
+        }
+        
+        // call the function
+        $func = $this->func;
+        $result = $this->obj->$func($input, $config, $context);
+        
+        // test a bool result
+        if (is_bool($result)) {
+            $this->assertIdentical($expect, $result);
+            return;
+        } elseif (is_bool($expect)) {
+            $expect = $input;
+        }
+        
+        if ($this->to_html) {
+            $result = $this->generator->
+              generateFromTokens($result, $config, $context);
+            if (is_array($expect)) {
+                $expect = $this->generator->
+                  generateFromTokens($expect, $config, $context);
+            }
+        }
+        
+        $this->assertEqual($expect, $result);
+        
+    }
+    
+}
+
+?>

tests/HTMLPurifier/Lexer/DirectLexTest.php

@@ -53,9 +53,11 @@ class HTMLPurifier_Lexer_DirectLexTest extends UnitTestCase
         $input[10] = 'name="input" selected';
         $expect[10] = array('name' => 'input', 'selected' => 'selected');
         
+        $config = HTMLPurifier_Config::createDefault();
+        $context = new HTMLPurifier_Context();
         $size = count($input);
         for($i = 0; $i < $size; $i++) {
-            $result = $this->DirectLex->parseAttributeString($input[$i]);
+            $result = $this->DirectLex->parseAttributeString($input[$i], $config, $context);
             $this->assertEqual($expect[$i], $result, 'Test ' . $i . ': %s');
             paintIf($result, $expect[$i] != $result);
         }

tests/HTMLPurifier/LexerTest.php

@@ -279,16 +279,17 @@ class HTMLPurifier_LexerTest extends UnitTestCase
         $expect[18] = array( new HTMLPurifier_Token_Empty('br', array('test' => 'x < 6')) );
         
         $default_config = HTMLPurifier_Config::createDefault();
+        $default_context = new HTMLPurifier_Context();
         foreach($input as $i => $discard) {
             if (!isset($config[$i])) $config[$i] = $default_config;
             
-            $result = $this->DirectLex->tokenizeHTML($input[$i], $config[$i]);
+            $result = $this->DirectLex->tokenizeHTML($input[$i], $config[$i], $default_context);
             $this->assertEqual($expect[$i], $result, 'DirectLexTest '.$i.': %s');
             paintIf($result, $expect[$i] != $result);
             
             if ($this->_has_pear) {
                 // assert unless I say otherwise
-                $sax_result = $this->PEARSax3->tokenizeHTML($input[$i], $config[$i]);
+                $sax_result = $this->PEARSax3->tokenizeHTML($input[$i], $config[$i], $default_context);
                 if (!isset($sax_expect[$i])) {
                     // by default, assert with normal result
                     $this->assertEqual($expect[$i], $sax_result, 'PEARSax3Test '.$i.': %s');
@@ -304,7 +305,7 @@ class HTMLPurifier_LexerTest extends UnitTestCase
             }
             
             if ($this->_has_dom) {
-                $dom_result = $this->DOMLex->tokenizeHTML($input[$i], $config[$i]);
+                $dom_result = $this->DOMLex->tokenizeHTML($input[$i], $config[$i], $default_context);
                 // same structure as SAX
                 if (!isset($dom_expect[$i])) {
                     $this->assertEqual($expect[$i], $dom_result, 'DOMLexTest '.$i.': %s');

tests/HTMLPurifier/Strategy/CompositeTest.php

@@ -28,6 +28,7 @@ class HTMLPurifier_Strategy_CompositeTest extends UnitTestCase
         $mock_1 = new HTMLPurifier_StrategyMock($this);
         $mock_2 = new HTMLPurifier_StrategyMock($this);
         $mock_3 = new HTMLPurifier_StrategyMock($this);
+        $context = new HTMLPurifier_Context();
         
         // setup the object
         
@@ -43,9 +44,9 @@ class HTMLPurifier_Strategy_CompositeTest extends UnitTestCase
         
         $config = new HTMLPurifier_ConfigMock();
         
-        $params_1 = array($input_1, $config);
-        $params_2 = array($input_2, $config);
-        $params_3 = array($input_3, $config);
+        $params_1 = array($input_1, $config, $context);
+        $params_2 = array($input_2, $config, $context);
+        $params_3 = array($input_3, $config, $context);
         
         $mock_1->expectOnce('execute', $params_1);
         $mock_1->setReturnValue('execute', $input_2, $params_1);
@@ -58,7 +59,7 @@ class HTMLPurifier_Strategy_CompositeTest extends UnitTestCase
         
         // perform test
         
-        $output = $composite->execute($input_1, $config);
+        $output = $composite->execute($input_1, $config, $context);
         $this->assertIdentical($input_4, $output);
         
         // tally the calls

tests/HTMLPurifier/StrategyHarness.php

@@ -25,12 +25,13 @@ class HTMLPurifier_StrategyHarness extends UnitTestCase
     }
     
     function assertStrategyWorks($strategy, $inputs, $expect, $config = array()) {
+        $context = new HTMLPurifier_Context();
         foreach ($inputs as $i => $input) {
-            $tokens = $this->lex->tokenizeHTML($input);
             if (!isset($config[$i])) {
                 $config[$i] = HTMLPurifier_Config::createDefault();
             }
-            $result_tokens = $strategy->execute($tokens, $config[$i]);
+            $tokens = $this->lex->tokenizeHTML($input, $config[$i], $context);
+            $result_tokens = $strategy->execute($tokens, $config[$i], $context);
             $result = $this->gen->generateFromTokens($result_tokens, $config[$i]);
             $this->assertEqual($expect[$i], $result, "Test $i: %s");
             paintIf($result, $result != $expect[$i]);