# HG changeset patch
# User cmlenz
# Date 1237299922 0
# Node ID 7ad34db775663cddf74f73fdd5f373badcc91652
# Parent  398c1b07f832378d29ad7f2bdb4cc58b1245df53
Cleaned up XPath tests, added tests from #185.

diff --git a/genshi/tests/path.py b/genshi/tests/path.py
--- a/genshi/tests/path.py
+++ b/genshi/tests/path.py
@@ -25,45 +25,10 @@
     def test(self, ignore_context = False):
         return self.strategy.test(ignore_context)
 
+
 class PathTestCase(unittest.TestCase):
 
     strategies = [GenericStrategy, SingleStepStrategy, SimplePathStrategy]
-    def _create_path(self, expression, expected):
-        return path
-
-    def _test_strategies(self, stream, path, render,
-                             namespaces=None, variables=None):
-        for strategy in self.strategies:
-            if not strategy.supports(path):
-                continue
-            s = strategy(path)
-            rendered = FakePath(s).select(stream,namespaces=namespaces,
-                                            variables=variables).render()
-            msg = "Bad render using %s strategy"%str(strategy)
-            msg += "\nExpected:\t'%s'"%render
-            msg += "\nRendered:\t'%s'"%rendered
-            self.assertEqual(render, rendered, msg)
-
-    def _test_expression(self, text, expected, stream=None, render="",
-                            namespaces=None, variables=None):
-        path = Path(text)
-        if expected is not None:
-            self.assertEqual(expected, repr(path))
-
-        if stream is None:
-            return
-
-        rendered = path.select(stream, namespaces=namespaces,
-                                    variables=variables).render()
-        msg = "Bad render using whole path"
-        msg += "\nExpected:\t'%s'"%render
-        msg += "\nRendered:\t'%s'"%rendered
-        self.assertEqual(render, rendered, msg)
-
-        if len(path.paths) == 1:
-            self._test_strategies(stream, path.paths[0], render,
-                                namespaces=namespaces, variables=variables)
-
 
     def test_error_no_absolute_path(self):
         self.assertRaises(PathSyntaxError, Path, '/root')
@@ -74,442 +39,520 @@
 
     def test_1step(self):
         xml = XML('<root><elem/></root>')
-
-        self._test_expression(  'elem',
-                                '<Path "child::elem">',
-                                xml,
-                                '<elem/>')
-
-        self._test_expression(  'elem',
-                                '<Path "child::elem">',
-                                xml,
-                                '<elem/>')
-
-        self._test_expression(  'child::elem',
-                                '<Path "child::elem">',
-                                xml,
-                                '<elem/>')
-
-        self._test_expression(  '//elem',
-                                '<Path "descendant-or-self::elem">',
-                                xml,
-                                '<elem/>')
-
-        self._test_expression(  'descendant::elem',
-                                '<Path "descendant::elem">',
-                                xml,
-                                '<elem/>')
+        self._test_eval(
+            path = 'elem',
+            equiv = '<Path "child::elem">',
+            input = xml,
+            output = '<elem/>'
+        )
+        self._test_eval(
+            path = 'elem',
+            equiv = '<Path "child::elem">',
+            input = xml,
+            output = '<elem/>'
+        )
+        self._test_eval(
+            path = 'child::elem',
+            equiv = '<Path "child::elem">',
+            input = xml,
+            output = '<elem/>'
+        )
+        self._test_eval(
+            path = '//elem',
+            equiv = '<Path "descendant-or-self::elem">',
+            input = xml,
+            output = '<elem/>'
+        )
+        self._test_eval(
+            path = 'descendant::elem',
+            equiv = '<Path "descendant::elem">',
+            input = xml,
+            output = '<elem/>'
+        )
 
     def test_1step_self(self):
         xml = XML('<root><elem/></root>')
-
-        self._test_expression(  '.',
-                                '<Path "self::node()">',
-                                xml,
-                                '<root><elem/></root>')
-
-        self._test_expression(  'self::node()',
-                                '<Path "self::node()">',
-                                xml,
-                                '<root><elem/></root>')
+        self._test_eval(
+            path = '.',
+            equiv = '<Path "self::node()">',
+            input = xml,
+            output = '<root><elem/></root>'
+        )
+        self._test_eval(
+            path = 'self::node()',
+            equiv = '<Path "self::node()">',
+            input = xml,
+            output = '<root><elem/></root>'
+        )
 
     def test_1step_wildcard(self):
         xml = XML('<root><elem/></root>')
