Python doctestcompare.LXMLOutputChecker類代碼示例

 def assertXmlEqual(self, want, got):
     checker = LXMLOutputChecker()
     if not checker.check_output(want, got, 0):
         message = checker.output_difference(Example("", want), got, 0)
         for line in difflib.unified_diff(want.splitlines(1), got.splitlines(1), fromfile='want.xml', tofile='got.xml'):
             print line
         raise AssertionError(message)

	def test_encodeEntities(self):
		doc = xtree('testdata/test_data.xml')
		doc.parse(False)
		r = xtree('testdata/r_test_encode.xml')
		r.parse(False)
		checker = LXMLOutputChecker()
		self.assertTrue(checker.compare_docs(r.tree.getroot(),doc.tree.getroot()))

def assert_xml_equal(got, want):
    got = lxml.html.tostring(got)
    want = lxml.html.tostring(want)
    checker = LXMLOutputChecker()
    if not checker.check_output(want, got, 0):
        message = checker.output_difference(Example("", want), got, 0)
        raise AssertionError(message)

def assertXmlEqual(result, expect):
    from doctest import Example
    from lxml.doctestcompare import LXMLOutputChecker
    checker = LXMLOutputChecker()
    if not checker.check_output(expect, result, 0):
        message = checker.output_difference(Example("", expect), result, 0)
        raise AssertionError(message)

    def assertXmlEqual(self, got, want):
        """ fail if the two objects are not equal XML serializations
        In case of a failure, both serializations are pretty printed
        with differences marked.
        There is not check well-formedness or against any schema, only
        slightly intelligent matching of the tested string to the reference
        string.

        '...' can be used as a wildcard instead of nodes or attribute values.

        Wildcard Examples:
            <foo>...</foo>
            <foo bar="..." />

        Arguments:
            got -- string to check, as unicode string
            want -- reference string, as unicode string

        Usage Example:
            self.assertXmlEqual(etree.tounicode(...), reference)
        """
        checker = LXMLOutputChecker()
        if not checker.check_output(want, got, 0):
            message = checker.output_difference(Example("", want), got, 0)
            raise AssertionError(message)

 def assertXmlEqual(self, want, got):
     # snippet from http://stackoverflow.com/questions/321795/comparing-xml-in-a-unit-test-in-python/7060342#7060342
     checker = LXMLOutputChecker()
     if not checker.check_output(want, got, 0):
         message = "XML mismatch\n\n"
         for line in difflib.unified_diff(want.splitlines(1), got.splitlines(1), fromfile='want.xml', tofile='got.xml'):
             message += line + '\n'
         raise AssertionError(message)

def assert_xml_equal(got, want):
    assert want is not None, 'Wanted XML cannot be None'
    if got is None:
        raise AssertionError('Got input to validate was None')
    checker = LXMLOutputChecker()
    if not checker.check_output(want, got, 0):
        message = checker.output_difference(Example("", want), got, 0)
        raise AssertionError(message)

    def assertXmlEqual(self, got, want):
        from lxml.doctestcompare import LXMLOutputChecker
        from doctest import Example

        checker = LXMLOutputChecker()
        if checker.check_output(want, got, 0):
            return
        message = checker.output_difference(Example("", want), got, 0)
        raise AssertionError(message)

	def test_insertPIBefore(self):  
		doc = xtree('testdata/test_wrap.xml')
		doc.parse(False)
		for text in doc.tree.xpath('//text'):
			pi = etree.ProcessingInstruction('PI', 'Pb')
			doc.insert_node(text,'stuff',pi,True)
		r = xtree('testdata/r_test_insertPIBefore.xml')
		r.parse(False)
		checker = LXMLOutputChecker()
		self.assertTrue(checker.compare_docs(r.tree.getroot(),doc.tree.getroot()))

    def assertXmlFilesEqual(self, result_filename, expected_filename):
        with open(result_filename) as rf:
            got = rf.read()
        with open(expected_filename) as ef:
            want = ef.read()

        checker = LXMLOutputChecker()
        if not checker.check_output(want, got, 0):
            message = checker.output_difference(Example("", got), want, 0)
            raise AssertionError(message)

    def assertXmlEquivalent(self, got, expect):
        """Asserts both xml parse to the same results
        `got` may be an XML string or lxml Element
        """
        checker = LXMLOutputChecker()

        if isinstance(got, etree._Element):
            got = etree.tostring(got)

        if not checker.check_output(expect, got, PARSE_XML):
            message = checker.output_difference(doctest.Example("", expect), got, PARSE_XML)
            self.fail(message)

	def test_wrap(self):  
		doc = xtree('testdata/test_wrap.xml')
		doc.parse(False)
		if not doc.is_valid:
			if not doc.errors is None: print(doc.errors)
		for text in doc.tree.xpath('//text'):
			el = etree.Element('EL')
			el.set('atr', 'test')
			doc.wrap_text(text,'text',el)
		r = xtree('testdata/r_test_wrap.xml')
		r.parse(False)
		checker = LXMLOutputChecker()
		self.assertTrue(checker.compare_docs(r.tree.getroot(),doc.tree.getroot()))

def assertEqualXML(test, expected):
    output_checker = LXMLOutputChecker()
    if not output_checker.check_output(expected, test, PARSE_XML):
        diff = output_checker.output_difference(Example("", expected), test, PARSE_XML)
        msg = diff
        for line in diff.split("\n"):
            if msg == diff:
                msg = msg + "\nDiff summary:\n"
            if "got:" in line or line.strip().startswith(('+', '-')):
                msg = msg + line + "\n"
        if msg == "":
            msg = diff
        raise AssertionError(msg)

def compare_xml(generated, expected):
    """Use doctest checking from lxml for comparing XML trees. Returns diff if the two are not the same"""
    checker = LXMLOutputChecker()

    class DummyDocTest():
        pass

    ob = DummyDocTest()
    ob.want = generated

    check = checker.check_output(expected, generated, PARSE_XML)
    if check is False:
        diff = checker.output_difference(ob, expected, PARSE_XML)
        return diff

    def assertXmlEquivalentOutputs(self, data, expected):
        """Asserts both XML outputs are equivalent.

        This assertion use the powerful but dangerous feature of
        LXMLOutputChecker. Powerful because one can compare two XML document
        in their meaning, but dangerous because sometimes there is more to
        check than just a kind of output.

        See LXMLOutputChecker documentation for more information.
        """
        checker = LXMLOutputChecker()

        if not checker.check_output(expected, data, PARSE_XML):
            self.fail("Output are not equivalent:\n" "Given: %s\n" "Expected: %s" % (data, expected))