def test_compile(tester): tester.startTest("Compile") exp = Compile("/") tester.compare( True, isinstance(exp, ParsedAbsoluteLocationPath.ParsedAbsoluteLocationPath)) tester.testDone()
def Test(tester): tester.startGroup('Exercise namespace nodes') isrc = InputSource.DefaultFactory.fromString(SRC_1, Uri.OsPathToUri(os.getcwd())) doc = NonvalidatingReader.parse(isrc) con = Context.Context(doc, 1, 1) EXPR = '//namespace::node()' expr = Compile(EXPR) #expr is <AbbreviatedAbsoluteLocationPath: /descendant-or-self::node()/namespace::node()> #expr._rel is <Step: namespace::node()> #expr._step is <Step: descendant-or-self::node()> tester.startTest(EXPR) actual = expr.evaluate(con) tester.compare(7, len(actual)) tester.testDone() EXPR = '//node()/namespace::node()' expr = Compile(EXPR) tester.startTest(EXPR) EXPECTED = [] actual = expr.evaluate(con) tester.compare(7, len(actual)) tester.testDone() EXPR = '//*/namespace::node()' expr = Compile(EXPR) tester.startTest(EXPR) EXPECTED = [] actual = expr.evaluate(con) tester.compare(7, len(actual)) tester.testDone() EXPR = '/*/*/namespace::node()' expr = Compile(EXPR) tester.startTest(EXPR) EXPECTED = [] actual = expr.evaluate(con) tester.compare(6, len(actual)) tester.testDone() EXPR = '/*/namespace::node()|/*/*/namespace::node()' expr = Compile(EXPR) tester.startTest(EXPR) EXPECTED = [] actual = expr.evaluate(con) tester.compare(7, len(actual)) tester.testDone() EXPR = '//*' expr = Compile(EXPR) #expr is <AbbreviatedAbsoluteLocationPath: /descendant-or-self::node()/child::*> tester.startTest(EXPR) EXPECTED = [] actual = expr.evaluate(con) tester.compare(4, len(actual)) tester.testDone() return tester.groupDone()
def Test(tester): tester.startGroup('CDATA sections in doc') isrc = InputSource.DefaultFactory.fromString(SRC_1, Uri.OsPathToUri(os.getcwd())) doc = NonvalidatingReader.parse(isrc) con = Context.Context(doc, 1, 1) EXPR = '/doc/elem/text()' expr = Compile(EXPR) tester.startTest(EXPR) actual = [node.data for node in expr.evaluate(con)] tester.compare(actual, ["abc"] * 3) tester.testDone() return tester.groupDone()
def fetch(params, debug=None, nopost=None): if (not params.has_key('resultxpath')): return None xhtml = send(params, debug, nopost) if debug: print >> sys.stderr, 'checking results' # make it a 4suite document doc = NonvalidatingReader.parseString(xhtml, params['action']) context = Context(doc, processorNss={"h": XHTML_NS}) #Compute the XPath against the context results = Compile(params['resultxpath']) results = results.evaluate(context) res = [] for a in results: tf = cStringIO.StringIO() PrettyPrint(a, tf) t = tf.getvalue() res.append(t) tf.close() results = res if debug: print >> sys.stderr, 'done', params['action'] return (results, xhtml)
def __init__(self, repr_xp, xp, nss): self._state_table = {START_STATE: {}} self._live_states = {} self._attrib_tests = {} self._ignored_subtree_states = [] self._push_states = [] self._substate_depth = 0 #States that should be hooked into for matching later XPatterns self._hook_states = {} newest_state = START_STATE last_state = START_STATE for subpat in xp.patterns: steps = subpat.steps[:] steps.reverse() for (step_count, (axis_type, node_test, ancestor)) in enumerate(steps): #Note: XSLT patterns only allow child or attribute axis handled = False attrib_test = None if axis_type == Node.ATTRIBUTE_NODE: if (isinstance(node_test, LocalNameTest) or isinstance(node_test, QualifiedNameTest) or isinstance(node_test, NamespaceTest) or isinstance(node_test, PrincipalTypeTest)): attrib_test = node_test start_event = (1, ATTRIB, None) end_event = (0, ATTRIB, None) handled = True elif isinstance(node_test, DocumentNodeTest): start_event = (1, None, None) end_event = (0, None, None) handled = True elif isinstance(node_test, LocalNameTest): if node_test.nodeType == Node.ELEMENT_NODE: start_event = (1, None, node_test._name) end_event = (0, None, node_test._name) handled = True elif isinstance(node_test, QualifiedNameTest): if node_test.nodeType == Node.ELEMENT_NODE: ns = nss[node_test._prefix] start_event = (1, ns, node_test._localName) end_event = (0, ns, node_test._localName) handled = True elif isinstance(node_test, PrincipalTypeTest): if node_test.nodeType == Node.ELEMENT_NODE: start_event = (1, ANY, EXPLICIT) end_event = (0, ANY, EXPLICIT) handled = True elif isinstance(node_test, NamespaceTest): if node_test.nodeType == Node.ELEMENT_NODE: ns = nss[node_test._prefix] start_event = (1, ns, ANY) end_event = (0, ns, ANY) handled = True if not (handled): import sys print >> sys.stderr, "Pattern step not supported:", ( axis_type, node_test, ancestor), "Node test class", node_test.__class__ continue #Say the full input is /u/v/w|/a/b/c and we're currently #Working the sub-pattern /a/b/c #top_state is the pattern #last_state is the last last_state = newest_state newest_state += 1 if not (step_count): if attrib_test: # #Because we want to treat @X as */@X # start_event = (1, ANY, EXPLICIT) # end_event = (0, ANY, EXPLICIT) attribute_test_state = newest_state self._state_table[newest_state] = {end_event: POP_STATE} if isinstance(node_test, DocumentNodeTest): self._state_table[START_STATE][ start_event] = newest_state else: for state in self._state_table: self._state_table[state][ start_event] = newest_state self._hook_states[newest_state] = start_event self._push_states.append(newest_state) #if attrib_test: #Because we want to treat @X as */@X # newest_state += 1 # start_event = (1, ATTRIB, None) # end_event = (0, ATTRIB, None) # self._state_table[newest_state] = {end_event: newest_state - 1} # self._state_table[newest_state -1][start_event] = newest_state else: if attrib_test: attribute_test_state = newest_state self._state_table[newest_state] = { end_event: parent_start_element_state } self._state_table[parent_start_element_state][ start_event] = newest_state for state in self._hook_states: self._state_table[newest_state][ self._hook_states[state]] = state start_element_state = newest_state #complete_state = top_state #The state representing completion of an XPattern if step_count and not ancestor and not isinstance( node_test, PrincipalTypeTest): #Insert a state, which handles any child element #Not explicitly matching some other state (so that #/a/b/c is not a mistaken match for XPattern /a/c) start_event = (1, ANY, IMPLICIT) end_event = (0, ANY, IMPLICIT) newest_state += 1 self._state_table[newest_state] = {} self._state_table[parent_start_element_state][ start_event] = newest_state self._state_table[newest_state][ end_event] = parent_start_element_state self._ignored_subtree_states.append(newest_state) #self._hook_states[newest_state] = start_event for state in self._hook_states: self._state_table[newest_state][ self._hook_states[state]] = state parent_start_element_state = start_element_state self._live_states[start_element_state] = repr_xp if attrib_test: self._attrib_tests[attribute_test_state] = Compile( '@' + repr(node_test)) self._state = START_STATE self.entering_xpatterns = [] self.leaving_xpatterns = [] self.current_xpatterns = [] self.tree_depth = 0 self.depth_marks = [] self.state_stack = [] #print self._state_table; print self._live_states; print self._push_states; print self._attrib_tests return