-
-        self._test_expression(  '*',
-                                '<Path "child::*">',
-                                xml,
-                                '<elem/>')
-
-        self._test_expression(  'child::*',
-                                '<Path "child::*">',
-                                xml,
-                                '<elem/>')
-
-        self._test_expression(  'child::node()',
-                                '<Path "child::node()">',
-                                xml,
-                                '<elem/>')
-
-        self._test_expression(  '//*',
-                                '<Path "descendant-or-self::*">',
-                                xml,
-                                '<root><elem/></root>')
+        self._test_eval(
+            path = '*',
+            equiv = '<Path "child::*">',
+            input = xml,
+            output = '<elem/>'
+        )
+        self._test_eval(
+            path = 'child::*',
+            equiv = '<Path "child::*">',
+            input = xml,
+            output = '<elem/>'
+        )
+        self._test_eval(
+            path = 'child::node()',
+            equiv = '<Path "child::node()">',
+            input = xml,
+            output = '<elem/>'
+        )
+        self._test_eval(
+            path = '//*',
+            equiv = '<Path "descendant-or-self::*">',
+            input = xml,
+            output = '<root><elem/></root>'
+        )
 
     def test_1step_attribute(self):
-        self._test_expression(  '@foo',
-                                '<Path "attribute::foo">',
-                                XML('<root/>'),
-                                '')
-
+        self._test_eval(
+            path = '@foo',
+            equiv = '<Path "attribute::foo">',
+            input = XML('<root/>'),
+            output = ''
+        )
         xml = XML('<root foo="bar"/>')
-
-        self._test_expression(  '@foo',
-                                '<Path "attribute::foo">',
-                                xml,
-                                'bar')
-
-        self._test_expression(  './@foo',
-                                '<Path "self::node()/attribute::foo">',
-                                xml,
-                                'bar')
+        self._test_eval(
+            path = '@foo',
+            equiv = '<Path "attribute::foo">',
+            input = xml,
+            output = 'bar'
+        )
+        self._test_eval(
+            path = './@foo',
+            equiv = '<Path "self::node()/attribute::foo">',
+            input = xml,
+            output = 'bar'
+        )
 
     def test_1step_text(self):
         xml = XML('<root>Hey</root>')
-
-        self._test_expression(  'text()',
-                                '<Path "child::text()">',
-                                xml,
-                                'Hey')
-
-        self._test_expression(  './text()',
-                                '<Path "self::node()/child::text()">',
-                                xml,
-                                'Hey')
-
-        self._test_expression(  '//text()',
-                                '<Path "descendant-or-self::text()">',
-                                xml,
-                                'Hey')
-
-        self._test_expression(  './/text()',
-            '<Path "self::node()/descendant-or-self::node()/child::text()">',
-                                xml,
-                                'Hey')
+        self._test_eval(
+            path = 'text()',
+            equiv = '<Path "child::text()">',
+            input = xml,
+            output = 'Hey'
+        )
+        self._test_eval(
+            path = './text()',
+            equiv = '<Path "self::node()/child::text()">',
+            input = xml,
+            output = 'Hey'
+        )
+        self._test_eval(
+            path = '//text()',
+            equiv = '<Path "descendant-or-self::text()">',
+            input = xml,
+            output = 'Hey'
+        )
+        self._test_eval(
+            path = './/text()',
+            equiv = '<Path "self::node()/descendant-or-self::node()/child::text()">',
+            input = xml,
+            output = 'Hey'
+        )
 
     def test_2step(self):
         xml = XML('<root><foo/><bar/></root>')
-        self._test_expression('*', None, xml, '<foo/><bar/>')
-        self._test_expression('bar', None, xml, '<bar/>')
-        self._test_expression('baz', None, xml, '')
+        self._test_eval('*', input=xml, output='<foo/><bar/>')
+        self._test_eval('bar', input=xml, output='<bar/>')
+        self._test_eval('baz', input=xml, output='')
 
     def test_2step_attribute(self):
         xml = XML('<elem class="x"><span id="joe">Hey Joe</span></elem>')
-        self._test_expression('@*', None, xml, 'x')
-        self._test_expression('./@*', None, xml, 'x')
-        self._test_expression('.//@*', None, xml, 'xjoe')
-        self._test_expression('*/@*', None, xml, 'joe')
+        self._test_eval('@*', input=xml, output='x')
+        self._test_eval('./@*', input=xml, output='x')
+        self._test_eval('.//@*', input=xml, output='xjoe')
+        self._test_eval('*/@*', input=xml, output='joe')
 
         xml = XML('<elem><foo id="1"/><foo id="2"/></elem>')
-        self._test_expression('@*', None, xml, '')
-        self._test_expression('foo/@*', None, xml, '12')
+        self._test_eval('@*', input=xml, output='')
+        self._test_eval('foo/@*', input=xml, output='12')
 
     def test_2step_complex(self):
         xml = XML('<root><foo><bar/></foo></root>')
-
-        self._test_expression(  'foo/bar',
-                                '<Path "child::foo/child::bar">',
-                                xml,
-                                '<bar/>')
-
-        self._test_expression(  './bar',
-                                '<Path "self::node()/child::bar">',
-                                xml,
-                                '')
-
-        self._test_expression(  'foo/*',
-                                '<Path "child::foo/child::*">',
-                                xml,
-                                '<bar/>')
-
+        self._test_eval(
+            path = 'foo/bar',
+            equiv = '<Path "child::foo/child::bar">',
+            input = xml,
+            output = '<bar/>'
+        )
+        self._test_eval(
+            path = './bar',
+            equiv = '<Path "self::node()/child::bar">',
+            input = xml,
+            output = ''
+        )
+        self._test_eval(
+            path = 'foo/*',
+            equiv = '<Path "child::foo/child::*">',
+            input = xml,
+            output = '<bar/>'
+        )
         xml = XML('<root><foo><bar id="1"/></foo><bar id="2"/></root>')
