fop-core/src/main/java/org/apache/fop/tools/TestConverter.java - xmlgraphics-fop - Git at Google

 /*
  * 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.
  */

 /* $Id$ */

 package org.apache.fop.tools;

 import java.io.File;
 import java.io.OutputStream;
 import java.net.URI;
 import java.util.Map;

 import javax.xml.parsers.DocumentBuilder;
 import javax.xml.parsers.DocumentBuilderFactory;

 import org.w3c.dom.Document;
 import org.w3c.dom.Node;
 import org.w3c.dom.NodeList;

 import org.apache.commons.io.IOUtils;
 import org.apache.commons.logging.impl.SimpleLog;

 import org.apache.fop.apps.FOUserAgent;
 import org.apache.fop.apps.FopFactory;
 import org.apache.fop.apps.MimeConstants;
 import org.apache.fop.cli.InputHandler;
 import org.apache.fop.tools.anttasks.FileCompare;

 /**
  * TestConverter is used to process a set of tests specified in
  * a testsuite.
  * This class retrieves the data in the testsuite and uses FOP
  * to convert the xml and xsl file into either an xml representation
  * of the area tree or a pdf document.
  * The area tree can be used for automatic comparisons between different
  * versions of FOP or the pdf can be view for manual checking and
  * pdf rendering.
  */
 public class TestConverter {

     private boolean failOnly;
     private String outputFormat = MimeConstants.MIME_FOP_AREA_TREE;
     private File destdir;
     private File compare;
     private String baseDir = "./";
     private Map differ = new java.util.HashMap();

     /**
      * logging instance
      */
     protected SimpleLog logger;

     /**
      * This main method can be used to run the test converter from
      * the command line.
      * This will take a specified testsuite xml and process all
      * tests in it.
      * The command line options are:
      * -b to set the base directory for where the testsuite and associated files are
      * -failOnly to process only the tests which are specified as fail in the test results
      * -pdf to output the result as pdf
      * @param args command-line arguments
      */
     public static void main(String[] args) {
         if (args == null || args.length == 0) {
             System.out.println("test suite file name required");
             return;
         }
         TestConverter tc = new TestConverter();

         String results = "results";
         String testFile = null;
         for (int count = 0; count < args.length; count++) {
             if (args[count].equals("-failOnly")) {
                 tc.setFailOnly(true);
             } else if (args[count].equals("-pdf")) {
                 tc.setOutputFormat(MimeConstants.MIME_PDF);
             } else if (args[count].equals("-rtf")) {
                 tc.setOutputFormat(MimeConstants.MIME_RTF);
             } else if (args[count].equals("-ps")) {
                 tc.setOutputFormat(MimeConstants.MIME_POSTSCRIPT);
             } else if (args[count].equals("-d")) {
                 tc.setDebug(true);
             } else if (args[count].equals("-b")) {
                 tc.setBaseDir(args[++count]);
             } else if (args[count].equals("-results")) {
                 results = args[++count];
             } else {
                 testFile = args[count];
             }
         }
         if (testFile == null) {
             System.out.println("test suite file name required");
         }

         tc.runTests(testFile, results, null);
     }

     /**
      * Construct a new TestConverter
      */
     public TestConverter() {
         logger = new SimpleLog("FOP/Test");
         logger.setLevel(SimpleLog.LOG_LEVEL_ERROR);
     }

     /**
      * Controls output format to generate
      * @param outputFormat the MIME type of the output format
      */
     public void setOutputFormat(String outputFormat) {
         this.outputFormat = outputFormat;
     }

     /**
      * Controls whether to process only the tests which are specified as fail
      * in the test results.
      * @param fail True if only fail tests should be processed
      */
     public void setFailOnly(boolean fail) {
         failOnly = fail;
     }

     /**
      * Sets the base directory.
      * @param str base directory
      */
     public void setBaseDir(String str) {
         baseDir = str;
     }

     /**
      * Controls whether to set logging to debug level
      * @param debug If true, debug level, if false, error level
      */
     public void setDebug(boolean debug) {
         if (debug) {
             logger.setLevel(SimpleLog.LOG_LEVEL_DEBUG);
         } else {
             logger.setLevel(SimpleLog.LOG_LEVEL_ERROR);
         }
     }

     /**
      * Run the Tests.
      * This runs the tests specified in the xml file fname.
      * The document is read as a dom and each testcase is covered.
      * @param fname filename of the input file
      * @param dest destination directory
      * @param compDir comparison directory
      * @return Map a Map containing differences
      */
     public Map runTests(String fname, String dest, String compDir) {
         logger.debug("running tests in file:" + fname);
         try {
             if (compDir != null) {
                 compare = new File(baseDir + "/" + compDir);
             }
             destdir = new File(baseDir + "/" + dest);
             destdir.mkdirs();
             File f = new File(baseDir + "/" + fname);
             DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
             DocumentBuilder db = factory.newDocumentBuilder();
             Document doc = db.parse(f);

             NodeList suitelist = doc.getChildNodes();
             if (suitelist.getLength() == 0) {
                 return differ;
             }

             Node testsuite = null;
             testsuite = doc.getDocumentElement();

             if (testsuite.hasAttributes()) {
                 String profile
                     = testsuite.getAttributes().getNamedItem("profile").getNodeValue();
                 logger.debug("testing test suite:" + profile);
             }

             NodeList testcases = testsuite.getChildNodes();
             for (int count = 0; count < testcases.getLength(); count++) {
                 Node testcase = testcases.item(count);
                 if (testcase.getNodeName().equals("testcases")) {
                     runTestCase(testcase);
                 }
             }
         } catch (Exception e) {
             logger.error("Error while running tests", e);
         }
         return differ;
     }

     /**
      * Run a test case.
      * This goes through a test case in the document.
      * A testcase can contain a test, a result or more test cases.
      * A test case is handled recursively otherwise the test is run.
      * @param tcase Test case node to run
      */
     protected void runTestCase(Node tcase) {
         if (tcase.hasAttributes()) {
             String profile
                 = tcase.getAttributes().getNamedItem("profile").getNodeValue();
             logger.debug("testing profile:" + profile);
         }

         NodeList cases = tcase.getChildNodes();
         for (int count = 0; count < cases.getLength(); count++) {
             Node node = cases.item(count);
             String nodename = node.getNodeName();
             if (nodename.equals("testcases")) {
                 runTestCase(node);
             } else if (nodename.equals("test")) {
                 runTest(tcase, node);
             } /* else if (nodename.equals("result")) {
                 //nop
             } */

         }

     }

     /**
      * Run a particular test.
      * This runs a test defined by the xml and xsl documents.
      * If the test has a result specified it is checked.
      * This creates an XSLTInputHandler to provide the input
      * for FOP and writes the data out to an XML are tree.
      * @param testcase Test case to run
      * @param test Test
      */
     protected void runTest(Node testcase, Node test) {
         String id = test.getAttributes().getNamedItem("id").getNodeValue();
         Node result = locateResult(testcase, id);
         boolean pass = false;
         if (result != null) {
             String agreement
                 = result.getAttributes().getNamedItem("agreement").getNodeValue();
             pass = agreement.equals("full");
         }

         if (pass && failOnly) {
             return;
         }

         String xml = test.getAttributes().getNamedItem("xml").getNodeValue();
         Node xslNode = test.getAttributes().getNamedItem("xsl");
         String xsl = null;
         if (xslNode != null) {
             xsl = xslNode.getNodeValue();
         }
         logger.debug("converting xml:" + xml + " and xsl:"
                   + xsl + " to area tree");

         String res = xml;
         Node resNode =  test.getAttributes().getNamedItem("results");
         if (resNode != null) {
             res = resNode.getNodeValue();
         }
         try {
             File xmlFile = new File(baseDir + "/" + xml);
             URI baseUri = xmlFile.getParentFile().toURI();

             InputHandler inputHandler = null;
             if (xsl == null) {
                 inputHandler = new InputHandler(xmlFile);
             } else {
                 inputHandler = new InputHandler(xmlFile, new File(baseDir + "/" + xsl), null);
             }

             FopFactory fopFactory = FopFactory.newInstance(baseUri);
             FOUserAgent userAgent = fopFactory.newFOUserAgent();

             userAgent.getRendererOptions().put("fineDetail", false);
             userAgent.getRendererOptions().put("consistentOutput", true);
             userAgent.setProducer("Testsuite Converter");

             String outname = res;
             if (outname.endsWith(".xml") || outname.endsWith(".pdf")) {
                 outname = outname.substring(0, outname.length() - 4);
             }
             File outputFile = new File(destdir,
                                        outname + makeResultExtension());

             outputFile.getParentFile().mkdirs();
             OutputStream outStream = null;
             try {
                 outStream = new java.io.BufferedOutputStream(
                     new java.io.FileOutputStream(outputFile));
                 logger.debug("ddir:" + destdir + " on:" + outputFile.getName());
                 inputHandler.renderTo(userAgent, outputFormat, outStream);
             } finally {
                 IOUtils.closeQuietly(outStream);
             }

             // check difference
             if (compare != null) {
                 File f1 = new File(destdir, outname + ".at.xml");
                 File f2 = new File(compare, outname + ".at.xml");
                 if (!compareFiles(f1, f2)) {
                     differ.put(outname + ".at.xml", pass);
                 }
             }
         } catch (Exception e) {
             logger.error("Error while running tests", e);
         }
     }

     /**
      * Return a suitable file extension for the output format.
      */
     private String makeResultExtension() {
         if (MimeConstants.MIME_PDF.equals(outputFormat)) {
            return ".pdf";
         } else if (MimeConstants.MIME_RTF.equals(outputFormat)) {
            return ".rtf";
         } else if (MimeConstants.MIME_POSTSCRIPT.equals(outputFormat)) {
            return ".ps";
         } else {
             return ".at.xml";
         }
     }

     /**
      * Compare files.
      * @param f1 first file
      * @param f2 second file
      * @return true if equal
      */
     protected boolean compareFiles(File f1, File f2) {
         try {
             return FileCompare.compareFiles(f1, f2);
         } catch (Exception e) {
             logger.error("Error while comparing files", e);
             return false;
         }
     }

     private Node locateResult(Node testcase, String id) {
         NodeList cases = testcase.getChildNodes();
         for (int count = 0; count < cases.getLength(); count++) {
             Node node = cases.item(count);
             String nodename = node.getNodeName();
             if (nodename.equals("result")) {
                 String resultid
                     = node.getAttributes().getNamedItem("id").getNodeValue();
                 if (id.equals(resultid)) {
                     return node;
                 }
             }
         }
         return null;
     }

 }
	/*
	* 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.
	*/

	/* $Id$ */

	package org.apache.fop.tools;

	import java.io.File;
	import java.io.OutputStream;
	import java.net.URI;
	import java.util.Map;

	import javax.xml.parsers.DocumentBuilder;
	import javax.xml.parsers.DocumentBuilderFactory;

	import org.w3c.dom.Document;
	import org.w3c.dom.Node;
	import org.w3c.dom.NodeList;

	import org.apache.commons.io.IOUtils;
	import org.apache.commons.logging.impl.SimpleLog;

	import org.apache.fop.apps.FOUserAgent;
	import org.apache.fop.apps.FopFactory;
	import org.apache.fop.apps.MimeConstants;
	import org.apache.fop.cli.InputHandler;
	import org.apache.fop.tools.anttasks.FileCompare;

	/**
	* TestConverter is used to process a set of tests specified in
	* a testsuite.
	* This class retrieves the data in the testsuite and uses FOP
	* to convert the xml and xsl file into either an xml representation
	* of the area tree or a pdf document.
	* The area tree can be used for automatic comparisons between different
	* versions of FOP or the pdf can be view for manual checking and
	* pdf rendering.
	*/
	public class TestConverter {

	private boolean failOnly;
	private String outputFormat = MimeConstants.MIME_FOP_AREA_TREE;
	private File destdir;
	private File compare;
	private String baseDir = "./";
	private Map differ = new java.util.HashMap();

	/**
	* logging instance
	*/
	protected SimpleLog logger;

	/**
	* This main method can be used to run the test converter from
	* the command line.
	* This will take a specified testsuite xml and process all
	* tests in it.
	* The command line options are:
	* -b to set the base directory for where the testsuite and associated files are
	* -failOnly to process only the tests which are specified as fail in the test results
	* -pdf to output the result as pdf
	* @param args command-line arguments
	*/
	public static void main(String[] args) {
	if (args == null \|\| args.length == 0) {
	System.out.println("test suite file name required");
	return;
	}
	TestConverter tc = new TestConverter();

	String results = "results";
	String testFile = null;
	for (int count = 0; count < args.length; count++) {
	if (args[count].equals("-failOnly")) {
	tc.setFailOnly(true);
	} else if (args[count].equals("-pdf")) {
	tc.setOutputFormat(MimeConstants.MIME_PDF);
	} else if (args[count].equals("-rtf")) {
	tc.setOutputFormat(MimeConstants.MIME_RTF);
	} else if (args[count].equals("-ps")) {
	tc.setOutputFormat(MimeConstants.MIME_POSTSCRIPT);
	} else if (args[count].equals("-d")) {
	tc.setDebug(true);
	} else if (args[count].equals("-b")) {
	tc.setBaseDir(args[++count]);
	} else if (args[count].equals("-results")) {
	results = args[++count];
	} else {
	testFile = args[count];
	}
	}
	if (testFile == null) {
	System.out.println("test suite file name required");
	}

	tc.runTests(testFile, results, null);
	}

	/**
	* Construct a new TestConverter
	*/
	public TestConverter() {
	logger = new SimpleLog("FOP/Test");
	logger.setLevel(SimpleLog.LOG_LEVEL_ERROR);
	}

	/**
	* Controls output format to generate
	* @param outputFormat the MIME type of the output format
	*/
	public void setOutputFormat(String outputFormat) {
	this.outputFormat = outputFormat;
	}

	/**
	* Controls whether to process only the tests which are specified as fail
	* in the test results.
	* @param fail True if only fail tests should be processed
	*/
	public void setFailOnly(boolean fail) {
	failOnly = fail;
	}

	/**
	* Sets the base directory.
	* @param str base directory
	*/
	public void setBaseDir(String str) {
	baseDir = str;
	}

	/**
	* Controls whether to set logging to debug level
	* @param debug If true, debug level, if false, error level
	*/
	public void setDebug(boolean debug) {
	if (debug) {
	logger.setLevel(SimpleLog.LOG_LEVEL_DEBUG);
	} else {
	logger.setLevel(SimpleLog.LOG_LEVEL_ERROR);
	}
	}

	/**
	* Run the Tests.
	* This runs the tests specified in the xml file fname.
	* The document is read as a dom and each testcase is covered.
	* @param fname filename of the input file
	* @param dest destination directory
	* @param compDir comparison directory
	* @return Map a Map containing differences
	*/
	public Map runTests(String fname, String dest, String compDir) {
	logger.debug("running tests in file:" + fname);
	try {
	if (compDir != null) {
	compare = new File(baseDir + "/" + compDir);
	}
	destdir = new File(baseDir + "/" + dest);
	destdir.mkdirs();
	File f = new File(baseDir + "/" + fname);
	DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
	DocumentBuilder db = factory.newDocumentBuilder();
	Document doc = db.parse(f);

	NodeList suitelist = doc.getChildNodes();
	if (suitelist.getLength() == 0) {
	return differ;
	}

	Node testsuite = null;
	testsuite = doc.getDocumentElement();

	if (testsuite.hasAttributes()) {
	String profile
	= testsuite.getAttributes().getNamedItem("profile").getNodeValue();
	logger.debug("testing test suite:" + profile);
	}

	NodeList testcases = testsuite.getChildNodes();
	for (int count = 0; count < testcases.getLength(); count++) {
	Node testcase = testcases.item(count);
	if (testcase.getNodeName().equals("testcases")) {
	runTestCase(testcase);
	}
	}
	} catch (Exception e) {
	logger.error("Error while running tests", e);
	}
	return differ;
	}

	/**
	* Run a test case.
	* This goes through a test case in the document.
	* A testcase can contain a test, a result or more test cases.
	* A test case is handled recursively otherwise the test is run.
	* @param tcase Test case node to run
	*/
	protected void runTestCase(Node tcase) {
	if (tcase.hasAttributes()) {
	String profile
	= tcase.getAttributes().getNamedItem("profile").getNodeValue();
	logger.debug("testing profile:" + profile);
	}

	NodeList cases = tcase.getChildNodes();
	for (int count = 0; count < cases.getLength(); count++) {
	Node node = cases.item(count);
	String nodename = node.getNodeName();
	if (nodename.equals("testcases")) {
	runTestCase(node);
	} else if (nodename.equals("test")) {
	runTest(tcase, node);
	} /* else if (nodename.equals("result")) {
	//nop
	} */

	}

	}

	/**
	* Run a particular test.
	* This runs a test defined by the xml and xsl documents.
	* If the test has a result specified it is checked.
	* This creates an XSLTInputHandler to provide the input
	* for FOP and writes the data out to an XML are tree.
	* @param testcase Test case to run
	* @param test Test
	*/
	protected void runTest(Node testcase, Node test) {
	String id = test.getAttributes().getNamedItem("id").getNodeValue();
	Node result = locateResult(testcase, id);
	boolean pass = false;
	if (result != null) {
	String agreement
	= result.getAttributes().getNamedItem("agreement").getNodeValue();
	pass = agreement.equals("full");
	}

	if (pass && failOnly) {
	return;
	}

	String xml = test.getAttributes().getNamedItem("xml").getNodeValue();
	Node xslNode = test.getAttributes().getNamedItem("xsl");
	String xsl = null;
	if (xslNode != null) {
	xsl = xslNode.getNodeValue();
	}
	logger.debug("converting xml:" + xml + " and xsl:"
	+ xsl + " to area tree");

	String res = xml;
	Node resNode = test.getAttributes().getNamedItem("results");
	if (resNode != null) {
	res = resNode.getNodeValue();
	}
	try {
	File xmlFile = new File(baseDir + "/" + xml);
	URI baseUri = xmlFile.getParentFile().toURI();

	InputHandler inputHandler = null;
	if (xsl == null) {
	inputHandler = new InputHandler(xmlFile);
	} else {
	inputHandler = new InputHandler(xmlFile, new File(baseDir + "/" + xsl), null);
	}

	FopFactory fopFactory = FopFactory.newInstance(baseUri);
	FOUserAgent userAgent = fopFactory.newFOUserAgent();

	userAgent.getRendererOptions().put("fineDetail", false);
	userAgent.getRendererOptions().put("consistentOutput", true);
	userAgent.setProducer("Testsuite Converter");

	String outname = res;
	if (outname.endsWith(".xml") \|\| outname.endsWith(".pdf")) {
	outname = outname.substring(0, outname.length() - 4);
	}
	File outputFile = new File(destdir,
	outname + makeResultExtension());

	outputFile.getParentFile().mkdirs();
	OutputStream outStream = null;
	try {
	outStream = new java.io.BufferedOutputStream(
	new java.io.FileOutputStream(outputFile));
	logger.debug("ddir:" + destdir + " on:" + outputFile.getName());
	inputHandler.renderTo(userAgent, outputFormat, outStream);
	} finally {
	IOUtils.closeQuietly(outStream);
	}

	// check difference
	if (compare != null) {
	File f1 = new File(destdir, outname + ".at.xml");
	File f2 = new File(compare, outname + ".at.xml");
	if (!compareFiles(f1, f2)) {
	differ.put(outname + ".at.xml", pass);
	}
	}
	} catch (Exception e) {
	logger.error("Error while running tests", e);
	}
	}

	/**
	* Return a suitable file extension for the output format.
	*/
	private String makeResultExtension() {
	if (MimeConstants.MIME_PDF.equals(outputFormat)) {
	return ".pdf";
	} else if (MimeConstants.MIME_RTF.equals(outputFormat)) {
	return ".rtf";
	} else if (MimeConstants.MIME_POSTSCRIPT.equals(outputFormat)) {
	return ".ps";
	} else {
	return ".at.xml";
	}
	}

	/**
	* Compare files.
	* @param f1 first file
	* @param f2 second file
	* @return true if equal
	*/
	protected boolean compareFiles(File f1, File f2) {
	try {
	return FileCompare.compareFiles(f1, f2);
	} catch (Exception e) {
	logger.error("Error while comparing files", e);
	return false;
	}
	}

	private Node locateResult(Node testcase, String id) {
	NodeList cases = testcase.getChildNodes();
	for (int count = 0; count < cases.getLength(); count++) {
	Node node = cases.item(count);
	String nodename = node.getNodeName();
	if (nodename.equals("result")) {
	String resultid
	= node.getAttributes().getNamedItem("id").getNodeValue();
	if (id.equals(resultid)) {
	return node;
	}
	}
	}
	return null;
	}

	}