AbsDeploymentTest.java

package org.objectweb.jonas_lib.deployment.tests;

// java
import java.io.Reader;
import java.io.StringReader;
import java.io.File;
import java.io.FileReader;
import java.lang.reflect.Method;
import java.util.Hashtable;
import java.util.StringTokenizer;
import javax.xml.namespace.QName;

// jonas
import org.objectweb.jonas_lib.deployment.api.DeploymentDescException;
import org.objectweb.jonas_lib.deployment.xml.AbsElement;
import org.objectweb.jonas_lib.deployment.xml.Element;
import org.objectweb.jonas_lib.deployment.xml.Qname;

public abstract class AbsDeploymentTest {

    private Hashtable elementsCounter = null;

    protected AbsDeploymentTest() {
        elementsCounter = new Hashtable();
    }

    public void stress() throws Exception {

        startTest(false);

        for (int i = 0; i < 100; i++) {
            startTest(true);
        }
    }

    // Abstract Methods used by startTest implemented in subclasses

    public abstract AbsElement getTopLevelElement() throws Exception;

    public abstract String parse(Reader reader, String name, boolean validation) throws Exception;

    public void startTest(boolean random) throws Exception {
        AbsElement ae = getTopLevelElement();
        fill(ae, random);
        String xmlOriginal = ae.toXML();
        String xmlParsed = parse(new StringReader(xmlOriginal), "test", false);
        checkDiff(xmlOriginal, xmlParsed);

    }

    public void parseElement() throws Exception {
        AbsElement ae = getTopLevelElement();
        fill(ae, false);
        System.out.println("Parsing xml :");
        System.out.println(ae);
        String xmlOriginal = ae.toXML();
        String xmlParsed = parse(new StringReader(xmlOriginal), "test", false);
        System.out.println("Result = ");
        System.out.println(xmlParsed);
    }

    public void parseXmlfromFile(String fileName) throws Exception {
        FileReader fileReader = null;

        // Check if the file exists.
        if (!new File(fileName).exists()) {
            throw new DeploymentDescException("The file '" + fileName + "' was not found.");
        }
        fileReader = new FileReader(fileName);
        System.out.println("Parsing xml : " + fileName);
        String xmlParsed = parse(fileReader, fileName, true);
        System.out.println("Parsing OK Result = ");
        System.out.println(xmlParsed);
    }

    protected void checkDiff(String xmlOriginal, String xmlParsed) throws Exception {
        StringTokenizer stOri = new StringTokenizer(xmlOriginal, "\n");
        StringTokenizer stPardsed = new StringTokenizer(xmlParsed, "\n");

        // Compare line by line
        while (stOri.hasMoreTokens() && stPardsed.hasMoreTokens()) {
            String lineOri = stOri.nextToken();
            String lineparsed = stPardsed.nextToken();
            if (!lineOri.equals(lineparsed)) {
                System.err.println("Failure in xml :");
                System.err.println(xmlOriginal);
                throw new Exception("Line : " + lineOri + " is different than parsed value: " + lineparsed);
            }
        }
    }

    public void fill(Element element, boolean random) throws Exception {

        // Get setters of the element
        Method[] methods = element.getClass().getMethods();

        // Analyze if it is Set or Add Method
        for (int i = 0; i < methods.length; i++) {
            // Get name
            Method method = methods[i];
            String name = method.getName();
            Class[] argsMethod = null;
            argsMethod = method.getParameterTypes();

            // One argument method
            if ((argsMethod.length == 1) && (name.startsWith("set") || name.startsWith("add"))) {
                Class cl = argsMethod[0];
                if (cl.getName().equals("java.lang.String")) {
                    // Test if it's one argument with String type :
                    fillString(element, method, random);
                } else if (cl.getName().equals("javax.xml.namespace.QName")) {
                    fillQName(element, method, random);
                } else {
                    // It's a subelement
                    if (name.startsWith("set")) {
                        setElement(element, method, argsMethod, random);
                    } else {
                        addElement(element, method, argsMethod, random);
                    }
                }
            }

        }

    }

    protected boolean aleatOK() {
        return (Math.random() > 0.5);
    }

    protected int nbAleat() {
        return (int) (Math.random() * 5);
    }

    protected void addElement(Element element, Method method, Class[] argsMethod, boolean random) throws Exception {
        int nb = 1;
        if (random) {
            nb = nbAleat();
        }
        for (int i = 0; i < nb; i++) {
            setElement(element, method, argsMethod, random);
        }
    }

    protected void setElement(Element element, Method method, Class[] argsMethod, boolean random) throws Exception {
        if (random && !aleatOK()) {
            return;
        }

        String name = method.getName();

        Class cl = argsMethod[0];
        String className = cl.getName();

        // Element object ?
        if (Element.class.isAssignableFrom(cl)) {
            // Create required object
            Object subElement = cl.newInstance();

            // Add object on top level object
            method.invoke(element, new Object[] {subElement});

            // Fill values of this element
            fill((Element) subElement, random);

            // Qname is a particular type, need to set the name
            if (cl.isAssignableFrom(Qname.class)) {
                // Transform name into Qname
                String qNameElement = convertUpperCaseToXml(name.substring(3, name.length()));
                ((Qname) subElement).setName(qNameElement);
            }

        }
    }

    protected void fillString(Element element, Method method, boolean random) throws Exception {
        if (random && !aleatOK()) {
            return;
        }
        method.invoke(element, (Object[]) new String[] {getNameCounterForElement(element, method)});
    }

    protected void fillQName(Element element, Method method, boolean random) throws Exception {
        if (random && !aleatOK()) {
            return;
        }
        QName qName = new QName("prefix:Test", getNameCounterForElement(element, method));
        method.invoke(element, (Object[]) new QName[] {qName});
    }

    protected String getNameCounterForElement(Element element, Method method) {
        StringBuffer sb = new StringBuffer();

        // Extract package.classname
        String name = method.getName().substring(3, method.getName().length());
        String packageClassname = element.getClass().getPackage().getName();
        String fullClass = packageClassname + "." + name;

        // Existing counter ?
        Integer counter = (Integer) elementsCounter.get(fullClass);
        if (counter == null) {
            // init counter as it don't already exist
            counter = new Integer(0);
        } else {
            // Increment
            counter = new Integer(counter.intValue() + 1);
        }
        elementsCounter.put(fullClass, counter);

        // return value
        return name + counter.intValue();
    }

    protected String convertUpperCaseToXml(String name) {
        StringBuffer sb = new StringBuffer();
        sb.append(Character.toLowerCase(name.charAt(0)));

        for (int i = 1; i < name.length(); i++) {
            if (Character.isUpperCase(name.charAt(i))) {
                sb.append("-");
            }
            sb.append(Character.toLowerCase(name.charAt(i)));

        }
        return sb.toString();

    }

}

---