-        self._test_expression(  './bar',
-                                '<Path "self::node()/child::bar">',
-                                xml,
-                                '<bar id="2"/>')
+        self._test_eval(
+            path = './bar',
+            equiv = '<Path "self::node()/child::bar">',
+            input = xml,
+            output = '<bar id="2"/>'
+        )
 
     def test_2step_text(self):
         xml = XML('<root><item>Foo</item></root>')
-
-        self._test_expression(  'item/text()',
-                                '<Path "child::item/child::text()">',
-                                xml,
-                                'Foo')
-
-        self._test_expression(  '*/text()',
-                                '<Path "child::*/child::text()">',
-                                xml,
-                                'Foo')
-
-        self._test_expression(  '//text()',
-                                '<Path "descendant-or-self::text()">',
-                                xml,
-                                'Foo')
-
-        self._test_expression(  './text()',
-                                '<Path "self::node()/child::text()">',
-                                xml,
-                                '')
-
+        self._test_eval(
+            path = 'item/text()',
+            equiv = '<Path "child::item/child::text()">',
+            input = xml,
+            output = 'Foo'
+        )
+        self._test_eval(
+            path = '*/text()',
+            equiv = '<Path "child::*/child::text()">',
+            input = xml,
+            output = 'Foo'
+        )
+        self._test_eval(
+            path = '//text()',
+            equiv = '<Path "descendant-or-self::text()">',
+            input = xml,
+            output = 'Foo'
+        )
+        self._test_eval(
+            path = './text()',
+            equiv = '<Path "self::node()/child::text()">',
+            input = xml,
+            output = ''
+        )
         xml = XML('<root><item>Foo</item><item>Bar</item></root>')
-        self._test_expression(  'item/text()',
-                                '<Path "child::item/child::text()">',
-                                xml,
-                                'FooBar')
+        self._test_eval(
+            path = 'item/text()',
+            equiv = '<Path "child::item/child::text()">',
+            input = xml,
+            output = 'FooBar'
+        )
+        xml = XML('<root><item><name>Foo</name><sub><name>Bar</name></sub></item></root>') 
+        self._test_eval(
+            path = 'item/name/text()',
+            equiv = '<Path "child::item/child::name/child::text()">',
+            input = xml,
+            output = 'Foo'
+        )
 
     def test_3step(self):
         xml = XML('<root><foo><bar/></foo></root>')
-        self._test_expression(  'foo/*',
-                                '<Path "child::foo/child::*">',
-                                xml,
-                                '<bar/>')
+        self._test_eval(
+            path = 'foo/*',
+            equiv = '<Path "child::foo/child::*">',
+            input = xml,
+            output = '<bar/>'
+        )
 
     def test_3step_complex(self):
-        xml = XML('<root><foo><bar/></foo></root>')
-        self._test_expression(  '*/bar',
-                                '<Path "child::*/child::bar">',
-                                xml,
-                                '<bar/>')
+        self._test_eval(
+            path = '*/bar',
+            equiv = '<Path "child::*/child::bar">',
+            input = XML('<root><foo><bar/></foo></root>'),
+            output = '<bar/>'
+        )
+        self._test_eval(
+            path = '//bar',
+            equiv = '<Path "descendant-or-self::bar">',
+            input = XML('<root><foo><bar id="1"/></foo><bar id="2"/></root>'),
+            output = '<bar id="1"/><bar id="2"/>'
+        )
 
-        xml = XML('<root><foo><bar id="1"/></foo><bar id="2"/></root>')
-        self._test_expression(  '//bar',
-                                '<Path "descendant-or-self::bar">',
-                                xml,
-                                '<bar id="1"/><bar id="2"/>')
+    def test_3step_complex_text(self):
+        xml = XML('<root><item><bar>Some text </bar><baz><bar>in here.</bar></baz></item></root>')
+        self._test_eval(
+            path = 'item/bar/text()',
+            equiv = '<Path "child::item/child::bar/child::text()">',
+            input = xml,
+            output = 'Some text '
+        )
+        self._test_eval(
+            path = 'item//bar/text()',
+            equiv = '<Path "child::item/descendant-or-self::node()/child::bar/child::text()">',
+            input = xml,
+            output = 'Some text in here.'
+        )
 
     def test_node_type_comment(self):
         xml = XML('<root><!-- commented --></root>')
-        self._test_expression(  'comment()',
-                                '<Path "child::comment()">',
-                                xml,
-                                '<!-- commented -->')
+        self._test_eval(
+            path = 'comment()',
+            equiv = '<Path "child::comment()">',
+            input = xml,
+            output = '<!-- commented -->'
+        )
 
     def test_node_type_text(self):
         xml = XML('<root>Some text <br/>in here.</root>')
