import org.custommonkey.xmlunit.examples.RecursiveElementNameAndTextQualifier; //导入依赖的package包/类
protected void assertModelEqualsFile(String expectedPath) throws Exception {
  File actualFile = tmpFolder.newFile();
  Dmn.writeModelToFile(actualFile, modelInstance);

  File expectedFile = ReflectUtil.getResourceAsFile(expectedPath);

  DocumentBuilderFactory docBuilderFactory = DocumentBuilderFactory.newInstance();
  DocumentBuilder docBuilder = docBuilderFactory.newDocumentBuilder();
  Document actualDocument = docBuilder.parse(actualFile);
  Document expectedDocument = docBuilder.parse(expectedFile);

  Diff diff = new Diff(expectedDocument, actualDocument);
  if (!diff.similar()) {
    diff.overrideElementQualifier(new RecursiveElementNameAndTextQualifier());
    DetailedDiff detailedDiff = new DetailedDiff(diff);
    String failMsg = "XML differs:\n" + detailedDiff.getAllDifferences() + "\n\nActual XML:\n" + Dmn.convertToString(modelInstance);
    fail(failMsg);
  }
}
 

import org.custommonkey.xmlunit.examples.RecursiveElementNameAndTextQualifier; //导入依赖的package包/类
@Test
public void testXmlMarshal() throws Exception {
  final JAXBContext context = JAXBContext.newInstance(cls);
  final Marshaller mr = context.createMarshaller();
  mr.setProperty(Marshaller.JAXB_FRAGMENT, Boolean.TRUE);
  mr.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE);
  XMLUnit.setIgnoreWhitespace(true);
  for (final Map.Entry<T, String> entry : marshalTestData.entrySet()) {
    final T obj = entry.getKey();
    final String xml = entry.getValue();
    final StringWriter writer = new StringWriter();
    mr.marshal(obj, writer);
    final String actual = writer.toString();
    logger.info("Object is:\n{}", obj);
    logger.info("Expected XML is:\n{}", XmlUtils.formatXml(xml));
    logger.info("Actual XML is:\n{}\n", actual);
    final Diff diff = new Diff(xml, actual);
    // we don't care about ordering
    diff.overrideElementQualifier(new RecursiveElementNameAndTextQualifier());
    XMLAssert.assertXMLEqual(diff, true);
  }
}
 

import org.custommonkey.xmlunit.examples.RecursiveElementNameAndTextQualifier; //导入依赖的package包/类
/**
 * Compares two XML files without regard to the order of elements or attributes, and ignoring any element named \"releaseDate\".
 * @return Whether the files are \"similar\"
 */
public static boolean compareXml(File expectedFile, File actualFile) {
	try {
		FileReader expectedFr = new FileReader(expectedFile);
		FileReader actualFr = new FileReader(actualFile);
		Diff diff = new Diff(expectedFr, actualFr);
		// ignore order
		// look at element, id, and weight (weight is a nested element)
		diff.overrideElementQualifier(new RecursiveElementNameAndTextQualifier());
		diff.overrideDifferenceListener(new ElementIgnoringDifferenceListener("releaseDate"));
		final boolean isSimilar = diff.similar();
		if (!isSimilar) printDetailedDiff(diff, System.err);
		expectedFr.close();
		actualFr.close();
		return isSimilar;
	} catch (IOException | SAXException e) {
		throw new RuntimeException(e);
	}
}
 

import org.custommonkey.xmlunit.examples.RecursiveElementNameAndTextQualifier; //导入依赖的package包/类
private static void doAssertXmlEquals(String expectedXml, String actualXml) throws Exception {
    Diff diff = new Diff(expectedXml, actualXml);
    diff.overrideElementQualifier(new RecursiveElementNameAndTextQualifier());
    if (!diff.similar()) {
        fail(String.format("\nExpected the following XML\n" + formatXml(expectedXml) +
                           "\nbut actual XML was\n\n" +
                           formatXml(actualXml)));
    }
}
 

import org.custommonkey.xmlunit.examples.RecursiveElementNameAndTextQualifier; //导入依赖的package包/类
private void assertXMLEqual(String expectedXml, String resultXml) {
    try {
        Diff diff = new Diff(expectedXml, resultXml);
        diff.overrideElementQualifier(new RecursiveElementNameAndTextQualifier());
        XMLAssert.assertXMLEqual(diff, true);
    } catch (Exception e) {
        throw new RuntimeException("XML Assertion failure", e);
    }
}
 

