Changeset 1025

Timestamp:

Mar 11, 2009, 6:03:03 PM (15 years ago)

Author:

cmlenz

Message:

Merged soc2008-xpath branch back into trunk.

Location:

trunk

Files:

• examples/bench/xpath.py (copied) (copied from branches/experimental/soc2008-xpath/examples/bench/xpath.py)
• genshi/filters/transform.py (modified) (3 diffs)
• genshi/path.py (modified) (13 diffs)
• genshi/tests/path.py (modified) (3 diffs)

trunk/genshi/filters/transform.py

@@ -711 +711 @@
         test = self.path.test()
         stream = iter(stream)
+        next = stream.next
         for mark, event in stream:
             if mark is None:
                 yield mark, event
                 continue
-            result = test(event, {}, {})
+            result = test(event, namespaces, variables)
             # XXX This is effectively genshi.core._ensure() for transform
             # streams.
@@ -723 +724 @@
                     depth = 1
                     while depth > 0:
-                        mark, subevent = stream.next()
+                        mark, subevent = next()
                         if subevent[0] is START:
                             depth += 1
@@ -732 +733 @@
                         else:
                             yield INSIDE, subevent
-                        test(subevent, {}, {}, updateonly=True)
+                        test(subevent, namespaces, variables, updateonly=True)
                 else:
                     yield OUTSIDE, event

trunk/genshi/path.py