-        self._test_expression(  'text()',
-                                '<Path "child::text()">',
-                                xml,
-                                'Some text in here.')
+        self._test_eval(
+            path = 'text()',
+            equiv = '<Path "child::text()">',
+            input = xml,
+            output = 'Some text in here.'
+        )
 
     def test_node_type_node(self):
         xml = XML('<root>Some text <br/>in here.</root>')
-        self._test_expression(  'node()',
-                                '<Path "child::node()">',
-                                xml,
-                                'Some text <br/>in here.',)
+        self._test_eval(
+            path = 'node()',
+            equiv = '<Path "child::node()">',
+            input = xml,
+            output = 'Some text <br/>in here.'
+        )
 
     def test_node_type_processing_instruction(self):
         xml = XML('<?python x = 2 * 3 ?><root><?php echo("x") ?></root>')
-
-        self._test_expression(  '//processing-instruction()',
-                        '<Path "descendant-or-self::processing-instruction()">',
-                                xml,
-                                '<?python x = 2 * 3 ?><?php echo("x") ?>')
-
-        self._test_expression(  'processing-instruction()',
-                                '<Path "child::processing-instruction()">',
-                                xml,
-                                '<?php echo("x") ?>')
-
-        self._test_expression(  'processing-instruction("php")',
-                        '<Path "child::processing-instruction(\"php\")">',
-                                xml,
-                                '<?php echo("x") ?>')
+        self._test_eval(
+            path = '//processing-instruction()',
+            equiv = '<Path "descendant-or-self::processing-instruction()">',
+            input = xml,
+            output = '<?python x = 2 * 3 ?><?php echo("x") ?>'
+        )
+        self._test_eval(
+            path = 'processing-instruction()',
+            equiv = '<Path "child::processing-instruction()">',
+            input = xml,
+            output = '<?php echo("x") ?>'
+        )
+        self._test_eval(
+            path = 'processing-instruction("php")',
+            equiv = '<Path "child::processing-instruction(\"php\")">',
+            input = xml,
+            output = '<?php echo("x") ?>'
+        )
 
     def test_simple_union(self):
         xml = XML("""<body>1<br />2<br />3<br /></body>""")
-        self._test_expression(  '*|text()',
-                                '<Path "child::*|child::text()">',
-                                xml,
-                                '1<br/>2<br/>3<br/>')
+        self._test_eval(
+            path = '*|text()',
+            equiv = '<Path "child::*|child::text()">',
+            input = xml,
+            output = '1<br/>2<br/>3<br/>'
+        )
 
     def test_predicate_name(self):
         xml = XML('<root><foo/><bar/></root>')
-        self._test_expression('*[name()="foo"]', None, xml, '<foo/>')
+        self._test_eval('*[name()="foo"]', input=xml, output='<foo/>')
 
     def test_predicate_localname(self):
         xml = XML('<root><foo xmlns="NS"/><bar/></root>')
-        self._test_expression('*[local-name()="foo"]', None, xml,
-                                '<foo xmlns="NS"/>')
+        self._test_eval('*[local-name()="foo"]', input=xml,
+                              output='<foo xmlns="NS"/>')
 
     def test_predicate_namespace(self):
         xml = XML('<root><foo xmlns="NS"/><bar/></root>')
-        self._test_expression('*[namespace-uri()="NS"]', None, xml,
-                                '<foo xmlns="NS"/>')
+        self._test_eval('*[namespace-uri()="NS"]', input=xml,
+                                output='<foo xmlns="NS"/>')
 
     def test_predicate_not_name(self):
         xml = XML('<root><foo/><bar/></root>')
-        self._test_expression('*[not(name()="foo")]', None, xml, '<bar/>')
+        self._test_eval('*[not(name()="foo")]', input=xml,
+                              output='<bar/>')
 
     def test_predicate_attr(self):
         xml = XML('<root><item/><item important="very"/></root>')
-        self._test_expression('item[@important]', None, xml,
-                                '<item important="very"/>')
-        self._test_expression('item[@important="very"]', None, xml,
-                                '<item important="very"/>')
+        self._test_eval('item[@important]', input=xml,
+                              output='<item important="very"/>')
+        self._test_eval('item[@important="very"]', input=xml,
+                              output='<item important="very"/>')
 
     def test_predicate_attr_equality(self):
         xml = XML('<root><item/><item important="notso"/></root>')
-        self._test_expression('item[@important="very"]', None, xml, '')
-        self._test_expression('item[@important!="very"]', None, xml,
-                                '<item/><item important="notso"/>')
+        self._test_eval('item[@important="very"]', input=xml, output='')
+        self._test_eval('item[@important!="very"]', input=xml,
+                              output='<item/><item important="notso"/>')
 
     def test_predicate_attr_greater_than(self):
         xml = XML('<root><item priority="3"/></root>')
