Java XMLUnit.setIgnoreWhitespace方法代码示例

import org.custommonkey.xmlunit.XMLUnit; //导入方法依赖的package包/类
@Override
protected boolean compare(File baselineFile, File comparisonFile) {
    try {
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();

        factory.setNamespaceAware(true);
        factory.setCoalescing(true);
        factory.setIgnoringElementContentWhitespace(true);
        factory.setIgnoringComments(true);

        DocumentBuilder builder = factory.newDocumentBuilder();
        Document baselineXml = builder.parse(baselineFile);
        Document comparisonXml = builder.parse(comparisonFile);

        baselineXml.normalizeDocument();
        comparisonXml.normalizeDocument();

        XMLUnit.setIgnoreAttributeOrder(true);
        XMLUnit.setIgnoreComments(true);
        XMLUnit.setIgnoreWhitespace(true);

        return XMLUnit.compareXML(baselineXml, comparisonXml).similar();
    } catch (SAXException | IOException | ParserConfigurationException e) {
        throw new TransformationUtilityException("An exception happened when comparing the two XML files", e);
    }
}
 

import org.custommonkey.xmlunit.XMLUnit; //导入方法依赖的package包/类
/**
 * Assert that the specified XML file has not semantically changed,
 * although it might be identical to the original one due to format
 * changes, comments not being present, etc
 *
 * @param relativeFilePath relative path to file to be evaluated
 * @throws ParserConfigurationException
 * @throws IOException
 * @throws SAXException
 */
protected void assertEqualsXml(String relativeFilePath) throws ParserConfigurationException, IOException, SAXException {
    File originalFile = new File(appFolder, relativeFilePath);
    File transformedFile = new File(transformedAppFolder, relativeFilePath);

    DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();

    factory.setNamespaceAware(true);
    factory.setCoalescing(true);
    factory.setIgnoringElementContentWhitespace(true);
    factory.setIgnoringComments(true);

    DocumentBuilder builder = factory.newDocumentBuilder();
    Document originalXml = builder.parse(originalFile);
    Document transformedXml = builder.parse(transformedFile);

    originalXml.normalizeDocument();
    transformedXml.normalizeDocument();

    XMLUnit.setIgnoreAttributeOrder(true);
    XMLUnit.setIgnoreComments(true);
    XMLUnit.setIgnoreWhitespace(true);

    Assert.assertTrue(XMLUnit.compareXML(originalXml, transformedXml).similar());
}
 

import org.custommonkey.xmlunit.XMLUnit; //导入方法依赖的package包/类
@Test
public void testCreateElement() throws Exception {
    final Document document = XmlUtil.newDocument();
    final Element top = XmlUtil.createElement(document, "top", Optional.of("namespace"));

    top.appendChild(XmlUtil.createTextElement(document, "innerText", "value", Optional.of("namespace")));
    top.appendChild(XmlUtil.createTextElementWithNamespacedContent(document, "innerPrefixedText", "pref", "prefixNamespace", "value", Optional.of("namespace")));
    top.appendChild(XmlUtil.createTextElementWithNamespacedContent(document, "innerPrefixedText", "pref", "prefixNamespace", "value", Optional.of("randomNamespace")));

    document.appendChild(top);
    assertEquals("top", XmlUtil.createDocumentCopy(document).getDocumentElement().getTagName());

    XMLUnit.setIgnoreAttributeOrder(true);
    XMLUnit.setIgnoreWhitespace(true);

    final Diff diff = XMLUnit.compareXML(XMLUnit.buildControlDocument(xml), document);
    assertTrue(diff.toString(), diff.similar());
}
 