@@ -39 +39 @@
 """
 
+from collections import deque
 try:
     from functools import reduce
@@ -46 +47 @@
 import operator
 import re
+from itertools import chain
 
 from genshi.core import Stream, Attrs, Namespace, QName
@@ -79 +81 @@
 
 
+class GenericStrategy(object):
+
+    @classmethod
+    def supports(cls, path):
+        return True
+
+    def __init__(self, path):
+        self.path = path
+
+    def test(self, ignore_context):
+        p = self.path
+        if ignore_context:
+            if p[0][0] is ATTRIBUTE:
+                steps = [_DOTSLASHSLASH] + p
+            else:
+                steps = [(DESCENDANT_OR_SELF, p[0][1], p[0][2])] + p[1:]
+        elif p[0][0] is CHILD or p[0][0] is ATTRIBUTE \
+                or p[0][0] is DESCENDANT:
+            steps = [_DOTSLASH] + p
+        else:
+            steps = p
+
+        # for node it contains all positions of xpath expression
+        # where its child should start checking for matches
+        # with list of corresponding context counters
+        # there can be many of them, because position that is from
+        # descendant-like axis can be achieved from different nodes
+        # for example <a><a><b/></a></a> should match both //a//b[1]
+        # and //a//b[2]
+        # positions always form increasing sequence (invariant)
+        stack = [[(0, [[]])]]
+
+        def _test(event, namespaces, variables, updateonly=False):
+            kind, data, pos = event[:3]
+            retval = None
+
+            # Manage the stack that tells us "where we are" in the stream
+            if kind is END:
+                if stack:
+                    stack.pop()
+                return None
+            if kind is START_NS or kind is END_NS \
+                    or kind is START_CDATA or kind is END_CDATA:
+                # should we make namespaces work?
+                return None
+
+            pos_queue = deque([(pos, cou, []) for pos, cou in stack[-1]])
+            next_pos = []
+
+            # length of real part of path - we omit attribute axis
+            real_len = len(steps) - ((steps[-1][0] == ATTRIBUTE) or 1 and 0)
+            last_checked = -1
+
+            # places where we have to check for match, are these
+            # provided by parent
+            while pos_queue:
+                x, pcou, mcou = pos_queue.popleft()
+                axis, nodetest, predicates = steps[x]
+
+                # we need to push descendant-like positions from parent
+                # further
+                if (axis is DESCENDANT or axis is DESCENDANT_OR_SELF) and pcou:
+                    if next_pos and next_pos[-1][0] == x:
+                        next_pos[-1][1].extend(pcou)
+                    else:
+                        next_pos.append((x, pcou))
+
+                # nodetest first
+                if not nodetest(kind, data, pos, namespaces, variables):
+                    continue
+
+                # counters packs that were already bad
+                missed = set()
+                counters_len = len(pcou) + len(mcou)
+
+                # number of counters - we have to create one
+                # for every context position based predicate
+                cnum = 0
+
+                # tells if we have match with position x
+                matched = True
+
+                if predicates:
+                    for predicate in predicates:
+                        pretval = predicate(kind, data, pos,
+                                            namespaces,
+                                            variables)
+                        if type(pretval) is float: # FIXME <- need to check
+                                                   # this for other types that
+                                                   # can be coerced to float
+
+                            # each counter pack needs to be checked
+                            for i, cou in enumerate(chain(pcou, mcou)):
+                                # it was bad before
+                                if i in missed:
+                                    continue
+
+                                if len(cou) < cnum + 1:
+                                    cou.append(0)
+                                cou[cnum] += 1 
+
+                                # it is bad now
+                                if cou[cnum] != int(pretval):
+                                    missed.add(i)
+
+                            # none of counters pack was good
+                            if len(missed) == counters_len:
+                                pretval = False
+                            cnum += 1
+
+                        if not pretval:
+                             matched = False
+                             break
+
+                if not matched:
+                    continue
+
+                # counter for next position with current node as context node
+                child_counter = []
+
+                if x + 1 == real_len:
+                    # we reached end of expression, because x + 1
+                    # is equal to the length of expression
+                    matched = True
+                    axis, nodetest, predicates = steps[-1]
+                    if axis is ATTRIBUTE:
+                        matched = nodetest(kind, data, pos, namespaces,
+                                           variables)
+                    if matched:
+                        retval = matched
+                else:
+                    next_axis = steps[x + 1][0]
+
+                    # if next axis allows matching self we have
+                    # to add next position to our queue
+                    if next_axis is DESCENDANT_OR_SELF or next_axis is SELF:
+                        if not pos_queue or pos_queue[0][0] > x + 1:
+                            pos_queue.appendleft((x + 1, [], [child_counter]))
+                        else:
+                            pos_queue[0][2].append(child_counter)
+
+                    # if axis is not self we have to add it to child's list
+                    if next_axis is not SELF:
+                        next_pos.append((x + 1, [child_counter]))
+
+            if kind is START:
+                stack.append(next_pos)
+
+            return retval
+
+        return _test
+
+
+class SimplePathStrategy(object):
+    """Strategy for path with only local names, attributes and text nodes."""
+
+    @classmethod
+    def supports(cls, path):
+        if path[0][0] is ATTRIBUTE:
+            return False
+        allowed_tests = (LocalNameTest, CommentNodeTest, TextNodeTest)
+        for _, nodetest, predicates in path:
+            if predicates:
+                return False
+            if not isinstance(nodetest, allowed_tests):
+                return False
+        return True
+
+    def __init__(self, path):
+        # fragments is list of tuples (fragment, pi, attr, self_beginning)
+        # fragment is list of nodetests for fragment of path with only
+        # child:: axes between
+        # pi is KMP partial match table for this fragment
+        # attr is attribute nodetest if fragment ends with @ and None otherwise
+        # self_beginning is True if axis for first fragment element
+        # was self (first fragment) or descendant-or-self (farther fragment)
+        self.fragments = []
+
+        self_beginning = False
+        fragment = []
+
+        def nodes_equal(node1, node2):
+            """Tests if two node tests are equal"""
+            if node1.__class__ is not node2.__class__:
+                return False
+            if node1.__class__ == LocalNameTest:
+                return node1.name == node2.name
+            return True
+
+        def calculate_pi(f):
+            """KMP prefix calculation for table"""
+            # the indexes in prefix table are shifted by one
+            # in comparision with common implementations
+            # pi[i] = NORMAL_PI[i + 1]
+            if len(f) == 0:
+                return []
+            pi = [0]
+            s = 0
+            for i in xrange(1, len(f)):
+                while s > 0 and not nodes_equal(f[s], f[i]):
+                    s = pi[s-1]
+                if nodes_equal(f[s], f[i]):
+                    s += 1
+                pi.append(s)
+            return pi
+
+        for axis in path:
+            if axis[0] is SELF:
+                if len(fragment) != 0:
+                    # if element is not first in fragment it has to be
+                    # the same as previous one
+                    # for example child::a/self::b is always wrong
+                    if axis[1] != fragment[-1][1]:
+                        self.fragments = None
+                        return
+                else:
+                    self_beginning = True
+                    fragment.append(axis[1])
+            elif axis[0] is CHILD:
+                fragment.append(axis[1])
+            elif axis[0] is ATTRIBUTE:
+                pi = calculate_pi(fragment)
+                self.fragments.append((fragment, pi, axis[1], self_beginning))
+                # attribute has always to be at the end, so we can jump out
+                return
+            else:
+                pi = calculate_pi(fragment)
+                self.fragments.append((fragment, pi, None, self_beginning))
+                fragment = [axis[1]]
+                if axis[0] is DESCENDANT:
+                    self_beginning = False
+                else: # DESCENDANT_OR_SELF
+                    self_beginning = True
+        pi = calculate_pi(fragment)
+        self.fragments.append((fragment, pi, None, self_beginning))
+
+    def test(self, ignore_context):
+        # stack of triples (fid, p, ic)
+        # fid is index of current fragment
+        # p is position in this fragment
+        # ic is if we ignore context in this fragment
+        stack = []
+        stack_push = stack.append
+        stack_pop = stack.pop
+        frags = self.fragments
+        frags_len = len(frags)
+
+        def _test(event, namespaces, variables, updateonly=False):
+            # expression found impossible during init
+            if frags is None:
+                return None
+
+            kind, data, pos = event[:3]
+
+            # skip events we don't care about
+            if kind is END:
+                if stack:
+                    stack_pop()
+                return None
+            if kind is START_NS or kind is END_NS \
+                    or kind is START_CDATA or kind is END_CDATA:
+                return None
+
+            if not stack:
+                # root node, nothing on stack, special case
+                fid = 0
+                # skip empty fragments (there can be actually only one)
+                while not frags[fid][0]:
+                    fid += 1
+                p = 0
+                # empty fragment means descendant node at beginning
+                ic = ignore_context or (fid > 0)
+
+                # expression can match first node, if first axis is self::,
+                # descendant-or-self:: or if ignore_context is True and
+                # axis is not descendant::
+                if not frags[fid][3] and (not ignore_context or fid > 0):
+                    # axis is not self-beggining, we have to skip this node
+                    stack_push((fid, p, ic))
+                    return None
+            else:
+                # take position of parent
+                fid, p, ic = stack[-1]
+
+            if fid is not None and not ic:
+                # fragment not ignoring context - we can't jump back
+                frag, pi, attrib, _ = frags[fid]
+                frag_len = len(frag)
+
+                if p == frag_len:
+                    # that probably means empty first fragment
+                    pass
+                elif frag[p](kind, data, pos, namespaces, variables):
+                    # match, so we can go further
+                    p += 1
+                else:
+                    # not matched, so there will be no match in subtree
+                    fid, p = None, None
+
+                if p == frag_len and fid + 1 != frags_len:
+                    # we made it to end of fragment, we can go to following
+                    fid += 1
+                    p = 0
+                    ic = True
+
+            if fid is None:
+                # there was no match in fragment not ignoring context
+                if kind is START:
+                    stack_push((fid, p, ic))
+                return None
+
+            if ic:
+                # we are in fragment ignoring context
+                while True:
+                    frag, pi, attrib, _ = frags[fid]
+                    frag_len = len(frag)
+
+                    # KMP new "character"
+                    while p > 0 and (p >= frag_len or not \
+                            frag[p](kind, data, pos, namespaces, variables)):
+                        p = pi[p-1]
+                    if frag[p](kind, data, pos, namespaces, variables):
+                        p += 1
+
+                    if p == frag_len:
+                        # end of fragment reached
+                        if fid + 1 == frags_len:
+                            # that was last fragment
+                            break
+                        else:
+                            fid += 1
+                            p = 0
+                            ic = True
+                            if not frags[fid][3]:
+                                # next fragment not self-beginning
+                                break
+                    else:
+                        break
+
+            if kind is START:
+                # we have to put new position on stack, for children
+
+                if not ic and fid + 1 == frags_len and p == frag_len:
+                    # it is end of the only, not context ignoring fragment
+                    # so there will be no matches in subtree
+                    stack_push((None, None, ic))
+                else:
+                    stack_push((fid, p, ic))
+
+            # have we reached the end of the last fragment?
+            if fid + 1 == frags_len and p == frag_len:
+                if attrib: # attribute ended path, return value
+                    return attrib(kind, data, pos, namespaces, variables)
+                return True
+
+            return None
+
+        return _test
+
+
+class SingleStepStrategy(object):
+
+    @classmethod
+    def supports(cls, path):
+        return len(path) == 1
+
+    def __init__(self, path):
+        self.path = path
+
+    def test(self, ignore_context):
+        steps = self.path
+        if steps[0][0] is ATTRIBUTE:
+            steps = [_DOTSLASH] + steps
+        select_attr = steps[-1][0] is ATTRIBUTE and steps[-1][1] or None
+
+        # for every position in expression stores counters' list
+        # it is used for position based predicates
+        counters = []
+        depth = [0]
+
+        def _test(event, namespaces, variables, updateonly=False):
+            kind, data, pos = event[:3]
+
+            # Manage the stack that tells us "where we are" in the stream
+            if kind is END:
+                if not ignore_context:
+                    depth[0] -= 1
+                return None
+            elif kind is START_NS or kind is END_NS \
+                    or kind is START_CDATA or kind is END_CDATA:
+                # should we make namespaces work?
+                return None
+
+            if not ignore_context:
+                outside = (steps[0][0] is SELF and depth[0] != 0) \
+                       or (steps[0][0] is CHILD and depth[0] != 1) \
+                       or (steps[0][0] is DESCENDANT and depth[0] < 1)
+                if kind is START:
+                    depth[0] += 1
+                if outside:
+                    return None
+
+            axis, nodetest, predicates = steps[0]
+            if not nodetest(kind, data, pos, namespaces, variables):
+                return None
+
+            if predicates:
+                cnum = 0
+                for predicate in predicates:
+                    pretval = predicate(kind, data, pos, namespaces, variables)
+                    if type(pretval) is float: # FIXME <- need to check this
+                                               # for other types that can be
+                                               # coerced to float
+                        if len(counters) < cnum + 1:
+                            counters.append(0)
+                        counters[cnum] += 1 
+                        if counters[cnum] != int(pretval):
+                            pretval = False
+                        cnum += 1
+                    if not pretval:
+                         return None
+
+            if select_attr:
+                return select_attr(kind, data, pos, namespaces, variables)
+
+            return True
+
+        return _test
+
+
 class Path(object):
     """Implements basic XPath support on streams.
     