-        self._test_expression('item[@priority>3]', None, xml, '')
-        self._test_expression('item[@priority>2]', None, xml,
-                                '<item priority="3"/>')
+        self._test_eval('item[@priority>3]', input=xml, output='')
+        self._test_eval('item[@priority>2]', input=xml,
+                              output='<item priority="3"/>')
 
     def test_predicate_attr_less_than(self):
         xml = XML('<root><item priority="3"/></root>')
-        self._test_expression('item[@priority<3]', None, xml, '')
-        self._test_expression('item[@priority<4]', None, xml,
-                                '<item priority="3"/>')
+        self._test_eval('item[@priority<3]', input=xml, output='')
+        self._test_eval('item[@priority<4]', input=xml,
+                              output='<item priority="3"/>')
 
     def test_predicate_attr_and(self):
         xml = XML('<root><item/><item important="very"/></root>')
-        self._test_expression('item[@important and @important="very"]',
-                                None, xml, '<item important="very"/>')
-        self._test_expression('item[@important and @important="notso"]',
-                                None, xml, '')
+        self._test_eval('item[@important and @important="very"]',
+                                input=xml, output='<item important="very"/>')
+        self._test_eval('item[@important and @important="notso"]',
+                                input=xml, output='')
 
     def test_predicate_attr_or(self):
         xml = XML('<root><item/><item important="very"/></root>')
-        self._test_expression('item[@urgent or @important]', None, xml,
-                                '<item important="very"/>')
-        self._test_expression('item[@urgent or @notso]', None, xml, '')
+        self._test_eval('item[@urgent or @important]', input=xml,
+                              output='<item important="very"/>')
+        self._test_eval('item[@urgent or @notso]', input=xml, output='')
 
     def test_predicate_boolean_function(self):
         xml = XML('<root><foo>bar</foo></root>')
-        self._test_expression('*[boolean("")]', None, xml, '')
-        self._test_expression('*[boolean("yo")]', None, xml, '<foo>bar</foo>')
-        self._test_expression('*[boolean(0)]', None, xml, '')
-        self._test_expression('*[boolean(42)]', None, xml, '<foo>bar</foo>')
-        self._test_expression('*[boolean(false())]', None, xml, '')
-        self._test_expression('*[boolean(true())]', None, xml,
-                                '<foo>bar</foo>')
+        self._test_eval('*[boolean("")]', input=xml, output='')
+        self._test_eval('*[boolean("yo")]', input=xml,
+                              output='<foo>bar</foo>')
+        self._test_eval('*[boolean(0)]', input=xml, output='')
+        self._test_eval('*[boolean(42)]', input=xml,
+                              output='<foo>bar</foo>')
+        self._test_eval('*[boolean(false())]', input=xml, output='')
+        self._test_eval('*[boolean(true())]', input=xml,
+                              output='<foo>bar</foo>')
 
     def test_predicate_ceil_function(self):
         xml = XML('<root><foo>bar</foo></root>')
-        self._test_expression('*[ceiling("4.5")=5]', None, xml,
-                                '<foo>bar</foo>')
+        self._test_eval('*[ceiling("4.5")=5]', input=xml,
+                              output='<foo>bar</foo>')
 
     def test_predicate_concat_function(self):
         xml = XML('<root><foo>bar</foo></root>')
-        self._test_expression('*[name()=concat("f", "oo")]', None, xml,
-                                '<foo>bar</foo>')
+        self._test_eval('*[name()=concat("f", "oo")]', input=xml,
+                              output='<foo>bar</foo>')
 
     def test_predicate_contains_function(self):
         xml = XML('<root><foo>bar</foo></root>')
-        self._test_expression('*[contains(name(), "oo")]', None, xml,
-                                '<foo>bar</foo>')
+        self._test_eval('*[contains(name(), "oo")]', input=xml,
+                              output='<foo>bar</foo>')
 
     def test_predicate_matches_function(self):
         xml = XML('<root><foo>bar</foo><bar>foo</bar></root>')
-        self._test_expression('*[matches(name(), "foo|bar")]', None, xml,
-                                '<foo>bar</foo><bar>foo</bar>')
+        self._test_eval('*[matches(name(), "foo|bar")]', input=xml,
+                              output='<foo>bar</foo><bar>foo</bar>')
 
     def test_predicate_false_function(self):
         xml = XML('<root><foo>bar</foo></root>')
-        self._test_expression('*[false()]', None, xml, '')
+        self._test_eval('*[false()]', input=xml, output='')
 
     def test_predicate_floor_function(self):
         xml = XML('<root><foo>bar</foo></root>')
-        self._test_expression('*[floor("4.5")=4]', None, xml,
-                                '<foo>bar</foo>')
+        self._test_eval('*[floor("4.5")=4]', input=xml,
+                              output='<foo>bar</foo>')
 
     def test_predicate_normalize_space_function(self):
         xml = XML('<root><foo>bar</foo></root>')
