def test_orOperator(self):
     """
     Test boolean or operator in condition.
     """
     xp = XPathQuery("//bar[@attrib5='value4' or @attrib5='value5']")
     self.assertEqual(xp.matches(self.e), True)
     self.assertEqual(xp.queryForNodes(self.e), [self.bar5, self.bar6])

 def test_attributeWithValueAny(self):
     """
     Test find nodes with attribute having value.
     """
     xp = XPathQuery("/foo/*[@attrib2='value2']")
     self.assertEqual(xp.matches(self.e), True)
     self.assertEqual(xp.queryForNodes(self.e), [self.bar2])

 def test_locationFooBarFoo(self):
     """
     Test finding foos at the second level.
     """
     xp = XPathQuery("/foo/bar/foo")
     self.assertEquals(xp.matches(self.e), 1)
     self.assertEquals(xp.queryForNodes(self.e), [self.subfoo, self.subfoo3, self.subfoo4])

 def test_queryForStringListAnyLocation(self):
     """
     queryforStringList on relative paths returns all their CDATA.
     """
     xp = XPathQuery("//foo")
     self.assertEqual(xp.queryForStringList(self.e),
                       ["somecontent", "somemorecontent"])

 def test_queryForString(self):
     """
     Test for queryForString and queryForStringList.
     """
     xp = XPathQuery("/foo")
     self.assertEquals(xp.queryForString(self.e), "somecontent")
     self.assertEquals(xp.queryForStringList(self.e), ["somecontent", "somemorecontent"])

 def test_position(self):
     """
     Test finding element at position.
     """
     xp = XPathQuery("/foo/bar[2]")
     self.assertEqual(xp.matches(self.e), 1)
     self.assertEqual(xp.queryForNodes(self.e), [self.bar1])

 def test_locationAllChilds(self):
     """
     Test finding childs of foo.
     """
     xp = XPathQuery("/foo/*")
     self.assertEquals(xp.matches(self.e), True)
     self.assertEquals(xp.queryForNodes(self.e), [self.bar1, self.bar2, self.bar4, self.bar5, self.bar6, self.bar7])

 def test_textConditionUnicode(self):
     """
     A node can be matched by text with non-ascii code points.
     """
     xp = XPathQuery(u"//*[text()='\N{SNOWMAN}']")
     self.assertEqual(xp.matches(self.e), True)
     self.assertEqual(xp.queryForNodes(self.e), [self.quux])

 def test_andOperator(self):
     """
     Test boolean and operator in condition.
     """
     xp = XPathQuery("//bar[@attrib4='value4' and @attrib5='value5']")
     self.assertEqual(xp.matches(self.e), True)
     self.assertEqual(xp.queryForNodes(self.e), [self.bar5])

 def test_locationWithValueUnicode(self):
     """
     Nodes' attributes can be matched with non-ASCII values.
     """
     xp = XPathQuery(u"/foo/*[@attrib6='á']")
     self.assertEqual(xp.matches(self.e), True)
     self.assertEqual(xp.queryForNodes(self.e), [self.bar7])

 def test_anyLocationAndText(self):
     """
     Test finding any nodes named gar and getting their text contents.
     """
     xp = XPathQuery("//gar")
     self.assertEquals(xp.matches(self.e), True)
     self.assertEquals(xp.queryForNodes(self.e), [self.gar1, self.gar2, self.gar3, self.gar4])
     self.assertEquals(xp.queryForStringList(self.e), ["DEF", "ABC", "JKL", "MNO"])

 def test_booleanOperatorsParens(self):
     """
     Test multiple boolean operators in condition with parens.
     """
     xp = XPathQuery("""//bar[@attrib4='value4' and
                              (@attrib5='value4' or @attrib5='value6')]""")
     self.assertEqual(xp.matches(self.e), True)
     self.assertEqual(xp.queryForNodes(self.e), [self.bar6, self.bar7])

 def test_queryForNodes(self):
     """
     Test finding nodes.
     """
     xp = XPathQuery("/foo/bar")
     self.assertEqual(xp.queryForNodes(self.e), [self.bar1, self.bar2,
                                                  self.bar4, self.bar5,
                                                  self.bar6, self.bar7])

 def test_anyLocation(self):
     """
     Test finding any nodes named bar.
     """
     xp = XPathQuery("//bar")
     self.assertEquals(xp.matches(self.e), True)
     self.assertEquals(
         xp.queryForNodes(self.e), [self.bar1, self.bar2, self.bar3, self.bar4, self.bar5, self.bar6, self.bar7]
     )

 def test_textNotOperator(self):
     """
     Test for not operator.
     """
     xp = XPathQuery("/foo[not(@nosuchattrib)]")
     self.assertEqual(xp.matches(self.e), True)

 def test_textCondition(self):
     """
     Test matching a node with given text.
     """
     xp = XPathQuery("/foo[text() = 'somecontent']")
     self.assertEqual(xp.matches(self.e), True)

 def test_attributeWithValue(self):
     """
     Test matching node with attribute having value.
     """
     xp = XPathQuery("/foo[@attrib1='value1']")
     self.assertEqual(xp.matches(self.e), 1)

 def test_namespaceNotFound(self):
     """
     Test not matching node with wrong namespace.
     """
     xp = XPathQuery("/foo[@xmlns='badns']/bar2")
     self.assertEqual(xp.matches(self.e), 0)

 def test_namespaceFound(self):
     """
     Test matching node with namespace.
     """
     xp = XPathQuery("/foo[@xmlns='testns']/bar")
     self.assertEqual(xp.matches(self.e), 1)

 def test_locationNoBar3(self):
     """
     Test not finding bar3.
     """
     xp = XPathQuery("/foo/bar3")
     self.assertEqual(xp.matches(self.e), 0)