-    Instances of this class represent a "compiled" XPath expression, and provide
-    methods for testing the path against a stream, as well as extracting a
-    substream matching that path.
-    """
+    Instances of this class represent a "compiled" XPath expression, and
+    provide methods for testing the path against a stream, as well as
+    extracting a substream matching that path.
+    """
+
+    STRATEGIES = (SingleStepStrategy, SimplePathStrategy, GenericStrategy)
 
     def __init__(self, text, filename=None, lineno=-1):
@@ -97 +531 @@
         self.source = text
         self.paths = PathParser(text, filename, lineno).parse()
+        self.strategies = []
+        for path in self.paths:
+            for strategy_class in self.STRATEGIES:
+                if strategy_class.supports(path):
+                    self.strategies.append(strategy_class(path))
+                    break
+            else:
+                raise NotImplemented, "This path is not implemented"
 
     def __repr__(self):
@@ -134 +576 @@
             variables = {}
         stream = iter(stream)
-        def _generate():
+        def _generate(stream=stream, ns=namespaces, vs=variables):
+            next = stream.next
             test = self.test()
             for event in stream:
-                result = test(event, namespaces, variables)
+                result = test(event, ns, vs)
                 if result is True:
                     yield event
@@ -143 +586 @@
                         depth = 1
                         while depth > 0:
-                            subevent = stream.next()
+                            subevent = next()
                             if subevent[0] is START:
                                 depth += 1
@@ -149 +592 @@
                                 depth -= 1
                             yield subevent
-                            test(subevent, namespaces, variables,
-                                 updateonly=True)
+                            test(subevent, ns, vs, updateonly=True)
                 elif result:
                     yield result
@@ -174 +616 @@
         >>> xml = XML('<root><elem><child id="1"/></elem><child id="2"/></root>')
         >>> test = Path('child').test()
+        >>> namespaces, variables = {}, {}
         >>> for event in xml:
-        ...     if test(event, {}, {}):
+        ...     if test(event, namespaces, variables):
         ...         print event[0], repr(event[1])
         START (QName(u'child'), Attrs([(QName(u'id'), u'2')]))
