def testParseWithText(self):
wiz = TreeWizard(self.adaptor, self.tokens)
t = wiz.create("(A B[foo] C[bar])")
# C pattern has no text arg so despite [bar] in t, no need
# to match text--check structure only.
valid = wiz.parse(t, "(A B[foo] C)")
self.failUnless(valid)
def testParseWithText2(self):
wiz = TreeWizard(self.adaptor, self.tokens)
t = wiz.create("(A B[T__32] (C (D E[a])))")
# C pattern has no text arg so despite [bar] in t, no need
# to match text--check structure only.
valid = wiz.parse(t, "(A B[foo] C)")
self.assertEquals("(A T__32 (C (D a)))", t.toStringTree())
def testParseWithWildcardLabels(self):
wiz = TreeWizard(self.adaptor, self.tokens)
t = wiz.create("(A B C)")
labels = {}
valid = wiz.parse(t, "(A %b:. %c:.)", labels)
self.failUnless(valid)
self.failUnlessEqual("B", str(labels["b"]))
self.failUnlessEqual("C", str(labels["c"]))
def testParseLabels(self):
wiz = TreeWizard(self.adaptor, self.tokens)
t = wiz.create("(A B C)")
labels = {}
valid = wiz.parse(t, "(%a:A %b:B %c:C)", labels)
self.assertTrue(valid)
self.assertEqual("A", str(labels["a"]))
self.assertEqual("B", str(labels["b"]))
self.assertEqual("C", str(labels["c"]))
def testParseLabelsAndTestText(self):
wiz = TreeWizard(self.adaptor, self.tokens)
t = wiz.create("(A B[foo] C)")
labels = {}
valid = wiz.parse(t, "(%a:A %b:B[foo] %c:C)", labels)
self.failUnless(valid)
self.failUnlessEqual("A", str(labels["a"]))
self.failUnlessEqual("foo", str(labels["b"]))
self.failUnlessEqual("C", str(labels["c"]))
def testParseLabels(self):
wiz = TreeWizard(self.adaptor, self.tokens)
t = wiz.create("(A B C)")
labels = {}
valid = wiz.parse(t, "(%a:A %b:B %c:C)", labels)
self.assertTrue(valid)
self.assertEqual("A", str(labels["a"]))
self.assertEqual("B", str(labels["b"]))
self.assertEqual("C", str(labels["c"]))
def testParseLabelsInNestedTree(self):
wiz = TreeWizard(self.adaptor, self.tokens)
t = wiz.create("(A (B C) (D E))")
labels = {}
valid = wiz.parse(t, "(%a:A (%b:B %c:C) (%d:D %e:E) )", labels)
self.failUnless(valid)
self.failUnlessEqual("A", str(labels["a"]))
self.failUnlessEqual("B", str(labels["b"]))
self.failUnlessEqual("C", str(labels["c"]))
self.failUnlessEqual("D", str(labels["d"]))
self.failUnlessEqual("E", str(labels["e"]))
def testNoParent(self):
tree = "(PRINT (MULT ID[x] (VEC INT[1] INT[2] INT[3])))"
adaptor = CommonTreeAdaptor()
wiz = TreeWizard(adaptor, self.tokenNames)
t = wiz.create(tree)
labels = {}
valid = wiz.parse(t, "(%x:PRINT (MULT ID (VEC INT INT INT)))", labels)
self.assertTrue(valid)
node = labels.get("x")
expecting = False
found = TreeParser._inContext(adaptor, self.tokenNames, node, "VEC")
self.assertEqual(expecting, found)
def testLotsOfWildcards(self):
tree = "(nil (ASSIGN ID[x] INT[3]) (PRINT (MULT ID[x] (VEC INT[1] INT[2] INT[3]))))"
adaptor = CommonTreeAdaptor()
wiz = TreeWizard(adaptor, self.tokenNames)
t = wiz.create(tree)
labels = {}
valid = wiz.parse(t, "(nil (ASSIGN ID[x] INT[3]) (PRINT (MULT ID (VEC INT %x:INT INT))))", labels)
self.assertTrue(valid)
node = labels.get("x")
expecting = True
found = TreeParser._inContext(adaptor, self.tokenNames, node, "... PRINT ... VEC ...")
self.assertEquals(expecting, found)
def testNotParent(self):
tree = "(PRINT (MULT ID[x] (VEC (MULT INT[9] INT[1]) INT[2] INT[3])))"
adaptor = CommonTreeAdaptor()
wiz = TreeWizard(adaptor, self.tokenNames)
t = wiz.create(tree)
labels = {}
valid = wiz.parse(t, "(PRINT (MULT ID (VEC (MULT INT %x:INT) INT INT)))", labels)
self.assertTrue(valid)
node = labels.get("x")
expecting = False
found = TreeParser._inContext(adaptor, self.tokenNames, node, "VEC")
self.assertEquals(expecting, found)
def testDotDot(self):
tree = "(PRINT (MULT ID[x] (VEC (MULT INT[9] INT[1]) INT[2] INT[3])))"
adaptor = CommonTreeAdaptor()
wiz = TreeWizard(adaptor, self.tokenNames)
t = wiz.create(tree)
labels = {}
valid = wiz.parse(t,
"(PRINT (MULT ID (VEC (MULT INT %x:INT) INT INT)))",
labels)
self.assertTrue(valid)
node = labels.get("x")
self.assertRaisesRegex(ValueError, r'invalid syntax: \.\.',
TreeParser._inContext, adaptor, self.tokenNames,
node, "PRINT .. VEC")
def testDotDot(self):
tree = "(PRINT (MULT ID[x] (VEC (MULT INT[9] INT[1]) INT[2] INT[3])))"
adaptor = CommonTreeAdaptor()
wiz = TreeWizard(adaptor, self.tokenNames)
t = wiz.create(tree)
labels = {}
valid = wiz.parse(
t,
"(PRINT (MULT ID (VEC (MULT INT %x:INT) INT INT)))",
labels)
self.assertTrue(valid)
node = labels.get("x")
self.assertRaisesRegex(
ValueError, r'invalid syntax: \.\.',
TreeParser._inContext, adaptor, self.tokenNames, node, "PRINT .. VEC")
def testDeepAndFindRoot(self):
tree = "(PRINT (MULT ID[x] (VEC (MULT INT[9] INT[1]) INT[2] INT[3])))"
adaptor = CommonTreeAdaptor()
wiz = TreeWizard(adaptor, self.tokenNames)
t = wiz.create(tree)
labels = {}
valid = wiz.parse(t,
"(PRINT (MULT ID (VEC (MULT INT %x:INT) INT INT)))",
labels)
self.assertTrue(valid)
node = labels.get("x")
expecting = True
found = TreeParser._inContext(adaptor, self.tokenNames, node,
"PRINT ...")
self.assertEqual(expecting, found)
def testWildcardAtStartIgnored(self):
tree = "(nil (ASSIGN ID[x] INT[3]) (PRINT (MULT ID[x] (VEC INT[1] INT[2] INT[3]))))"
adaptor = CommonTreeAdaptor()
wiz = TreeWizard(adaptor, self.tokenNames)
t = wiz.create(tree)
labels = {}
valid = wiz.parse(
t,
"(nil (ASSIGN ID[x] INT[3]) (PRINT (MULT ID (VEC INT %x:INT INT))))",
labels)
self.assertTrue(valid)
node = labels.get("x")
expecting = True
found = TreeParser._inContext(adaptor, self.tokenNames, node, "...VEC")
self.assertEqual(expecting, found)
def testDotDot(self):
tree = "(PRINT (MULT ID[x] (VEC (MULT INT[9] INT[1]) INT[2] INT[3])))"
adaptor = CommonTreeAdaptor()
wiz = TreeWizard(adaptor, self.tokenNames)
t = wiz.create(tree)
labels = {}
valid = wiz.parse(t, "(PRINT (MULT ID (VEC (MULT INT %x:INT) INT INT)))", labels)
self.assertTrue(valid)
node = labels.get("x")
try:
TreeParser._inContext(adaptor, self.tokenNames, node, "PRINT .. VEC")
self.fail()
except ValueError, exc:
expecting = "invalid syntax: .."
found = str(exc)
self.assertEquals(expecting, found)
def testMismatch(self):
tree = "(PRINT (MULT ID[x] (VEC (MULT INT[9] INT[1]) INT[2] INT[3])))"
adaptor = CommonTreeAdaptor()
wiz = TreeWizard(adaptor, self.tokenNames)
t = wiz.create(tree)
labels = {}
valid = wiz.parse(t,
"(PRINT (MULT ID (VEC (MULT INT %x:INT) INT INT)))",
labels)
self.assertTrue(valid)
node = labels.get("x")
expecting = False
## missing MULT
found = TreeParser._inContext(adaptor, self.tokenNames, node,
"PRINT VEC MULT")
self.assertEquals(expecting, found)
def testDotDot(self):
tree = "(PRINT (MULT ID[x] (VEC (MULT INT[9] INT[1]) INT[2] INT[3])))"
adaptor = CommonTreeAdaptor()
wiz = TreeWizard(adaptor, self.tokenNames)
t = wiz.create(tree)
labels = {}
valid = wiz.parse(t,
"(PRINT (MULT ID (VEC (MULT INT %x:INT) INT INT)))",
labels)
self.assertTrue(valid)
node = labels.get("x")
try:
TreeParser._inContext(adaptor, self.tokenNames, node,
"PRINT .. VEC")
self.fail()
except ValueError, exc:
expecting = "invalid syntax: .."
found = str(exc)
self.assertEquals(expecting, found)
def testWildcard(self):
wiz = TreeWizard(self.adaptor, self.tokens)
t = wiz.create("(A B C)")
valid = wiz.parse(t, "(A . .)")
self.failUnless(valid)
def testParseSingleNodeFails(self):
wiz = TreeWizard(self.adaptor, self.tokens)
t = wiz.create("A")
valid = wiz.parse(t, "B")
self.assertFalse(valid)
def testParseFlatTreeFails2(self):
wiz = TreeWizard(self.adaptor, self.tokens)
t = wiz.create("(nil A B C)")
valid = wiz.parse(t, "(nil A B A)")
self.assertFalse(valid)
def testParse(self):
wiz = TreeWizard(self.adaptor, self.tokens)
t = wiz.create("(A B C)")
valid = wiz.parse(t, "(A B C)")
self.assertTrue(valid)
def testParseSingleNodeFails(self):
wiz = TreeWizard(self.adaptor, self.tokens)
t = wiz.create("A")
valid = wiz.parse(t, "B")
self.assertFalse(valid)
def testParseFlatTreeFails2(self):
wiz = TreeWizard(self.adaptor, self.tokens)
t = wiz.create("(nil A B C)")
valid = wiz.parse(t, "(nil A B A)")
self.assertFalse(valid)
def testParseWithTextFails(self):
wiz = TreeWizard(self.adaptor, self.tokens)
t = wiz.create("(A B C)")
valid = wiz.parse(t, "(A[foo] B C)")
self.failUnless(not valid) # fails
def testParseSingleNodeFails(self):
wiz = TreeWizard(self.adaptor, self.tokens)
t = wiz.create("A")
valid = wiz.parse(t, "B")
self.failUnless(not valid)
def testParse(self):
wiz = TreeWizard(self.adaptor, self.tokens)
t = wiz.create("(A B C)")
valid = wiz.parse(t, "(A B C)")
self.assertTrue(valid)
def testParseFlatTreeFails2(self):
wiz = TreeWizard(self.adaptor, self.tokens)
t = wiz.create("(nil A B C)")
valid = wiz.parse(t, "(nil A B A)")
self.failUnless(not valid)
