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 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 test_compile(tester):
tester.startTest("Compile")
exp = Compile("/")
tester.compare(
True,
isinstance(exp, ParsedAbsoluteLocationPath.ParsedAbsoluteLocationPath))
tester.testDone()
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 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 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 __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
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()