import org.custommonkey.xmlunit.XMLUnit; //导入方法依赖的package包/类
public void testSetEndpoints() throws Exception {
    // Create a new Camel context and add an endpoint
    CamelContextFactoryBean camelContext = new CamelContextFactoryBean();
    List<CamelEndpointFactoryBean> endpoints = new LinkedList<CamelEndpointFactoryBean>();
    CamelEndpointFactoryBean endpoint = new CamelEndpointFactoryBean();
    endpoint.setId("endpoint1");
    endpoint.setUri("mock:end");
    endpoints.add(endpoint);
    camelContext.setEndpoints(endpoints);

    // Compare the new context with our reference context
    Reader expectedContext = null;
    try {
        expectedContext = new InputStreamReader(getClass().getResourceAsStream("/org/apache/camel/spring/context-with-endpoint.xml"));
        String createdContext = contextAsString(camelContext);
        XMLUnit.setIgnoreWhitespace(true);
        XMLAssert.assertXMLEqual(expectedContext, new StringReader(createdContext));
    } finally {
        IOHelper.close(expectedContext);
    }
}
 

import org.custommonkey.xmlunit.XMLUnit; //导入方法依赖的package包/类
@Test
public void writeDeliveryReportResponse() throws Exception {
    DeliveryReportResponse deliveryResponse = new DeliveryReportResponse();
    deliveryResponse.setErrorCode(5);
    deliveryResponse.setErrorMessage("Success");

    StringWriter sw = new StringWriter();
    SxmpWriter.write(sw, deliveryResponse);

    logger.debug(sw.toString());

    StringBuilder expectedXML = new StringBuilder(200)
        .append("<?xml version=\"1.0\"?>\n")
        .append("<operation type=\"deliveryReport\">\n")
        .append(" <deliveryReportResponse>\n")
        .append("   <error code=\"5\" message=\"Success\"/>\n")
        .append(" </deliveryReportResponse>\n")
        .append("</operation>\n")
        .append("");

    // compare to actual correct submit response
    XMLUnit.setIgnoreWhitespace(true);
    Diff myDiff = new Diff(expectedXML.toString(), sw.toString());
    DetailedDiff myDetailedDiff = new DetailedDiff(myDiff);
    Assert.assertTrue("XML are similar " + myDetailedDiff, myDetailedDiff.similar());
}
 

import org.custommonkey.xmlunit.XMLUnit; //导入方法依赖的package包/类
@Test
public void testMarshalAsByteArrayOutputStream()
        throws SimpleMarshallerException, SAXException, IOException {
    // Arrange
    XMLUnit.setIgnoreAttributeOrder(true);
    XMLUnit.setIgnoreComments(true);
    XMLUnit.setIgnoreWhitespace(true);
    final String expectedOutput = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?><ruleExecutionContainer><executionResponseList/></ruleExecutionContainer>";
    final RuleExecutionContainer r = createRuleExecutionContainer();

    // Act
    final ByteArrayOutputStream output = marshaller
            .marshalAsByteArrayOutputStream(r);

    assertNotNull(output);
    assertXMLEqual(expectedOutput, output.toString());
}
 

import org.custommonkey.xmlunit.XMLUnit; //导入方法依赖的package包/类
@Test
public void testCreate() throws Exception {
    SwitchYardModel switchyard = new V1SwitchYardModel(SwitchYardNamespace.V_1_0.uri());
    TransformsModel transforms = new V1TransformsModel(SwitchYardNamespace.V_1_0.uri());
    JavaTransformModel javaTransform = new V1JavaTransformModel(TransformNamespace.V_1_0.uri());
    javaTransform.setFrom(new QName("msgA"));
    javaTransform.setTo(new QName("msgB"));
    javaTransform.setClazz("org.examples.transform.AtoBTransform");
    transforms.addTransform(javaTransform);
    SmooksTransformModel smooksTransform = new V1SmooksTransformModel(TransformNamespace.V_1_0.uri());
    smooksTransform.setFrom(new QName("msgC"));
    smooksTransform.setTo(new QName("msgD"));
    smooksTransform.setTransformType("XML2JAVA");
    smooksTransform.setConfig("/trasnforms/xxx.xml");
    smooksTransform.setReportPath("/tmp/smooksreport.html");
    transforms.addTransform(smooksTransform);
    switchyard.setTransforms(transforms);
    String new_xml = switchyard.toString();
    String old_xml = new ModelPuller<SwitchYardModel>().pull(XML, getClass()).toString();
    XMLUnit.setIgnoreWhitespace(true);
    Diff diff = XMLUnit.compareXML(old_xml, new_xml);
    Assert.assertTrue(diff.toString(), diff.identical());
}
 