@@ -186 +629 @@
         :rtype: ``function``
         """
-        paths = [(p, len(p), [0], [], [0] * len(p)) for p in [
-            (ignore_context and [_DOTSLASHSLASH] or []) + p for p in self.paths
-        ]]
-
-        def _test(event, namespaces, variables, updateonly=False):
-            kind, data, pos = event[:3]
+        tests = [s.test(ignore_context) for s in self.strategies]
+        if len(tests) == 1:
+            return tests[0]
+
+        def _multi(event, namespaces, variables, updateonly=False):
             retval = None
-            for steps, size, cursors, cutoff, counter in paths:
-                # Manage the stack that tells us "where we are" in the stream
-                if kind is END:
-                    if cursors:
-                        cursors.pop()
-                    continue
-                elif kind is START:
-                    cursors.append(cursors and cursors[-1] or 0)
-                elif kind is START_NS or kind is END_NS \
-                        or kind is START_CDATA or kind is END_CDATA:
-                    continue
-
-                if updateonly or retval or not cursors:
-                    continue
-                cursor = cursors[-1]
-                depth = len(cursors)
-
-                if cutoff and depth + int(kind is not START) > cutoff[0]:
-                    continue
-
-                ctxtnode = not ignore_context and kind is START \
-                                              and depth == 2
-                matched = None
-                while 1:
-                    # Fetch the next location step
-                    axis, nodetest, predicates = steps[cursor]
-
-                    # If this is the start event for the context node, and the
-                    # axis of the location step doesn't include the current
-                    # element, skip the test
-                    if ctxtnode and (axis is CHILD or axis is DESCENDANT):
-                        break
-
-                    # Is this the last step of the location path?
-                    last_step = cursor + 1 == size
-
-                    # Perform the actual node test
-                    matched = nodetest(kind, data, pos, namespaces, variables)
-
-                    # The node test matched
-                    if matched:
-
-                        # Check all the predicates for this step
-                        if predicates:
-                            for predicate in predicates:
-                                pretval = predicate(kind, data, pos, namespaces,
-                                                    variables)
-                                if type(pretval) is float: # FIXME <- need to
-                                                           # check this for
-                                                           # other types that
-                                                           # can be coerced to
-                                                           # float
-                                    counter[cursor] += 1
-                                    if counter[cursor] != int(pretval):
-                                        pretval = False
-                                if not pretval:
-                                    matched = None
-                                    break
-
-                        # Both the node test and the predicates matched
-                        if matched:
-                            if last_step:
-                                if not ctxtnode or kind is not START \
-                                        or axis is ATTRIBUTE or axis is SELF:
-                                    retval = matched
-                            elif not ctxtnode or axis is SELF \
-                                              or axis is DESCENDANT_OR_SELF:
-                                cursor += 1
-                                cursors[-1] = cursor
-                            cutoff[:] = []
-
-                    if kind is START:
-                        if last_step and not (axis is DESCENDANT or
-                                              axis is DESCENDANT_OR_SELF):
-                            cutoff[:] = [depth]
-
-                        elif steps[cursor][0] is ATTRIBUTE:
-                            # If the axis of the next location step is the
-                            # attribute axis, we need to move on to processing
-                            # that step without waiting for the next markup
-                            # event
-                            continue
-
-                    # We're done with this step if it's the last step or the
-                    # axis isn't "self"
-                    if not matched or last_step or not (
-                            axis is SELF or axis is DESCENDANT_OR_SELF):
-                        break
-                    if ctxtnode and axis is DESCENDANT_OR_SELF:
-                        ctxtnode = False
-
-                if (retval or not matched) and kind is START and \
-                        not (axis is DESCENDANT or axis is DESCENDANT_OR_SELF):
-                    # If this step is not a closure, it cannot be matched until
-                    # the current element is closed... so we need to move the
-                    # cursor back to the previous closure and retest that
-                    # against the current element
-                    backsteps = [(i, k, d, p) for i, (k, d, p)
-                                 in enumerate(steps[:cursor])
-                                 if k is DESCENDANT or k is DESCENDANT_OR_SELF]
-                    backsteps.reverse()
-                    for cursor, axis, nodetest, predicates in backsteps:
-                        if nodetest(kind, data, pos, namespaces, variables):
-                            cutoff[:] = []
-                            break
-                    cursors[-1] = cursor
-
+            for test in tests:
+                val = test(event, namespaces, variables, updateonly=updateonly)
+                if retval is None:
+                    retval = val
             return retval
-
-        return _test
+        return _multi
 
 
@@ -375 +713 @@
         while True:
             if self.cur_token.startswith('/'):
-                if self.cur_token == '//':
+                if not steps:
+                    if self.cur_token == '//':
+                        # hack to make //* match every node - also root
+                        self.next_token()
+                        axis, nodetest, predicates = self._location_step()
+                        steps.append((DESCENDANT_OR_SELF, nodetest, 
+                                      predicates))
+                        if self.at_end or not self.cur_token.startswith('/'):
+                            break
+                        continue
+                    else:
+                        raise PathSyntaxError('Absolute location paths not '
+                                              'supported', self.filename,
+                                              self.lineno)
+                elif self.cur_token == '//':
                     steps.append((DESCENDANT_OR_SELF, NodeTest(), []))
-                elif not steps:
-                    raise PathSyntaxError('Absolute location paths not '
-                                          'supported', self.filename,
-                                          self.lineno)
                 self.next_token()
 
@@ -387 +735 @@
                 axis = CHILD
             steps.append((axis, nodetest, predicates))
-
             if self.at_end or not self.cur_token.startswith('/'):
                 break
@@ -716 +1063 @@
     """
     __slots__ = ['expr']
+    _return_type = bool
     def __init__(self, expr):
         self.expr = expr
@@ -1173 +1521 @@
 
 _DOTSLASHSLASH = (DESCENDANT_OR_SELF, PrincipalTypeTest(None), ())
+_DOTSLASH = (SELF, PrincipalTypeTest(None), ())

trunk/genshi/tests/path.py

@@ -16 +16 @@
 
 from genshi.input import XML
-from genshi.path import Path, PathSyntaxError
-
+from genshi.path import Path, PathParser, PathSyntaxError, GenericStrategy, \
+                        SingleStepStrategy, SimplePathStrategy
+
+
+class FakePath(Path):
+    def __init__(self, strategy):
+        self.strategy = strategy
+    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):
@@ -31 +76 @@
         xml = XML('<root><elem/></root>')
 
-        path = Path('elem')
-        self.assertEqual('<Path "child::elem">', repr(path))
-        self.assertEqual('<elem/>', path.select(xml).render())
-
-        path = Path('child::elem')
-        self.assertEqual('<Path "child::elem">', repr(path))
-        self.assertEqual('<elem/>', path.select(xml).render())
-
-        path = Path('//elem')
-        self.assertEqual('<Path "descendant-or-self::node()/child::elem">',
-                         repr(path))
-        self.assertEqual('<elem/>', path.select(xml).render())
-
-        path = Path('descendant::elem')
-        self.assertEqual('<Path "descendant::elem">', repr(path))
-        self.assertEqual('<elem/>', path.select(xml).render())
+        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/>')
 
     def test_1step_self(self):
         xml = XML('<root><elem/></root>')
 
-        path = Path('.')
-        self.assertEqual('<Path "self::node()">', repr(path))
-        self.assertEqual('<root><elem/></root>', path.select(xml).render())
-
-        path = Path('self::node()')
-        self.assertEqual('<Path "self::node()">', repr(path))
-        self.assertEqual('<root><elem/></root>', path.select(xml).render())
+        self._test_expression(  '.',
+                                '<Path "self::node()">',
+                                xml,
+                                '<root><elem/></root>')
+
+        self._test_expression(  'self::node()',
+                                '<Path "self::node()">',
+                                xml,
+                                '<root><elem/></root>')
 
     def test_1step_wildcard(self):
         xml = XML('<root><elem/></root>')
 
-        path = Path('*')
-        self.assertEqual('<Path "child::*">', repr(path))
-        self.assertEqual('<elem/>', path.select(xml).render())
-
-        path = Path('child::*')
-        self.assertEqual('<Path "child::*">', repr(path))
-        self.assertEqual('<elem/>', path.select(xml).render())
-
-        path = Path('child::node()')
-        self.assertEqual('<Path "child::node()">', repr(path))
-        self.assertEqual('<elem/>', Path('child::node()').select(xml).render())
-
-        path = Path('//*')
-        self.assertEqual('<Path "descendant-or-self::node()/child::*">',
-                         repr(path))
-        self.assertEqual('<root><elem/></root>', path.select(xml).render())
+        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>')
 
     def test_1step_attribute(self):