-        self._test_expression('*[normalize-space(" foo   bar  ")="foo bar"]',
-                                None, xml, '<foo>bar</foo>')
+        self._test_eval('*[normalize-space(" foo   bar  ")="foo bar"]',
+                                input=xml, output='<foo>bar</foo>')
 
     def test_predicate_number_function(self):
         xml = XML('<root><foo>bar</foo></root>')
-        self._test_expression('*[number("3.0")=3]', None, xml,
-                                 '<foo>bar</foo>')
-        self._test_expression('*[number("3.0")=3.0]', None, xml,
-                                '<foo>bar</foo>')
-        self._test_expression('*[number("0.1")=.1]', None, xml,
-                                '<foo>bar</foo>')
+        self._test_eval('*[number("3.0")=3]', input=xml,
+                              output='<foo>bar</foo>')
+        self._test_eval('*[number("3.0")=3.0]', input=xml,
+                              output='<foo>bar</foo>')
+        self._test_eval('*[number("0.1")=.1]', input=xml,
+                              output='<foo>bar</foo>')
 
     def test_predicate_round_function(self):
         xml = XML('<root><foo>bar</foo></root>')
-        self._test_expression('*[round("4.4")=4]', None, xml,
-                                '<foo>bar</foo>')
-        self._test_expression('*[round("4.6")=5]', None, xml,
-                                '<foo>bar</foo>')
+        self._test_eval('*[round("4.4")=4]', input=xml,
+                              output='<foo>bar</foo>')
+        self._test_eval('*[round("4.6")=5]', input=xml,
+                              output='<foo>bar</foo>')
 
     def test_predicate_starts_with_function(self):
         xml = XML('<root><foo>bar</foo></root>')
-        self._test_expression('*[starts-with(name(), "f")]', None, xml,
-                                '<foo>bar</foo>')
-        self._test_expression('*[starts-with(name(), "b")]', None, xml, '')
+        self._test_eval('*[starts-with(name(), "f")]', input=xml,
+                              output='<foo>bar</foo>')
+        self._test_eval('*[starts-with(name(), "b")]', input=xml,
+                              output='')
 
     def test_predicate_string_length_function(self):
         xml = XML('<root><foo>bar</foo></root>')
-        self._test_expression('*[string-length(name())=3]', None, xml,
-                                '<foo>bar</foo>')
+        self._test_eval('*[string-length(name())=3]', input=xml,
+                              output='<foo>bar</foo>')
 
     def test_predicate_substring_function(self):
         xml = XML('<root><foo>bar</foo></root>')
-        self._test_expression('*[substring(name(), 1)="oo"]', None, xml,
-                                '<foo>bar</foo>')
-        self._test_expression('*[substring(name(), 1, 1)="o"]', None, xml,
-                                '<foo>bar</foo>')
+        self._test_eval('*[substring(name(), 1)="oo"]', input=xml,
+                              output='<foo>bar</foo>')
+        self._test_eval('*[substring(name(), 1, 1)="o"]', input=xml,
+                              output='<foo>bar</foo>')
 
     def test_predicate_substring_after_function(self):
         xml = XML('<root><foo>bar</foo></root>')
-        self._test_expression('*[substring-after(name(), "f")="oo"]', None, xml,
-                                '<foo>bar</foo>')
+        self._test_eval('*[substring-after(name(), "f")="oo"]', input=xml,
+                                output='<foo>bar</foo>')
 
     def test_predicate_substring_before_function(self):
         xml = XML('<root><foo>bar</foo></root>')
-        self._test_expression('*[substring-before(name(), "oo")="f"]',
-                                None, xml, '<foo>bar</foo>')
+        self._test_eval('*[substring-before(name(), "oo")="f"]',
+                                input=xml, output='<foo>bar</foo>')
 
     def test_predicate_translate_function(self):
         xml = XML('<root><foo>bar</foo></root>')
-        self._test_expression('*[translate(name(), "fo", "ba")="baa"]',
-                                None, xml, '<foo>bar</foo>')
+        self._test_eval('*[translate(name(), "fo", "ba")="baa"]',
+                                input=xml, output='<foo>bar</foo>')
 
     def test_predicate_true_function(self):
         xml = XML('<root><foo>bar</foo></root>')
-        self._test_expression('*[true()]', None, xml, '<foo>bar</foo>')
+        self._test_eval('*[true()]', input=xml, output='<foo>bar</foo>')
 
     def test_predicate_variable(self):
         xml = XML('<root><foo>bar</foo></root>')
-        variables = {'bar': 'foo'}
-        self._test_expression('*[name()=$bar]', None, xml, '<foo>bar</foo>',
-                                variables = variables)
+        self._test_eval(
+            path = '*[name()=$bar]',
+            input = xml,
+            output = '<foo>bar</foo>',
+            variables = {'bar': 'foo'}
+        )
 
     def test_predicate_position(self):
         xml = XML('<root><foo id="a1"/><foo id="a2"/><foo id="a3"/></root>')
-        self._test_expression('*[2]', None, xml, '<foo id="a2"/>')
+        self._test_eval('*[2]', input=xml, output='<foo id="a2"/>')
 
     def test_predicate_attr_and_position(self):
         xml = XML('<root><foo/><foo id="a1"/><foo id="a2"/></root>')