import org.custommonkey.xmlunit.XMLUnit; //导入方法依赖的package包/类
@Test
public void testOrders() throws Exception {
    HTTPMixIn httpMixIn = new HTTPMixIn();

    httpMixIn.initialize();
    try {
        XMLUnit.setIgnoreWhitespace(true);
        String port = getSoapClientPort();
        String wsdl = httpMixIn.sendString("http://localhost:" + port + "/quickstart-bean/OrderService?wsdl", "", HTTPMixIn.HTTP_GET);
        XMLAssert.assertXMLEqual(new InputStreamReader(Classes.getResourceAsStream("quickstarts/bean-service/OrderService.wsdl")), new StringReader(wsdl));
        String response = httpMixIn.postString("http://localhost:" + port + "/quickstart-bean/OrderService", SOAP_REQUEST);
        XMLAssert.assertXpathEvaluatesTo("PO-19838-XYZ", "//orderAck/orderId", response);
        XMLAssert.assertXpathEvaluatesTo("true", "//orderAck/accepted", response);
        XMLAssert.assertXpathEvaluatesTo("Order Accepted [intercepted]", "//orderAck/status", response);
    } finally {
        httpMixIn.uninitialize();
    }
}
 

import org.custommonkey.xmlunit.XMLUnit; //导入方法依赖的package包/类
@Before
public void setUp() {
    XMLUnit.setIgnoreWhitespace(true);

    when(viewProvider.get()).thenReturn(view);
    when(childViewProvider.get()).thenReturn(childView);
    when(parserFactory.create()).thenReturn(new LabellingInteractionBeanMockParser(CHILDREN_FULL));
    testObj = new LabellingBuilder(parserFactory, new LabellingViewBuilder(viewProvider, childViewProvider));

    stub(view.getContainer()).toReturn(mock(ForIsWidget.class));
}
 

import org.custommonkey.xmlunit.XMLUnit; //导入方法依赖的package包/类
@Override
public void setUp() throws Exception {
  // Initialise the GATE library and creole register
  Gate.init();

  XMLUnit.setIgnoreComments(true);
  XMLUnit.setIgnoreWhitespace(true);
  XMLUnit.setIgnoreAttributeOrder(true);
}
 

import org.custommonkey.xmlunit.XMLUnit; //导入方法依赖的package包/类
@Then("verify that response is equal to file '$filePath'")
public void verifyThatResponseIsEqualToFile(String filePath) throws SOAPException, IOException, SAXException {
    FileReader expectedResponseXML = new FileReader(getFileFromResourcesByFilePath(filePath));
    SOAPMessage rawSoapResponse = (SOAPMessage) Thucydides.getCurrentSession().get(RESPONSE);
    String cleanResponse = getXmlPayload(rawSoapResponse);
    StringReader actualResponseXML = new StringReader(cleanResponse);
    XMLUnit.setIgnoreWhitespace(true);
    Diff diff = new Diff(expectedResponseXML, actualResponseXML);
    StringBuffer stringBuffer = diff.appendMessage(new StringBuffer());
    assertTrue(stringBuffer.toString(), diff.similar());
}
 