-        path = Path('@foo')
-        self.assertEqual('<Path "attribute::foo">', repr(path))
-
-        xml = XML('<root/>')
-        self.assertEqual('', path.select(xml).render())
+        self._test_expression(  '@foo',
+                                '<Path "attribute::foo">',
+                                XML('<root/>'),
+                                '')
 
         xml = XML('<root foo="bar"/>')
-        self.assertEqual('bar', path.select(xml).render())
-
-        path = Path('./@foo')
-        self.assertEqual('<Path "self::node()/attribute::foo">', repr(path))
-        self.assertEqual('bar', path.select(xml).render())
+
+        self._test_expression(  '@foo',
+                                '<Path "attribute::foo">',
+                                xml,
+                                'bar')
+
+        self._test_expression(  './@foo',
+                                '<Path "self::node()/attribute::foo">',
+                                xml,
+                                'bar')
 
     def test_1step_text(self):
         xml = XML('<root>Hey</root>')
 
-        path = Path('text()')
-        self.assertEqual('<Path "child::text()">', repr(path))
-        self.assertEqual('Hey', path.select(xml).render())
-
-        path = Path('./text()')
-        self.assertEqual('<Path "self::node()/child::text()">', repr(path))
-        self.assertEqual('Hey', path.select(xml).render())
-
-        path = Path('//text()')
-        self.assertEqual('<Path "descendant-or-self::node()/child::text()">',
-                         repr(path))
-        self.assertEqual('Hey', path.select(xml).render())
-
-        path = Path('.//text()')
-        self.assertEqual('<Path "self::node()/descendant-or-self::node()/child::text()">',
-                         repr(path))
-        self.assertEqual('Hey', path.select(xml).render())
+        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')
 
     def test_2step(self):
         xml = XML('<root><foo/><bar/></root>')
-        self.assertEqual('<foo/><bar/>', Path('*').select(xml).render())
-        self.assertEqual('<bar/>', Path('bar').select(xml).render())
-        self.assertEqual('', Path('baz').select(xml).render())
+        self._test_expression('*', None, xml, '<foo/><bar/>')
+        self._test_expression('bar', None, xml, '<bar/>')
+        self._test_expression('baz', None, xml, '')
 
     def test_2step_attribute(self):
         xml = XML('<elem class="x"><span id="joe">Hey Joe</span></elem>')
-        self.assertEqual('x', Path('@*').select(xml).render())
-        self.assertEqual('x', Path('./@*').select(xml).render())
-        self.assertEqual('xjoe', Path('.//@*').select(xml).render())
-        self.assertEqual('joe', Path('*/@*').select(xml).render())
+        self._test_expression('@*', None, xml, 'x')
+        self._test_expression('./@*', None, xml, 'x')
+        self._test_expression('.//@*', None, xml, 'xjoe')
+        self._test_expression('*/@*', None, xml, 'joe')
 
         xml = XML('<elem><foo id="1"/><foo id="2"/></elem>')
-        self.assertEqual('', Path('@*').select(xml).render())
-        self.assertEqual('12', Path('foo/@*').select(xml).render())
+        self._test_expression('@*', None, xml, '')
+        self._test_expression('foo/@*', None, xml, '12')
 
     def test_2step_complex(self):
         xml = XML('<root><foo><bar/></foo></root>')
 
-        path = Path('foo/bar')
-        self.assertEqual('<Path "child::foo/child::bar">', repr(path))
-        self.assertEqual('<bar/>', path.select(xml).render())
-
-        path = Path('./bar')
-        self.assertEqual('<Path "self::node()/child::bar">', repr(path))
-        self.assertEqual('', path.select(xml).render())
-
-        path = Path('foo/*')
-        self.assertEqual('<Path "child::foo/child::*">', repr(path))
-        self.assertEqual('<bar/>', path.select(xml).render())
+        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/>')
 
         xml = XML('<root><foo><bar id="1"/></foo><bar id="2"/></root>')
-        path = Path('./bar')
-        self.assertEqual('<Path "self::node()/child::bar">', repr(path))
-        self.assertEqual('<bar id="2"/>', path.select(xml).render())
+        self._test_expression(  './bar',
+                                '<Path "self::node()/child::bar">',
+                                xml,
+                                '<bar id="2"/>')
 
     def test_2step_text(self):
         xml = XML('<root><item>Foo</item></root>')
 
-        path = Path('item/text()')
-        self.assertEqual('<Path "child::item/child::text()">', repr(path))
-        self.assertEqual('Foo', path.select(xml).render())
-
-        path = Path('*/text()')
-        self.assertEqual('<Path "child::*/child::text()">', repr(path))
-        self.assertEqual('Foo', path.select(xml).render())
-
-        path = Path('//text()')
-        self.assertEqual('<Path "descendant-or-self::node()/child::text()">',
-                         repr(path))
-        self.assertEqual('Foo', path.select(xml).render())
-
-        path = Path('./text()')
-        self.assertEqual('<Path "self::node()/child::text()">', repr(path))
-        self.assertEqual('', path.select(xml).render())
+        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,
+                                '')
 
         xml = XML('<root><item>Foo</item><item>Bar</item></root>')
-        path = Path('item/text()')
-        self.assertEqual('<Path "child::item/child::text()">', repr(path))
-        self.assertEqual('FooBar', path.select(xml).render())
-
-        xml = XML('<root><item>Foo</item><item>Bar</item></root>')
-        self.assertEqual('FooBar', path.select(xml).render())
+        self._test_expression(  'item/text()',
+                                '<Path "child::item/child::text()">',
+                                xml,
+                                'FooBar')
 
     def test_3step(self):
         xml = XML('<root><foo><bar/></foo></root>')
-        path = Path('foo/*')
-        self.assertEqual('<Path "child::foo/child::*">', repr(path))
-        self.assertEqual('<bar/>', path.select(xml).render())
+        self._test_expression(  'foo/*',
+                                '<Path "child::foo/child::*">',
+                                xml,
+                                '<bar/>')
 
     def test_3step_complex(self):
         xml = XML('<root><foo><bar/></foo></root>')
-        path = Path('*/bar')
-        self.assertEqual('<Path "child::*/child::bar">', repr(path))
-        self.assertEqual('<bar/>', path.select(xml).render())
+        self._test_expression(  '*/bar',
+                                '<Path "child::*/child::bar">',
+                                xml,
+                                '<bar/>')
 
         xml = XML('<root><foo><bar id="1"/></foo><bar id="2"/></root>')