-        self._test_expression('*[@id][2]', None, xml, '<foo id="a2"/>')
+        self._test_eval('*[@id][2]', input=xml, output='<foo id="a2"/>')
 
     def test_predicate_position_and_attr(self):
         xml = XML('<root><foo/><foo id="a1"/><foo id="a2"/></root>')
-        self._test_expression('*[1][@id]', None, xml, '')
-        self._test_expression('*[2][@id]', None, xml, '<foo id="a1"/>')
+        self._test_eval('*[1][@id]', input=xml, output='')
+        self._test_eval('*[2][@id]', input=xml, output='<foo id="a1"/>')
 
     def test_predicate_advanced_position(self):
         xml = XML('<root><a><b><c><d><e/></d></c></b></a></root>')
-        self._test_expression(   'descendant-or-self::*/'
+        self._test_eval(   'descendant-or-self::*/'
                                 'descendant-or-self::*/'
                                 'descendant-or-self::*[2]/'
-                                'self::*/descendant::*[3]', None, xml,
-                                '<d><e/></d>')
+                                'self::*/descendant::*[3]', input=xml,
+                                output='<d><e/></d>')
 
     def test_predicate_child_position(self):
         xml = XML('\
 <root><a><b>1</b><b>2</b><b>3</b></a><a><b>4</b><b>5</b></a></root>')
-        self._test_expression('//a/b[2]', None, xml, '<b>2</b><b>5</b>')
-        self._test_expression('//a/b[3]', None, xml, '<b>3</b>')
+        self._test_eval('//a/b[2]', input=xml, output='<b>2</b><b>5</b>')
+        self._test_eval('//a/b[3]', input=xml, output='<b>3</b>')
 
     def test_name_with_namespace(self):
         xml = XML('<root xmlns:f="FOO"><f:foo>bar</f:foo></root>')
-        self._test_expression('f:foo', '<Path "child::f:foo">', xml,
-                                '<foo xmlns="FOO">bar</foo>',
-                                namespaces = {'f': 'FOO'})
+        self._test_eval(
+            path = 'f:foo',
+            equiv = '<Path "child::f:foo">',
+            input = xml,
+            output = '<foo xmlns="FOO">bar</foo>',
+            namespaces = {'f': 'FOO'}
+        )
 
     def test_wildcard_with_namespace(self):
         xml = XML('<root xmlns:f="FOO"><f:foo>bar</f:foo></root>')
-        self._test_expression('f:*', '<Path "child::f:*">', xml,
-                                '<foo xmlns="FOO">bar</foo>',
-                                namespaces = {'f': 'FOO'})
+        self._test_eval(
+            path = 'f:*',
+            equiv = '<Path "child::f:*">',
+            input = xml,
+            output = '<foo xmlns="FOO">bar</foo>',
+            namespaces = {'f': 'FOO'}
+        )
 
     def test_predicate_termination(self):
         """
@@ -517,54 +560,58 @@
         cause an infinite loop. See <http://genshi.edgewall.org/ticket/82>.
         """
         xml = XML('<ul flag="1"><li>a</li><li>b</li></ul>')
-        self._test_expression('.[@flag="1"]/*', None, xml,
-                                '<li>a</li><li>b</li>')
+        self._test_eval('.[@flag="1"]/*', input=xml,
+                              output='<li>a</li><li>b</li>')
 
         xml = XML('<ul flag="1"><li>a</li><li>b</li></ul>')
-        self._test_expression('.[@flag="0"]/*', None, xml, '')
+        self._test_eval('.[@flag="0"]/*', input=xml, output='')
 
     def test_attrname_with_namespace(self):
         xml = XML('<root xmlns:f="FOO"><foo f:bar="baz"/></root>')
-        self._test_expression('foo[@f:bar]', None, xml,
-                                '<foo xmlns:ns1="FOO" ns1:bar="baz"/>',
-                                namespaces={'f': 'FOO'})
+        self._test_eval('foo[@f:bar]', input=xml,
+                              output='<foo xmlns:ns1="FOO" ns1:bar="baz"/>',
+                              namespaces={'f': 'FOO'})
 
     def test_attrwildcard_with_namespace(self):
         xml = XML('<root xmlns:f="FOO"><foo f:bar="baz"/></root>')
-        self._test_expression('foo[@f:*]', None, xml,
-                                '<foo xmlns:ns1="FOO" ns1:bar="baz"/>',
-                                namespaces={'f': 'FOO'})
+        self._test_eval('foo[@f:*]', input=xml,
+                              output='<foo xmlns:ns1="FOO" ns1:bar="baz"/>',
+                              namespaces={'f': 'FOO'})
+
     def test_self_and_descendant(self):
         xml = XML('<root><foo/></root>')