import org.custommonkey.xmlunit.XMLUnit; //导入方法依赖的package包/类
@Override
public void verifyFilesOnEqual(String filePath, File lastDownloadedFile) throws IOException, SAXException, ParserConfigurationException {
    FileReader controlXML = new FileReader(getFileFromResourcesByFilePath(filePath));
    FileReader testXML = new FileReader(lastDownloadedFile);
    XMLUnit.setIgnoreWhitespace(true);
    XMLAssert.assertXMLEqual("THE FILE '" + lastDownloadedFile.getName() + "' DOESN'T CONTAIN EXPECTED VALUE", controlXML, testXML);
}
 

import org.custommonkey.xmlunit.XMLUnit; //导入方法依赖的package包/类
@Then("verify REST-XML response is equal to '$file'")
public void thenXMLResponseEqualToFile(String file) throws IOException, SAXException {
    File fileFromResources = getFileFromResourcesByFilePath(file);
    List<String> expected = Files.readLines(fileFromResources, Charset.defaultCharset());
    String expectedXml = expected.stream()
            .map(StringUtils::chomp)
            .map(StringUtils::strip)
            .collect(Collectors.joining());
    Response response = getVariableValue(KEY);
    String actualXml = response.getBody().asString();
    XMLUnit.setIgnoreWhitespace(true);
    DetailedDiff myDiff = new DetailedDiff(new Diff(expectedXml, actualXml));
    assertThat(myDiff.toString(), actualXml, is(expectedXml));
}
 

import org.custommonkey.xmlunit.XMLUnit; //导入方法依赖的package包/类
public static void assertXMLEquals(String expectedXML, String actualXML) throws Exception {
    XMLUnit.setIgnoreWhitespace(true);
    XMLUnit.setIgnoreDiffBetweenTextAndCDATA(true);
    XMLUnit.setIgnoreAttributeOrder(true);

    DetailedDiff diff = new DetailedDiff(XMLUnit.compareXML(expectedXML, actualXML));

    List<?> allDifferences = diff.getAllDifferences();
    Assert.assertEquals("Differences found: "+ diff.toString(), 0, allDifferences.size());
}
 

import org.custommonkey.xmlunit.XMLUnit; //导入方法依赖的package包/类
@Test
public void writeSubmitRequestWithNationalAndApplication() throws Exception {
    SubmitRequest request = new SubmitRequest();
    request.setAccount(new Account("customer1", "test1"));
    request.setApplication(new Application("TestApp"));
    request.setOperatorId(20);
    request.setSourceAddress(new MobileAddress(MobileAddress.Type.NATIONAL, "0123456789"));
    request.setDestinationAddress(new MobileAddress(MobileAddress.Type.INTERNATIONAL, "+13135551212"));
    request.setText("Hello World");

    StringWriter sw = new StringWriter();
    SxmpWriter.write(sw, request);

    logger.debug(sw.toString());

    StringBuilder expectedXML = new StringBuilder(200)
        .append("<?xml version=\"1.0\"?>\n")
        .append("<operation type=\"submit\">\n")
        .append(" <account username=\"customer1\" password=\"test1\"/>\n")
        .append(" <application>TestApp</application>\n")
        .append(" <submitRequest>\n")
        .append("  <operatorId>20</operatorId>\n")
        .append("  <priority>0</priority>\n")
        .append("  <deliveryReport>false</deliveryReport>\n")
        .append("  <sourceAddress type=\"national\">0123456789</sourceAddress>\n")
        .append("  <destinationAddress type=\"international\">+13135551212</destinationAddress>\n")
        .append("  <text encoding=\"UTF-8\">48656C6C6F20576F726C64</text>\n")
        .append(" </submitRequest>\n")
        .append("</operation>\n")
        .append("");

    // compare to actual correct submit response
    XMLUnit.setIgnoreWhitespace(true);
    Diff myDiff = new Diff(expectedXML.toString(), sw.toString());
    DetailedDiff myDetailedDiff = new DetailedDiff(myDiff);
    Assert.assertTrue("XML are similar " + myDetailedDiff, myDetailedDiff.similar());
}