import org.custommonkey.xmlunit.examples.RecursiveElementNameAndTextQualifier; //导入依赖的package包/类
public void assertXMLEqual(String expectedXml, String resultXml) {
    try {
        Diff diff = new Diff(expectedXml, resultXml);
        diff.overrideElementQualifier(new RecursiveElementNameAndTextQualifier());
        XMLAssert.assertXMLEqual(diff, true);
    } catch (Exception e) {
        throw new RuntimeException("XML Assertion failure", e);
    }
}
 

import org.custommonkey.xmlunit.examples.RecursiveElementNameAndTextQualifier; //导入依赖的package包/类
protected void validateQuery(InputStream query, InputStream expectedResults) {
String actualResults = executeQuery(query) ;
XMLUnit.setIgnoreWhitespace(true) ;
Diff resultsDiff ;
try {
    resultsDiff = new Diff(asString(expectedResults), actualResults) ;
} catch (Exception e) {
    throw new RuntimeException("Exception comparing results.", e) ;
}
resultsDiff.overrideElementQualifier(new RecursiveElementNameAndTextQualifier()) ;
assertTrue(resultsDiff.toString(), resultsDiff.similar()) ;
   }
 

import org.custommonkey.xmlunit.examples.RecursiveElementNameAndTextQualifier; //导入依赖的package包/类
public void testCarToXml() throws Exception {
  String xml = beanXmlConverter.convertToXml(car);
  XMLUnit.setIgnoreWhitespace(true);
  Diff diff;
  diff = new Diff(TestModel.Car.DEFAULT_XML, xml);
  diff.overrideElementQualifier(new RecursiveElementNameAndTextQualifier());
  XMLAssert.assertXMLEqual(diff, true);
}
 

import org.custommonkey.xmlunit.examples.RecursiveElementNameAndTextQualifier; //导入依赖的package包/类
public static void assertSimilar(CharSequence expected, CharSequence actual) throws SAXException, IOException {
    Diff diff = new Diff(expected.toString(), actual.toString());
    diff.overrideElementQualifier(new RecursiveElementNameAndTextQualifier());
    assertXMLEqual(diff, true);
}
 

import org.custommonkey.xmlunit.examples.RecursiveElementNameAndTextQualifier; //导入依赖的package包/类
protected void assertXMLEqual(String expected, String result) throws Exception {
    Diff diff = new Diff(expected, result);
    diff.overrideElementQualifier(new RecursiveElementNameAndTextQualifier());
    XMLAssert.assertXMLEqual(diff, true);
}
 

import org.custommonkey.xmlunit.examples.RecursiveElementNameAndTextQualifier; //导入依赖的package包/类
/**
 * Tests that {@link MetadataResource metadata resources} are marshalled to
 * the expected XML format.
 * @throws IOException if the {@link Diff} constructor fails
 * @throws JAXBException if the {@link JAXBContext} or {@link Marshaller} fail
 * @throws SAXException if the {@link Diff} constructor fails
 */
@Test
public void testXmlMarshalling() throws IOException, JAXBException,
  SAXException
{
  // Generate the expected output.
  String expectedXml =
    "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>"
    + "<metadata>"
    + "<keyval><key>1</key><val>one</val></keyval>"
    + "<keyval><key>2</key><val>two</val></keyval>"
    + "<keyval><key>3</key><val>three</val></keyval>"
    + "<keyval><key>4</key><val>a</val><val>b</val><val>c</val></keyval>"
    + "</metadata>";

  // Create a MetadataResource using a Metadata instance.
  Hashtable metadataEntries = new Hashtable<String, Object>();
  metadataEntries.put("1", "one");
  metadataEntries.put("2", "two");
  metadataEntries.put("3", "three");
  List<String> list = new ArrayList<String>();
  list.add("a");
  list.add("b");
  list.add("c");
  metadataEntries.put("4", list);

  Metadata metadata = new Metadata();
  metadata.addMetadata(metadataEntries);
  MetadataResource resource = new MetadataResource(metadata);


  // Set up a JAXB context and marshall the ReferenceResource to XML.
  JAXBContext context = JAXBContext.newInstance(resource.getClass());
  Marshaller marshaller = context.createMarshaller();
  StringWriter writer = new StringWriter();
  marshaller.marshal(resource, writer);

  // Compare the expected and actual outputs.
  XMLUnit.setIgnoreWhitespace(true);
  XMLUnit.setIgnoreComments(true);
  XMLUnit.setIgnoreAttributeOrder(true);
  Diff diff = new Diff(expectedXml, writer.toString());
  diff.overrideElementQualifier(new RecursiveElementNameAndTextQualifier());
  assertTrue("The output XML was different to the expected XML: "
    + diff.toString(), diff.similar());
}