src/test/java/tests/w3c/TestRoundTripXSD.java

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements. See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership. The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License. You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied. See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
package tests.w3c;

import org.apache.ws.commons.schema.XmlSchema;
import org.apache.ws.commons.schema.XmlSchemaCollection;
import org.custommonkey.xmlunit.*;
import org.w3c.dom.Element;

import java.io.*;
import java.lang.reflect.InvocationTargetException;
import java.util.ListIterator;

/**
 * Class to test a single schema by roundtripping it using XMLUnit cmd line parms: arg0 - valid|invalid arg1 -
 * path to xsd file
 */
public class TestRoundTripXSD extends XMLTestCase {

    private static boolean debug;

    static {
        String debugString = System.getProperty("debug");
        debug = debugString == null ? false : debugString.equals("true");
    }

    private File fileToTest = null;

    private boolean valid = false;

    public final static void main(String[] args) {
        junit.textui.TestRunner.run(new TestRoundTripXSD(new File(args[1]), args[0].equals("valid")));
    }

    public TestRoundTripXSD() {
        this(new File(System.getProperty("W3CTestLocation")), System.getProperty("W3CTestValidity")
            .equals("valid"));

    }

    public TestRoundTripXSD(File f, boolean valid) {
        super(basename(f));

        this.fileToTest = f;
        this.valid = valid;
    }

    private static String basename(File f) {
        String path = f.getPath();
        int i = path.lastIndexOf(System.getProperty("file.separator"));
        String retval = path.substring(i + 1);
        return retval;
    }

    protected void runTest() throws Throwable {
        try {
            testRoundTrip();
        } catch (InvocationTargetException e) {
            e.fillInStackTrace();
            throw e.getTargetException();
        } catch (IllegalAccessException e) {
            e.fillInStackTrace();
            throw e;
        }
    }

    public void testRoundTrip() throws Exception {

        XmlSchema schema = null;
        DetailedDiff detaileddiffs = null;

        try {
            if (debug) {
                System.out.println("fileToTest=" + this.fileToTest);
                System.out.println("valid=" + this.valid);
            }
            schema = loadSchema(fileToTest);

            // TODO: if we get here and the input was meant to be invalid perhaps
            // should fail. Depends on whether XmlSchema is doing validation. For
            // now we're ignoring invalid tests.

            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            schema.write(baos);
            Diff diff = new Diff(new FileReader(fileToTest),
                                 new InputStreamReader(new ByteArrayInputStream(baos.toByteArray())));

            detaileddiffs = new DetailedDiff(diff);
            detaileddiffs.overrideDifferenceListener(new SchemaAttrDiff());
            boolean result = detaileddiffs.similar();
            if (!result && debug) {
                printFailureDetail(schema, detaileddiffs);
            }
            assertTrue("Serialized out schema not similar to original", result);
        } catch (Exception e) {
            if (this.valid) {
                if (debug) {
                    printFailureDetail(schema, detaileddiffs);
                }
                throw new Exception(this.fileToTest.getPath(), e);
            }
        }

    }

    public XmlSchema loadSchema(File f) throws Exception {
        XmlSchemaCollection col = new XmlSchemaCollection();
        col.setBaseUri(f.getPath());
        XmlSchema xmlSchema = col.read(new FileReader(f), null);
        return xmlSchema;
    }

    static class SchemaAttrDiff extends IgnoreTextAndAttributeValuesDifferenceListener {

        public int differenceFound(Difference difference) {

            if (difference.getId() == DifferenceConstants.ELEMENT_NUM_ATTRIBUTES.getId()) {
                // control and test have to be elements
                // check if they are schema elements .. they only
                // seem to have the added attributeFormDefault and
                // elementFormDefault attributes
                // so shldnt have more than 2 attributes difference
                Element actualEl = (Element)difference.getControlNodeDetail().getNode();

                if (actualEl.getLocalName().equals("schema")) {

                    int expectedAttrs = Integer.parseInt(difference.getControlNodeDetail().getValue());
                    int actualAttrs = Integer.parseInt(difference.getTestNodeDetail().getValue());
                    if (Math.abs(actualAttrs - expectedAttrs) <= 2) {
                        return RETURN_IGNORE_DIFFERENCE_NODES_SIMILAR;
                    }
                }
            } else if (difference.getId() == DifferenceConstants.ATTR_NAME_NOT_FOUND_ID) {
                // sometimes the serializer throws in a few extra attributes...
                Element actualEl = (Element)difference.getControlNodeDetail().getNode();

                if (actualEl.getLocalName().equals("schema")) {
                    return RETURN_IGNORE_DIFFERENCE_NODES_SIMILAR;
                }
            }

            return super.differenceFound(difference);
        }
    }

    private void printFailureDetail(XmlSchema schema, DetailedDiff detaileddiffs) {
        System.err.println(super.getName() + " failure detail");
        System.err.println("-----");
        schema.write(System.err);
        if (detaileddiffs != null) {
            ListIterator li = detaileddiffs.getAllDifferences().listIterator();

            while (li.hasNext()) {
                System.err.println(li.next());
            }
        }
    }

}