-        path = Path('//bar')
-        self.assertEqual('<Path "descendant-or-self::node()/child::bar">',
-                         repr(path))
-        self.assertEqual('<bar id="1"/><bar id="2"/>',
-                         path.select(xml).render())
+        self._test_expression(  '//bar',
+                                '<Path "descendant-or-self::bar">',
+                                xml,
+                                '<bar id="1"/><bar id="2"/>')
 
     def test_node_type_comment(self):
         xml = XML('<root><!-- commented --></root>')
-        path = Path('comment()')
-        self.assertEqual('<Path "child::comment()">', repr(path))
-        self.assertEqual('<!-- commented -->', path.select(xml).render())
+        self._test_expression(  'comment()',
+                                '<Path "child::comment()">',
+                                xml,
+                                '<!-- commented -->')
 
     def test_node_type_text(self):
         xml = XML('<root>Some text <br/>in here.</root>')
-        path = Path('text()')
-        self.assertEqual('<Path "child::text()">', repr(path))
-        self.assertEqual('Some text in here.', path.select(xml).render())
+        self._test_expression(  'text()',
+                                '<Path "child::text()">',
+                                xml,
+                                'Some text in here.')
 
     def test_node_type_node(self):
         xml = XML('<root>Some text <br/>in here.</root>')
-        path = Path('node()')
-        self.assertEqual('<Path "child::node()">', repr(path))
-        self.assertEqual('Some text <br/>in here.', path.select(xml).render())
+        self._test_expression(  'node()',
+                                '<Path "child::node()">',
+                                xml,
+                                'Some text <br/>in here.',)
 
     def test_node_type_processing_instruction(self):
         xml = XML('<?python x = 2 * 3 ?><root><?php echo("x") ?></root>')
 
-        path = Path('processing-instruction()')
-        self.assertEqual('<Path "child::processing-instruction()">',
-                         repr(path))
-        self.assertEqual('<?python x = 2 * 3 ?><?php echo("x") ?>',
-                         path.select(xml).render())
-
-        path = Path('processing-instruction("php")')
-        self.assertEqual('<Path "child::processing-instruction(\"php\")">',
-                         repr(path))
-        self.assertEqual('<?php echo("x") ?>', path.select(xml).render())
+        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") ?>')
 
     def test_simple_union(self):
         xml = XML("""<body>1<br />2<br />3<br /></body>""")
-        path = Path('*|text()')
-        self.assertEqual('<Path "child::*|child::text()">', repr(path))
-        self.assertEqual('1<br/>2<br/>3<br/>', path.select(xml).render())
+        self._test_expression(  '*|text()',
+                                '<Path "child::*|child::text()">',
+                                xml,
+                                '1<br/>2<br/>3<br/>')
 
     def test_predicate_name(self):
         xml = XML('<root><foo/><bar/></root>')
-        path = Path('*[name()="foo"]')
-        self.assertEqual('<foo/>', path.select(xml).render())
+        self._test_expression('*[name()="foo"]', None, xml, '<foo/>')
 
     def test_predicate_localname(self):
         xml = XML('<root><foo xmlns="NS"/><bar/></root>')
-        path = Path('*[local-name()="foo"]')
-        self.assertEqual('<foo xmlns="NS"/>', path.select(xml).render())
+        self._test_expression('*[local-name()="foo"]', None, xml,
+                                '<foo xmlns="NS"/>')
 
     def test_predicate_namespace(self):
         xml = XML('<root><foo xmlns="NS"/><bar/></root>')
-        path = Path('*[namespace-uri()="NS"]')
-        self.assertEqual('<foo xmlns="NS"/>', path.select(xml).render())
+        self._test_expression('*[namespace-uri()="NS"]', None, xml,
+                                '<foo xmlns="NS"/>')
 
     def test_predicate_not_name(self):
         xml = XML('<root><foo/><bar/></root>')
-        path = Path('*[not(name()="foo")]')
-        self.assertEqual('<bar/>', path.select(xml).render())
+        self._test_expression('*[not(name()="foo")]', None, xml, '<bar/>')
 
     def test_predicate_attr(self):
         xml = XML('<root><item/><item important="very"/></root>')
-        path = Path('item[@important]')
-        self.assertEqual('<item important="very"/>', path.select(xml).render())
-        path = Path('item[@important="very"]')
-        self.assertEqual('<item important="very"/>', path.select(xml).render())
+        self._test_expression('item[@important]', None, xml,
+                                '<item important="very"/>')
+        self._test_expression('item[@important="very"]', None, xml,
+                                '<item important="very"/>')
 
     def test_predicate_attr_equality(self):
         xml = XML('<root><item/><item important="notso"/></root>')
-        path = Path('item[@important="very"]')
-        self.assertEqual('', path.select(xml).render())
-        path = Path('item[@important!="very"]')
-        self.assertEqual('<item/><item important="notso"/>',
-                         path.select(xml).render())
+        self._test_expression('item[@important="very"]', None, xml, '')
+        self._test_expression('item[@important!="very"]', None, xml,
+                                '<item/><item important="notso"/>')
 
     def test_predicate_attr_greater_than(self):
         xml = XML('<root><item priority="3"/></root>')
-        path = Path('item[@priority>3]')
-        self.assertEqual('', path.select(xml).render())
-        path = Path('item[@priority>2]')
-        self.assertEqual('<item priority="3"/>', path.select(xml).render())
+        self._test_expression('item[@priority>3]', None, xml, '')
+        self._test_expression('item[@priority>2]', None, xml,
+                                '<item priority="3"/>')
 
     def test_predicate_attr_less_than(self):
         xml = XML('<root><item priority="3"/></root>')
-        path = Path('item[@priority<3]')
-        self.assertEqual('', path.select(xml).render())
-        path = Path('item[@priority<4]')
-        self.assertEqual('<item priority="3"/>', path.select(xml).render())
+        self._test_expression('item[@priority<3]', None, xml, '')
+        self._test_expression('item[@priority<4]', None, xml,
+                                '<item priority="3"/>')
 
     def test_predicate_attr_and(self):
         xml = XML('<root><item/><item important="very"/></root>')