-        self._test_expression('self::root', None, xml, '<root><foo/></root>')
-        self._test_expression('self::foo', None, xml, '')
-        self._test_expression('descendant::root', None, xml, '')
-        self._test_expression('descendant::foo', None, xml, '<foo/>')
-        self._test_expression('descendant-or-self::root', None, xml, 
-                                '<root><foo/></root>')
-        self._test_expression('descendant-or-self::foo', None, xml, '<foo/>')
+        self._test_eval('self::root', input=xml, output='<root><foo/></root>')
+        self._test_eval('self::foo', input=xml, output='')
+        self._test_eval('descendant::root', input=xml, output='')
+        self._test_eval('descendant::foo', input=xml, output='<foo/>')
+        self._test_eval('descendant-or-self::root', input=xml, 
+                                output='<root><foo/></root>')
+        self._test_eval('descendant-or-self::foo', input=xml, output='<foo/>')
 
     def test_long_simple_paths(self):
         xml = XML('<root><a><b><a><d><a><b><a><b><a><b><a><c>!'
                     '</c></a></b></a></b></a></b></a></d></a></b></a></root>')
-        self._test_expression('//a/b/a/b/a/c', None, xml, '<c>!</c>')
-        self._test_expression('//a/b/a/c', None, xml, '<c>!</c>')
-        self._test_expression('//a/c', None, xml, '<c>!</c>')
-        self._test_expression('//c', None, xml, '<c>!</c>')
+        self._test_eval('//a/b/a/b/a/c', input=xml, output='<c>!</c>')
+        self._test_eval('//a/b/a/c', input=xml, output='<c>!</c>')
+        self._test_eval('//a/c', input=xml, output='<c>!</c>')
+        self._test_eval('//c', input=xml, output='<c>!</c>')
         # Please note that a//b is NOT the same as a/descendant::b 
         # it is a/descendant-or-self::node()/b, which SimplePathStrategy
         # does NOT support
-        self._test_expression('a/b/descendant::a/c', None, xml, '<c>!</c>')
-        self._test_expression('a/b/descendant::a/d/descendant::a/c',
-                                None, xml, '<c>!</c>')
-        self._test_expression('a/b/descendant::a/d/a/c', None, xml, '')
-        self._test_expression('//d/descendant::b/descendant::b/descendant::b'
-                                '/descendant::c', None, xml, '<c>!</c>')
-        self._test_expression('//d/descendant::b/descendant::b/descendant::b'
-                                '/descendant::b/descendant::c', None, xml, '')
+        self._test_eval('a/b/descendant::a/c', input=xml, output='<c>!</c>')
+        self._test_eval('a/b/descendant::a/d/descendant::a/c',
+                              input=xml, output='<c>!</c>')
+        self._test_eval('a/b/descendant::a/d/a/c', input=xml, output='')
+        self._test_eval('//d/descendant::b/descendant::b/descendant::b'
+                              '/descendant::c', input=xml, output='<c>!</c>')
+        self._test_eval('//d/descendant::b/descendant::b/descendant::b'
+                              '/descendant::b/descendant::c', input=xml,
+                              output='')
+
     def _test_support(self, strategy_class, text):
         path = PathParser(text, None, -1).parse()[0]
         return strategy_class.supports(path)
+
     def test_simple_strategy_support(self):
         self.assert_(self._test_support(SimplePathStrategy, 'a/b'))
         self.assert_(self._test_support(SimplePathStrategy, 'self::a/b'))
@@ -582,11 +629,46 @@
         self.assert_(not self._test_support(SimplePathStrategy, 'foo:bar'))
         self.assert_(not self._test_support(SimplePathStrategy, 'a/@foo:bar'))
 
+    def _test_strategies(self, input, path, output,
+                         namespaces=None, variables=None):
+        for strategy in self.strategies:
+            if not strategy.supports(path):
+                continue
+            s = strategy(path)
+            rendered = FakePath(s).select(input, namespaces=namespaces,
+                                          variables=variables).render()
+            msg = 'Bad render using %s strategy' % str(strategy)
+            msg += '\nExpected:\t%r' % output
+            msg += '\nRendered:\t%r' % rendered
+            self.assertEqual(output, rendered, msg)
+
+    def _test_eval(self, path, equiv=None, input=None, output='',
+                         namespaces=None, variables=None):
+        path = Path(path)
+        if equiv is not None:
+            self.assertEqual(equiv, repr(path))
+
+        if input is None:
+            return
+
+        rendered = path.select(input, namespaces=namespaces,
+                               variables=variables).render()
+        msg = 'Bad output using whole path'
+        msg += '\nExpected:\t%r' % output
+        msg += '\nRendered:\t%r' % rendered
+        self.assertEqual(output, rendered, msg)
+
+        if len(path.paths) == 1:
+            self._test_strategies(input, path.paths[0], output,
+                                  namespaces=namespaces, variables=variables)
+
+
 def suite():
     suite = unittest.TestSuite()
     suite.addTest(doctest.DocTestSuite(Path.__module__))
     suite.addTest(unittest.makeSuite(PathTestCase, 'test'))
     return suite
 
+
 if __name__ == '__main__':
     unittest.main(defaultTest='suite')