-        path = Path('item[@important and @important="very"]')
-        self.assertEqual('<item important="very"/>', path.select(xml).render())
-        path = Path('item[@important and @important="notso"]')
-        self.assertEqual('', path.select(xml).render())
+        self._test_expression('item[@important and @important="very"]',
+                                None, xml, '<item important="very"/>')
+        self._test_expression('item[@important and @important="notso"]',
+                                None, xml, '')
 
     def test_predicate_attr_or(self):
         xml = XML('<root><item/><item important="very"/></root>')
-        path = Path('item[@urgent or @important]')
-        self.assertEqual('<item important="very"/>', path.select(xml).render())
-        path = Path('item[@urgent or @notso]')
-        self.assertEqual('', path.select(xml).render())
+        self._test_expression('item[@urgent or @important]', None, xml,
+                                '<item important="very"/>')
+        self._test_expression('item[@urgent or @notso]', None, xml, '')
 
     def test_predicate_boolean_function(self):
         xml = XML('<root><foo>bar</foo></root>')
-        path = Path('*[boolean("")]')
-        self.assertEqual('', path.select(xml).render())
-        path = Path('*[boolean("yo")]')
-        self.assertEqual('<foo>bar</foo>', path.select(xml).render())
-        path = Path('*[boolean(0)]')
-        self.assertEqual('', path.select(xml).render())
-        path = Path('*[boolean(42)]')
-        self.assertEqual('<foo>bar</foo>', path.select(xml).render())
-        path = Path('*[boolean(false())]')
-        self.assertEqual('', path.select(xml).render())
-        path = Path('*[boolean(true())]')
-        self.assertEqual('<foo>bar</foo>', path.select(xml).render())
+        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>')
 
     def test_predicate_ceil_function(self):
         xml = XML('<root><foo>bar</foo></root>')
-        path = Path('*[ceiling("4.5")=5]')
-        self.assertEqual('<foo>bar</foo>', path.select(xml).render())
+        self._test_expression('*[ceiling("4.5")=5]', None, xml,
+                                '<foo>bar</foo>')
 
     def test_predicate_concat_function(self):
         xml = XML('<root><foo>bar</foo></root>')
-        path = Path('*[name()=concat("f", "oo")]')
-        self.assertEqual('<foo>bar</foo>', path.select(xml).render())
+        self._test_expression('*[name()=concat("f", "oo")]', None, xml,
+                                '<foo>bar</foo>')
 
     def test_predicate_contains_function(self):
         xml = XML('<root><foo>bar</foo></root>')
-        path = Path('*[contains(name(), "oo")]')
-        self.assertEqual('<foo>bar</foo>', path.select(xml).render())
+        self._test_expression('*[contains(name(), "oo")]', None, xml,
+                                '<foo>bar</foo>')
 
     def test_predicate_matches_function(self):
         xml = XML('<root><foo>bar</foo><bar>foo</bar></root>')
-        path = Path('*[matches(name(), "foo|bar")]')
-        self.assertEqual('<foo>bar</foo><bar>foo</bar>', path.select(xml).render())
+        self._test_expression('*[matches(name(), "foo|bar")]', None, xml,
+                                '<foo>bar</foo><bar>foo</bar>')
 
     def test_predicate_false_function(self):
         xml = XML('<root><foo>bar</foo></root>')
-        path = Path('*[false()]')
-        self.assertEqual('', path.select(xml).render())
+        self._test_expression('*[false()]', None, xml, '')
 
     def test_predicate_floor_function(self):
         xml = XML('<root><foo>bar</foo></root>')
-        path = Path('*[floor("4.5")=4]')
-        self.assertEqual('<foo>bar</foo>', path.select(xml).render())
+        self._test_expression('*[floor("4.5")=4]', None, xml,
+                                '<foo>bar</foo>')
 
     def test_predicate_normalize_space_function(self):
         xml = XML('<root><foo>bar</foo></root>')
-        path = Path('*[normalize-space(" foo   bar  ")="foo bar"]')
-        self.assertEqual('<foo>bar</foo>', path.select(xml).render())
+        self._test_expression('*[normalize-space(" foo   bar  ")="foo bar"]',
+                                None, xml, '<foo>bar</foo>')
 
     def test_predicate_number_function(self):
         xml = XML('<root><foo>bar</foo></root>')
-        path = Path('*[number("3.0")=3]')
-        self.assertEqual('<foo>bar</foo>', path.select(xml).render())
-        path = Path('*[number("3.0")=3.0]')
-        self.assertEqual('<foo>bar</foo>', path.select(xml).render())
-        path = Path('*[number("0.1")=.1]')
-        self.assertEqual('<foo>bar</foo>', path.select(xml).render())
+        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>')
 
     def test_predicate_round_function(self):
         xml = XML('<root><foo>bar</foo></root>')
-        path = Path('*[round("4.4")=4]')
-        self.assertEqual('<foo>bar</foo>', path.select(xml).render())
-        path = Path('*[round("4.6")=5]')
-        self.assertEqual('<foo>bar</foo>', path.select(xml).render())
+        self._test_expression('*[round("4.4")=4]', None, xml,
+                                '<foo>bar</foo>')
+        self._test_expression('*[round("4.6")=5]', None, xml,
+                                '<foo>bar</foo>')
 
     def test_predicate_starts_with_function(self):
         xml = XML('<root><foo>bar</foo></root>')
-        path = Path('*[starts-with(name(), "f")]')
-        self.assertEqual('<foo>bar</foo>', path.select(xml).render())
-        path = Path('*[starts-with(name(), "b")]')
-        self.assertEqual('', path.select(xml).render())
+        self._test_expression('*[starts-with(name(), "f")]', None, xml,
+                                '<foo>bar</foo>')
+        self._test_expression('*[starts-with(name(), "b")]', None, xml, '')
 
     def test_predicate_string_length_function(self):
         xml = XML('<root><foo>bar</foo></root>')
-        path = Path('*[string-length(name())=3]')
-        self.assertEqual('<foo>bar</foo>', path.select(xml).render())
+        self._test_expression('*[string-length(name())=3]', None, xml,
+                                '<foo>bar</foo>')
 
     def test_predicate_substring_function(self):
         xml = XML('<root><foo>bar</foo></root>')
-        path = Path('*[substring(name(), 1)="oo"]')
-        self.assertEqual('<foo>bar</foo>', path.select(xml).render())
-        path = Path('*[substring(name(), 1, 1)="o"]')
-        self.assertEqual('<foo>bar</foo>', path.select(xml).render())
+        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>')
 
     def test_predicate_substring_after_function(self):
         xml = XML('<root><foo>bar</foo></root>')
-        path = Path('*[substring-after(name(), "f")="oo"]')
-        self.assertEqual('<foo>bar</foo>', path.select(xml).render())
+        self._test_expression('*[substring-after(name(), "f")="oo"]', None, xml,
+                                '<foo>bar</foo>')
 
     def test_predicate_substring_before_function(self):
         xml = XML('<root><foo>bar</foo></root>')
-        path = Path('*[substring-before(name(), "oo")="f"]')
-        self.assertEqual('<foo>bar</foo>', path.select(xml).render())
+        self._test_expression('*[substring-before(name(), "oo")="f"]',
+                                None, xml, '<foo>bar</foo>')
 
     def test_predicate_translate_function(self):
         xml = XML('<root><foo>bar</foo></root>')
-        path = Path('*[translate(name(), "fo", "ba")="baa"]')
-        self.assertEqual('<foo>bar</foo>', path.select(xml).render())
+        self._test_expression('*[translate(name(), "fo", "ba")="baa"]',
+                                None, xml, '<foo>bar</foo>')
 
     def test_predicate_true_function(self):
         xml = XML('<root><foo>bar</foo></root>')
-        path = Path('*[true()]')
-        self.assertEqual('<foo>bar</foo>', path.select(xml).render())
+        self._test_expression('*[true()]', None, xml, '<foo>bar</foo>')
 
     def test_predicate_variable(self):
         xml = XML('<root><foo>bar</foo></root>')
-        path = Path('*[name()=$bar]')
         variables = {'bar': 'foo'}
-        self.assertEqual('<foo>bar</foo>',
-                         path.select(xml, variables=variables).render())
+        self._test_expression('*[name()=$bar]', None, xml, '<foo>bar</foo>',
+                                variables = variables)
 
     def test_predicate_position(self):
         xml = XML('<root><foo id="a1"/><foo id="a2"/><foo id="a3"/></root>')
-        path = Path('*[2]')
-        self.assertEqual('<foo id="a2"/>', path.select(xml).render())
+        self._test_expression('*[2]', None, xml, '<foo id="a2"/>')
 
     def test_predicate_attr_and_position(self):
         xml = XML('<root><foo/><foo id="a1"/><foo id="a2"/></root>')
-        path = Path('*[@id][2]')
-        self.assertEqual('<foo id="a2"/>', path.select(xml).render())
+        self._test_expression('*[@id][2]', None, xml, '<foo id="a2"/>')
 
     def test_predicate_position_and_attr(self):
         xml = XML('<root><foo/><foo id="a1"/><foo id="a2"/></root>')
-        path = Path('*[1][@id]')
-        self.assertEqual('', path.select(xml).render())
-        path = Path('*[2][@id]')
-        self.assertEqual('<foo id="a1"/>', path.select(xml).render())
+        self._test_expression('*[1][@id]', None, xml, '')
+        self._test_expression('*[2][@id]', None, xml, '<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::*/'
+                                'descendant-or-self::*/'
+                                'descendant-or-self::*[2]/'
+                                'self::*/descendant::*[3]', None, xml,
+                                '<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>')
 
     def test_name_with_namespace(self):
         xml = XML('<root xmlns:f="FOO"><f:foo>bar</f:foo></root>')
-        path = Path('f:foo')
-        self.assertEqual('<Path "child::f:foo">', repr(path))
-        namespaces = {'f': 'FOO'}
-        self.assertEqual('<foo xmlns="FOO">bar</foo>',
-                         path.select(xml, namespaces=namespaces).render())
+        self._test_expression('f:foo', '<Path "child::f:foo">', xml,
+                                '<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>')
-        path = Path('f:*')
-        self.assertEqual('<Path "child::f:*">', repr(path))
-        namespaces = {'f': 'FOO'}
-        self.assertEqual('<foo xmlns="FOO">bar</foo>',
-                         path.select(xml, namespaces=namespaces).render())
+        self._test_expression('f:*', '<Path "child::f:*">', xml,
+                                '<foo xmlns="FOO">bar</foo>',
+                                namespaces = {'f': 'FOO'})
 
     def test_predicate_termination(self):
@@ -450 +518 @@
         """
         xml = XML('<ul flag="1"><li>a</li><li>b</li></ul>')
-        path = Path('.[@flag="1"]/*')
-        self.assertEqual('<li>a</li><li>b</li>', path.select(xml).render())
+        self._test_expression('.[@flag="1"]/*', None, xml,
+                                '<li>a</li><li>b</li>')
 
         xml = XML('<ul flag="1"><li>a</li><li>b</li></ul>')
-        path = Path('.[@flag="0"]/*')
-        self.assertEqual('', path.select(xml).render())
+        self._test_expression('.[@flag="0"]/*', None, xml, '')
 
     def test_attrname_with_namespace(self):
         xml = XML('<root xmlns:f="FOO"><foo f:bar="baz"/></root>')
-        path = Path('foo[@f:bar]')
-        self.assertEqual('<foo xmlns:ns1="FOO" ns1:bar="baz"/>',
-                         path.select(xml, namespaces={'f': 'FOO'}).render())
+        self._test_expression('foo[@f:bar]', None, xml,
+                                '<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>')
-        path = Path('foo[@f:*]')
-        self.assertEqual('<foo xmlns:ns1="FOO" ns1:bar="baz"/>',
-                         path.select(xml, namespaces={'f': 'FOO'}).render())
-
+        self._test_expression('foo[@f:*]', None, xml,
+                                '<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/>')
+
+    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>')
+        # 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, '')
+    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'))
+        self.assert_(self._test_support(SimplePathStrategy, 'descendant::a/b'))
+        self.assert_(self._test_support(SimplePathStrategy,
+                         'descendant-or-self::a/b'))
+        self.assert_(self._test_support(SimplePathStrategy, '//a/b'))
+        self.assert_(self._test_support(SimplePathStrategy, 'a/@b'))
+        self.assert_(self._test_support(SimplePathStrategy, 'a/text()'))
+
+        # a//b is a/descendant-or-self::node()/b
+        self.assert_(not self._test_support(SimplePathStrategy, 'a//b'))
+        self.assert_(not self._test_support(SimplePathStrategy, 'node()/@a'))
+        self.assert_(not self._test_support(SimplePathStrategy, '@a'))
+        self.assert_(not self._test_support(SimplePathStrategy, 'foo:bar'))
+        self.assert_(not self._test_support(SimplePathStrategy, 'a/@foo:bar'))
 
 def suite():