test/jaxp/javax/xml/jaxp/libs/jaxp/library/JAXPTestUtilities.java - platform/libcore - Git at Google

 /*
  * Copyright (c) 2014, 2017, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  */
 package jaxp.library;

 import static org.testng.Assert.fail;

 import java.io.ByteArrayInputStream;
 import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.StringWriter;
 import java.nio.ByteBuffer;
 import java.nio.ByteOrder;
 import java.nio.charset.Charset;
 import java.nio.charset.StandardCharsets;
 import java.nio.charset.UnsupportedCharsetException;
 import java.nio.file.Files;
 import java.nio.file.Paths;
 import java.security.Permission;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
 import java.util.concurrent.Callable;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.function.Supplier;
 import java.util.regex.Pattern;
 import java.util.stream.Collectors;

 import javax.xml.parsers.DocumentBuilder;
 import javax.xml.parsers.DocumentBuilderFactory;
 import javax.xml.parsers.ParserConfigurationException;
 import javax.xml.transform.Transformer;
 import javax.xml.transform.TransformerException;
 import javax.xml.transform.TransformerFactory;
 import javax.xml.transform.dom.DOMSource;
 import javax.xml.transform.stream.StreamResult;

 import org.w3c.dom.Document;
 import org.w3c.dom.Node;
 import org.xml.sax.SAXException;

 /**
  * This is an interface provide basic support for JAXP functional test.
  */
 public class JAXPTestUtilities {
     /**
      * Prefix for error message.
      */
     public static final String ERROR_MSG_HEADER = "Unexcepted exception thrown:";

     /**
      * Prefix for error message on clean up block.
      */
     public static final String ERROR_MSG_CLEANUP = "Clean up failed on %s";

     /**
      * Force using slash as File separator as we always use cygwin to test in
      * Windows platform.
      */
     public static final String FILE_SEP = "/";

     /**
      * A map storing every test's current test file pointer. File number should
      * be incremental and it's a thread-safe reading on this file number.
      */
     private static final ConcurrentHashMap<Class<?>, Integer> currentFileNumber
                 = new ConcurrentHashMap<>();

     /**
      * BOM table for storing BOM header.
      */
     private final static Map<String, byte[]> bom = new HashMap<>();

     /**
      * Initialize all BOM headers.
      */
     static {
         bom.put("UTF-8", new byte[]{(byte)0xEF, (byte) 0xBB, (byte) 0xBF});
         bom.put("UTF-16BE", new byte[]{(byte)0xFE, (byte)0xFF});
         bom.put("UTF-16LE", new byte[]{(byte)0xFF, (byte)0xFE});
         bom.put("UTF-32BE", new byte[]{(byte)0x00, (byte)0x00, (byte)0xFE, (byte)0xFF});
         bom.put("UTF-32LE", new byte[]{(byte)0xFF, (byte)0xFE, (byte)0x00, (byte)0x00});
     }

     /**
      * Compare contents of golden file with test output file line by line.
      * return true if they're identical.
      * @param goldfile Golden output file name
      * @param outputfile Test output file name
      * @return true if two files are identical.
      *         false if two files are not identical.
      * @throws IOException if an I/O error occurs reading from the file or a
      *         malformed or unmappable byte sequence is read.
      */
     public static boolean compareWithGold(String goldfile, String outputfile)
             throws IOException {
         return compareWithGold(goldfile, outputfile, StandardCharsets.UTF_8);
     }

     /**
      * Compare contents of golden file with test output file line by line.
      * return true if they're identical.
      * @param goldfile Golden output file name.
      * @param outputfile Test output file name.
      * @param cs the charset to use for decoding.
      * @return true if two files are identical.
      *         false if two files are not identical.
      * @throws IOException if an I/O error occurs reading from the file or a
      *         malformed or unmappable byte sequence is read.
      */
     public static boolean compareWithGold(String goldfile, String outputfile,
              Charset cs) throws IOException {
         boolean isSame = Files.readAllLines(Paths.get(goldfile)).
                 equals(Files.readAllLines(Paths.get(outputfile), cs));
         if (!isSame) {
             System.err.println("Golden file " + goldfile + " :");
             Files.readAllLines(Paths.get(goldfile)).forEach(System.err::println);
             System.err.println("Output file " + outputfile + " :");
             Files.readAllLines(Paths.get(outputfile), cs).forEach(System.err::println);
         }
         return isSame;
     }

     /**
      * Compare contents of golden file with test output list line by line.
      * return true if they're identical.
      * @param goldfile Golden output file name.
      * @param lines test output list.
      * @return true if file's content is identical to given list.
      *         false if file's content is not identical to given list.
      * @throws IOException if an I/O error occurs reading from the file or a
      *         malformed or unmappable byte sequence is read
      */
     public static boolean compareLinesWithGold(String goldfile, List<String> lines)
             throws IOException {
         return Files.readAllLines(Paths.get(goldfile)).equals(lines);
     }

     /**
      * Compare contents of golden file with a test output string.
      * return true if they're identical.
      * @param goldfile Golden output file name.
      * @param string test string.
      * @return true if file's content is identical to given string.
      *         false if file's content is not identical to given string.
      * @throws IOException if an I/O error occurs reading from the file or a
      *         malformed or unmappable byte sequence is read
      */
     public static boolean compareStringWithGold(String goldfile, String string)
             throws IOException {
         return Files.readAllLines(Paths.get(goldfile)).stream().collect(
                 Collectors.joining(System.getProperty("line.separator")))
                 .equals(string);
     }

     /**
      * Compare contents of golden file with test output file by their document
      * representation.
      * Here we ignore the white space and comments. return true if they're
      * lexical identical.
      * @param goldfile Golden output file name.
      * @param resultFile Test output file name.
      * @return true if two file's document representation are identical.
      *         false if two file's document representation are not identical.
      * @throws javax.xml.parsers.ParserConfigurationException if the
      *         implementation is not available or cannot be instantiated.
      * @throws SAXException If any parse errors occur.
      * @throws IOException if an I/O error occurs reading from the file or a
      *         malformed or unmappable byte sequence is read .
      */
     public static boolean compareDocumentWithGold(String goldfile, String resultFile)
             throws ParserConfigurationException, SAXException, IOException {
         DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
         factory.setNamespaceAware(true);
         factory.setCoalescing(true);
         factory.setIgnoringElementContentWhitespace(true);
         factory.setIgnoringComments(true);
         DocumentBuilder db = factory.newDocumentBuilder();

         Document goldD = db.parse(Paths.get(goldfile).toFile());
         goldD.normalizeDocument();
         Document resultD = db.parse(Paths.get(resultFile).toFile());
         resultD.normalizeDocument();
         return goldD.isEqualNode(resultD);
     }

     /**
      * Compare contents of golden file with the serialization represent by given
      * DOM node.
      * Here we ignore the white space and comments. return true if they're
      * lexical identical.
      * @param goldfile Golden output file name.
      * @param node A DOM node instance.
      * @return true if file's content is identical to given node's serialization
      *         represent.
      *         false if file's content is not identical to given node's
      *         serialization represent.
      * @throws TransformerException If an unrecoverable error occurs during the
      *         course of the transformation..
      * @throws IOException if an I/O error occurs reading from the file or a
      *         malformed or unmappable byte sequence is read .
      */
     public static boolean compareSerializeDOMWithGold(String goldfile, Node node)
             throws TransformerException, IOException {
         TransformerFactory factory = TransformerFactory.newInstance();
         // Use identity transformer to serialize
         Transformer identityTransformer = factory.newTransformer();
         StringWriter sw = new StringWriter();
         StreamResult streamResult = new StreamResult(sw);
         DOMSource nodeSource = new DOMSource(node);
         identityTransformer.transform(nodeSource, streamResult);
         return compareStringWithGold(goldfile, sw.toString());
     }

     /**
      * Convert stream to ByteArrayInputStream by given character set.
      * @param charset target character set.
      * @param file a file that contains no BOM head content.
      * @return a ByteArrayInputStream contains BOM heads and bytes in original
      *         stream
      * @throws IOException I/O operation failed or unsupported character set.
      */
     public static InputStream bomStream(String charset, String file)
             throws IOException {
         String localCharset = charset;
         if (charset.equals("UTF-16") || charset.equals("UTF-32")) {
             localCharset
                 += ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN ? "BE" : "LE";
         }
         if (!bom.containsKey(localCharset))
             throw new UnsupportedCharsetException("Charset:" + localCharset);

         byte[] content = Files.readAllLines(Paths.get(file)).stream().
                 collect(Collectors.joining()).getBytes(localCharset);
         byte[] head = bom.get(localCharset);
         ByteBuffer bb = ByteBuffer.allocate(content.length + head.length);
         bb.put(head);
         bb.put(content);
         return new ByteArrayInputStream(bb.array());
     }

    /**
      * Worker method to detect common absolute URLs.
      *
      * @param s String path\filename or URL (or any, really)
      * @return true if s starts with a common URI scheme (namely
      * the ones found in the examples of RFC2396); false otherwise
      */
     protected static boolean isCommonURL(String s) {
         if (null == s)
             return false;
         return Pattern.compile("^(file:|http:|ftp:|gopher:|mailto:|news:|telnet:)")
                 .matcher(s).matches();
     }

     /**
      * Utility method to translate a String filename to URL.
      *
      * If the name starts with a common URI scheme (namely the ones
      * found in the examples of RFC2396), then simply return the
      * name as-is (the assumption is that it's already a URL).
      * Otherwise we attempt (cheaply) to convert to a file:/ URL.
      *
      * @param filename local path/filename of a file.
      * @return a file:/ URL if filename represent a file, the same string if
      *         it appears to already be a URL.
      */
     public static String filenameToURL(String filename) {
         return Paths.get(filename).toUri().toASCIIString();
     }

     /**
      * Prints error message if an exception is thrown
      * @param ex The exception is thrown by test.
      */
     public static void failUnexpected(Throwable ex) {
         fail(ERROR_MSG_HEADER, ex);
     }

     /**
      * Prints error message if an exception is thrown when clean up a file.
      * @param ex The exception is thrown in cleaning up a file.
      * @param name Cleaning up file name.
      */
     public static void failCleanup(IOException ex, String name) {
         fail(String.format(ERROR_MSG_CLEANUP, name), ex);
     }

     /**
      * Retrieve next test output file name. This method is a thread-safe method.
      * @param clazz test class.
      * @return next test output file name.
      */
     public static String getNextFile(Class<?> clazz) {
         int nextNumber = currentFileNumber.contains(clazz)
                 ? currentFileNumber.get(clazz) + 1 : 1;
         Integer i = currentFileNumber.putIfAbsent(clazz, nextNumber);
         if (i != null) {
             do {
                 nextNumber = currentFileNumber.get(clazz) + 1;
             } while (!currentFileNumber.replace(clazz, nextNumber - 1, nextNumber));
         }
         return USER_DIR + clazz.getName() + nextNumber + ".out";
     }

     /**
      * Acquire a full path string by given class name and relative path string.
      * @param clazz Class name for the test.
      * @param relativeDir relative path between java source file and expected
      *        path.
      * @return a string represents the full path of accessing path.
      */
     public static String getPathByClassName(Class<?> clazz, String relativeDir) {
         String javaSourcePath = System.getProperty("test.src").replaceAll("\\" + File.separator, FILE_SEP);
         String normalizedPath = Paths.get(javaSourcePath, relativeDir).normalize().
                 toAbsolutePath().toString();
         return normalizedPath.replace("\\", FILE_SEP) + FILE_SEP;
     }


     /**
      * Run the supplier with all permissions. This won't impact global policy.
      *
      * @param s
      *            Supplier to run
      */
     public static <T> T runWithAllPerm(Supplier<T> s) {
         Optional<JAXPPolicyManager> policyManager = Optional.ofNullable(JAXPPolicyManager
                 .getJAXPPolicyManager(false));
         policyManager.ifPresent(manager -> manager.setAllowAll(true));
         try {
             return s.get();
         } finally {
             policyManager.ifPresent(manager -> manager.setAllowAll(false));
         }
     }

     /**
      * Run the supplier with all permissions. This won't impact global policy.
      *
      * @param s
      *            Supplier to run
      */
     public static <T> T tryRunWithAllPerm(Callable<T> c) throws Exception {
         Optional<JAXPPolicyManager> policyManager = Optional.ofNullable(JAXPPolicyManager
                 .getJAXPPolicyManager(false));
         policyManager.ifPresent(manager -> manager.setAllowAll(true));
         try {
             return c.call();
         } finally {
             policyManager.ifPresent(manager -> manager.setAllowAll(false));
         }
     }

     /**
      * Run the Runnable with all permissions. This won't impact global policy.
      *
      * @param s
      *            Supplier to run
      */
     public static void runWithAllPerm(Runnable r) {
         Optional<JAXPPolicyManager> policyManager = Optional.ofNullable(JAXPPolicyManager
                 .getJAXPPolicyManager(false));
         policyManager.ifPresent(manager -> manager.setAllowAll(true));
         try {
             r.run();
         } finally {
             policyManager.ifPresent(manager -> manager.setAllowAll(false));
         }
     }

     /**
      * Acquire a system property.
      *
      * @param name
      *            System property name to be acquired.
      * @return property value
      */
     public static String getSystemProperty(String name) {
         return runWithAllPerm(() -> System.getProperty(name));
     }

     /**
      * Set a system property by given system value.
      *
      * @param name
      *            System property name to be set.
      * @param value
      *            System property value to be set.
      */
     public static void setSystemProperty(String name, String value) {
         runWithAllPerm(() -> System.setProperty(name, value));
     }

     /**
      * Clear a system property.
      *
      * @param name
      *            System property name to be cleared.
      */
     public static void clearSystemProperty(String name) {
         runWithAllPerm(() -> System.clearProperty(name));
     }

     /**
      * Run the runnable with assigning temporary permissions. This won't impact
      * global policy.
      *
      * @param r
      *            Runnable to run
      * @param ps
      *            assigning permissions to add.
      */
     public static void runWithTmpPermission(Runnable r, Permission... ps) {
         JAXPPolicyManager policyManager = JAXPPolicyManager.getJAXPPolicyManager(false);
         List<Integer> tmpPermissionIndexes = new ArrayList<>();
         if (policyManager != null) {
             for (Permission p : ps)
                 tmpPermissionIndexes.add(policyManager.addTmpPermission(p));
         }
         try {
             r.run();
         } finally {
             for (int index: tmpPermissionIndexes)
                 policyManager.removeTmpPermission(index);
         }
     }

     /**
      * Run the supplier with assigning temporary permissions. This won't impact
      * global policy.
      *
      * @param s
      *            Supplier to run
      * @param ps
      *            assigning permissions to add.
      */
     public static <T> T runWithTmpPermission(Supplier<T> s, Permission... ps) {
         JAXPPolicyManager policyManager = JAXPPolicyManager.getJAXPPolicyManager(false);
         List<Integer> tmpPermissionIndexes = new ArrayList<>();
         if (policyManager != null) {
             for (Permission p : ps)
                 tmpPermissionIndexes.add(policyManager.addTmpPermission(p));
         }
         try {
             return s.get();
         } finally {
             for (int index: tmpPermissionIndexes)
                 policyManager.removeTmpPermission(index);
         }
     }

     /**
      * Run the RunnableWithException with assigning temporary permissions. This
      * won't impact global policy.
      *
      * @param r
      *            RunnableWithException to execute
      * @param ps
      *            assigning permissions to add.
      */
     public static void tryRunWithTmpPermission(RunnableWithException r, Permission... ps) throws Exception {
         JAXPPolicyManager policyManager = JAXPPolicyManager.getJAXPPolicyManager(false);
         List<Integer> tmpPermissionIndexes = new ArrayList<>();
         if (policyManager != null) {
             for (Permission p : ps)
                 tmpPermissionIndexes.add(policyManager.addTmpPermission(p));
         }
         try {
             r.run();
         } finally {
             for (int index: tmpPermissionIndexes)
                 policyManager.removeTmpPermission(index);
         }
     }

     @FunctionalInterface
     public interface RunnableWithException {
         void run() throws Exception;
     }

     /**
      * Current test directory.
      */
     public static final String USER_DIR = getSystemProperty("user.dir") + FILE_SEP;;

 }
	/*
	* Copyright (c) 2014, 2017, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/
	package jaxp.library;

	import static org.testng.Assert.fail;

	import java.io.ByteArrayInputStream;
	import java.io.File;
	import java.io.IOException;
	import java.io.InputStream;
	import java.io.StringWriter;
	import java.nio.ByteBuffer;
	import java.nio.ByteOrder;
	import java.nio.charset.Charset;
	import java.nio.charset.StandardCharsets;
	import java.nio.charset.UnsupportedCharsetException;
	import java.nio.file.Files;
	import java.nio.file.Paths;
	import java.security.Permission;
	import java.util.ArrayList;
	import java.util.HashMap;
	import java.util.List;
	import java.util.Map;
	import java.util.Optional;
	import java.util.concurrent.Callable;
	import java.util.concurrent.ConcurrentHashMap;
	import java.util.function.Supplier;
	import java.util.regex.Pattern;
	import java.util.stream.Collectors;

	import javax.xml.parsers.DocumentBuilder;
	import javax.xml.parsers.DocumentBuilderFactory;
	import javax.xml.parsers.ParserConfigurationException;
	import javax.xml.transform.Transformer;
	import javax.xml.transform.TransformerException;
	import javax.xml.transform.TransformerFactory;
	import javax.xml.transform.dom.DOMSource;
	import javax.xml.transform.stream.StreamResult;

	import org.w3c.dom.Document;
	import org.w3c.dom.Node;
	import org.xml.sax.SAXException;

	/**
	* This is an interface provide basic support for JAXP functional test.
	*/
	public class JAXPTestUtilities {
	/**
	* Prefix for error message.
	*/
	public static final String ERROR_MSG_HEADER = "Unexcepted exception thrown:";

	/**
	* Prefix for error message on clean up block.
	*/
	public static final String ERROR_MSG_CLEANUP = "Clean up failed on %s";

	/**
	* Force using slash as File separator as we always use cygwin to test in
	* Windows platform.
	*/
	public static final String FILE_SEP = "/";

	/**
	* A map storing every test's current test file pointer. File number should
	* be incremental and it's a thread-safe reading on this file number.
	*/
	private static final ConcurrentHashMap<Class<?>, Integer> currentFileNumber
	= new ConcurrentHashMap<>();

	/**
	* BOM table for storing BOM header.
	*/
	private final static Map<String, byte[]> bom = new HashMap<>();

	/**
	* Initialize all BOM headers.
	*/
	static {
	bom.put("UTF-8", new byte[]{(byte)0xEF, (byte) 0xBB, (byte) 0xBF});
	bom.put("UTF-16BE", new byte[]{(byte)0xFE, (byte)0xFF});
	bom.put("UTF-16LE", new byte[]{(byte)0xFF, (byte)0xFE});
	bom.put("UTF-32BE", new byte[]{(byte)0x00, (byte)0x00, (byte)0xFE, (byte)0xFF});
	bom.put("UTF-32LE", new byte[]{(byte)0xFF, (byte)0xFE, (byte)0x00, (byte)0x00});
	}

	/**
	* Compare contents of golden file with test output file line by line.
	* return true if they're identical.
	* @param goldfile Golden output file name
	* @param outputfile Test output file name
	* @return true if two files are identical.
	* false if two files are not identical.
	* @throws IOException if an I/O error occurs reading from the file or a
	* malformed or unmappable byte sequence is read.
	*/
	public static boolean compareWithGold(String goldfile, String outputfile)
	throws IOException {
	return compareWithGold(goldfile, outputfile, StandardCharsets.UTF_8);
	}

	/**
	* Compare contents of golden file with test output file line by line.
	* return true if they're identical.
	* @param goldfile Golden output file name.
	* @param outputfile Test output file name.
	* @param cs the charset to use for decoding.
	* @return true if two files are identical.
	* false if two files are not identical.
	* @throws IOException if an I/O error occurs reading from the file or a
	* malformed or unmappable byte sequence is read.
	*/
	public static boolean compareWithGold(String goldfile, String outputfile,
	Charset cs) throws IOException {
	boolean isSame = Files.readAllLines(Paths.get(goldfile)).
	equals(Files.readAllLines(Paths.get(outputfile), cs));
	if (!isSame) {
	System.err.println("Golden file " + goldfile + " :");
	Files.readAllLines(Paths.get(goldfile)).forEach(System.err::println);
	System.err.println("Output file " + outputfile + " :");
	Files.readAllLines(Paths.get(outputfile), cs).forEach(System.err::println);
	}
	return isSame;
	}

	/**
	* Compare contents of golden file with test output list line by line.
	* return true if they're identical.
	* @param goldfile Golden output file name.
	* @param lines test output list.
	* @return true if file's content is identical to given list.
	* false if file's content is not identical to given list.
	* @throws IOException if an I/O error occurs reading from the file or a
	* malformed or unmappable byte sequence is read
	*/
	public static boolean compareLinesWithGold(String goldfile, List<String> lines)
	throws IOException {
	return Files.readAllLines(Paths.get(goldfile)).equals(lines);
	}

	/**
	* Compare contents of golden file with a test output string.
	* return true if they're identical.
	* @param goldfile Golden output file name.
	* @param string test string.
	* @return true if file's content is identical to given string.
	* false if file's content is not identical to given string.
	* @throws IOException if an I/O error occurs reading from the file or a
	* malformed or unmappable byte sequence is read
	*/
	public static boolean compareStringWithGold(String goldfile, String string)
	throws IOException {
	return Files.readAllLines(Paths.get(goldfile)).stream().collect(
	Collectors.joining(System.getProperty("line.separator")))
	.equals(string);
	}

	/**
	* Compare contents of golden file with test output file by their document
	* representation.
	* Here we ignore the white space and comments. return true if they're
	* lexical identical.
	* @param goldfile Golden output file name.
	* @param resultFile Test output file name.
	* @return true if two file's document representation are identical.
	* false if two file's document representation are not identical.
	* @throws javax.xml.parsers.ParserConfigurationException if the
	* implementation is not available or cannot be instantiated.
	* @throws SAXException If any parse errors occur.
	* @throws IOException if an I/O error occurs reading from the file or a
	* malformed or unmappable byte sequence is read .
	*/
	public static boolean compareDocumentWithGold(String goldfile, String resultFile)
	throws ParserConfigurationException, SAXException, IOException {
	DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
	factory.setNamespaceAware(true);
	factory.setCoalescing(true);
	factory.setIgnoringElementContentWhitespace(true);
	factory.setIgnoringComments(true);
	DocumentBuilder db = factory.newDocumentBuilder();

	Document goldD = db.parse(Paths.get(goldfile).toFile());
	goldD.normalizeDocument();
	Document resultD = db.parse(Paths.get(resultFile).toFile());
	resultD.normalizeDocument();
	return goldD.isEqualNode(resultD);
	}

	/**
	* Compare contents of golden file with the serialization represent by given
	* DOM node.
	* Here we ignore the white space and comments. return true if they're
	* lexical identical.
	* @param goldfile Golden output file name.
	* @param node A DOM node instance.
	* @return true if file's content is identical to given node's serialization
	* represent.
	* false if file's content is not identical to given node's
	* serialization represent.
	* @throws TransformerException If an unrecoverable error occurs during the
	* course of the transformation..
	* @throws IOException if an I/O error occurs reading from the file or a
	* malformed or unmappable byte sequence is read .
	*/
	public static boolean compareSerializeDOMWithGold(String goldfile, Node node)
	throws TransformerException, IOException {
	TransformerFactory factory = TransformerFactory.newInstance();
	// Use identity transformer to serialize
	Transformer identityTransformer = factory.newTransformer();
	StringWriter sw = new StringWriter();
	StreamResult streamResult = new StreamResult(sw);
	DOMSource nodeSource = new DOMSource(node);
	identityTransformer.transform(nodeSource, streamResult);
	return compareStringWithGold(goldfile, sw.toString());
	}

	/**
	* Convert stream to ByteArrayInputStream by given character set.
	* @param charset target character set.
	* @param file a file that contains no BOM head content.
	* @return a ByteArrayInputStream contains BOM heads and bytes in original
	* stream
	* @throws IOException I/O operation failed or unsupported character set.
	*/
	public static InputStream bomStream(String charset, String file)
	throws IOException {
	String localCharset = charset;
	if (charset.equals("UTF-16") \|\| charset.equals("UTF-32")) {
	localCharset
	+= ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN ? "BE" : "LE";
	}
	if (!bom.containsKey(localCharset))
	throw new UnsupportedCharsetException("Charset:" + localCharset);

	byte[] content = Files.readAllLines(Paths.get(file)).stream().
	collect(Collectors.joining()).getBytes(localCharset);
	byte[] head = bom.get(localCharset);
	ByteBuffer bb = ByteBuffer.allocate(content.length + head.length);
	bb.put(head);
	bb.put(content);
	return new ByteArrayInputStream(bb.array());
	}

	/**
	* Worker method to detect common absolute URLs.
	*
	* @param s String path\filename or URL (or any, really)
	* @return true if s starts with a common URI scheme (namely
	* the ones found in the examples of RFC2396); false otherwise
	*/
	protected static boolean isCommonURL(String s) {
	if (null == s)
	return false;
	return Pattern.compile("^(file:\|http:\|ftp:\|gopher:\|mailto:\|news:\|telnet:)")
	.matcher(s).matches();
	}

	/**
	* Utility method to translate a String filename to URL.
	*
	* If the name starts with a common URI scheme (namely the ones
	* found in the examples of RFC2396), then simply return the
	* name as-is (the assumption is that it's already a URL).
	* Otherwise we attempt (cheaply) to convert to a file:/ URL.
	*
	* @param filename local path/filename of a file.
	* @return a file:/ URL if filename represent a file, the same string if
	* it appears to already be a URL.
	*/
	public static String filenameToURL(String filename) {
	return Paths.get(filename).toUri().toASCIIString();
	}

	/**
	* Prints error message if an exception is thrown
	* @param ex The exception is thrown by test.
	*/
	public static void failUnexpected(Throwable ex) {
	fail(ERROR_MSG_HEADER, ex);
	}

	/**
	* Prints error message if an exception is thrown when clean up a file.
	* @param ex The exception is thrown in cleaning up a file.
	* @param name Cleaning up file name.
	*/
	public static void failCleanup(IOException ex, String name) {
	fail(String.format(ERROR_MSG_CLEANUP, name), ex);
	}

	/**
	* Retrieve next test output file name. This method is a thread-safe method.
	* @param clazz test class.
	* @return next test output file name.
	*/
	public static String getNextFile(Class<?> clazz) {
	int nextNumber = currentFileNumber.contains(clazz)
	? currentFileNumber.get(clazz) + 1 : 1;
	Integer i = currentFileNumber.putIfAbsent(clazz, nextNumber);
	if (i != null) {
	do {
	nextNumber = currentFileNumber.get(clazz) + 1;
	} while (!currentFileNumber.replace(clazz, nextNumber - 1, nextNumber));
	}
	return USER_DIR + clazz.getName() + nextNumber + ".out";
	}

	/**
	* Acquire a full path string by given class name and relative path string.
	* @param clazz Class name for the test.
	* @param relativeDir relative path between java source file and expected
	* path.
	* @return a string represents the full path of accessing path.
	*/
	public static String getPathByClassName(Class<?> clazz, String relativeDir) {
	String javaSourcePath = System.getProperty("test.src").replaceAll("\\" + File.separator, FILE_SEP);
	String normalizedPath = Paths.get(javaSourcePath, relativeDir).normalize().
	toAbsolutePath().toString();
	return normalizedPath.replace("\\", FILE_SEP) + FILE_SEP;
	}


	/**
	* Run the supplier with all permissions. This won't impact global policy.
	*
	* @param s
	* Supplier to run
	*/
	public static <T> T runWithAllPerm(Supplier<T> s) {
	Optional<JAXPPolicyManager> policyManager = Optional.ofNullable(JAXPPolicyManager
	.getJAXPPolicyManager(false));
	policyManager.ifPresent(manager -> manager.setAllowAll(true));
	try {
	return s.get();
	} finally {
	policyManager.ifPresent(manager -> manager.setAllowAll(false));
	}
	}

	/**
	* Run the supplier with all permissions. This won't impact global policy.
	*
	* @param s
	* Supplier to run
	*/
	public static <T> T tryRunWithAllPerm(Callable<T> c) throws Exception {
	Optional<JAXPPolicyManager> policyManager = Optional.ofNullable(JAXPPolicyManager
	.getJAXPPolicyManager(false));
	policyManager.ifPresent(manager -> manager.setAllowAll(true));
	try {
	return c.call();
	} finally {
	policyManager.ifPresent(manager -> manager.setAllowAll(false));
	}
	}

	/**
	* Run the Runnable with all permissions. This won't impact global policy.
	*
	* @param s
	* Supplier to run
	*/
	public static void runWithAllPerm(Runnable r) {
	Optional<JAXPPolicyManager> policyManager = Optional.ofNullable(JAXPPolicyManager
	.getJAXPPolicyManager(false));
	policyManager.ifPresent(manager -> manager.setAllowAll(true));
	try {
	r.run();
	} finally {
	policyManager.ifPresent(manager -> manager.setAllowAll(false));
	}
	}

	/**
	* Acquire a system property.
	*
	* @param name
	* System property name to be acquired.
	* @return property value
	*/
	public static String getSystemProperty(String name) {
	return runWithAllPerm(() -> System.getProperty(name));
	}

	/**
	* Set a system property by given system value.
	*
	* @param name
	* System property name to be set.
	* @param value
	* System property value to be set.
	*/
	public static void setSystemProperty(String name, String value) {
	runWithAllPerm(() -> System.setProperty(name, value));
	}

	/**
	* Clear a system property.
	*
	* @param name
	* System property name to be cleared.
	*/
	public static void clearSystemProperty(String name) {
	runWithAllPerm(() -> System.clearProperty(name));
	}

	/**
	* Run the runnable with assigning temporary permissions. This won't impact
	* global policy.
	*
	* @param r
	* Runnable to run
	* @param ps
	* assigning permissions to add.
	*/
	public static void runWithTmpPermission(Runnable r, Permission... ps) {
	JAXPPolicyManager policyManager = JAXPPolicyManager.getJAXPPolicyManager(false);
	List<Integer> tmpPermissionIndexes = new ArrayList<>();
	if (policyManager != null) {
	for (Permission p : ps)
	tmpPermissionIndexes.add(policyManager.addTmpPermission(p));
	}
	try {
	r.run();
	} finally {
	for (int index: tmpPermissionIndexes)
	policyManager.removeTmpPermission(index);
	}
	}

	/**
	* Run the supplier with assigning temporary permissions. This won't impact
	* global policy.
	*
	* @param s
	* Supplier to run
	* @param ps
	* assigning permissions to add.
	*/
	public static <T> T runWithTmpPermission(Supplier<T> s, Permission... ps) {
	JAXPPolicyManager policyManager = JAXPPolicyManager.getJAXPPolicyManager(false);
	List<Integer> tmpPermissionIndexes = new ArrayList<>();
	if (policyManager != null) {
	for (Permission p : ps)
	tmpPermissionIndexes.add(policyManager.addTmpPermission(p));
	}
	try {
	return s.get();
	} finally {
	for (int index: tmpPermissionIndexes)
	policyManager.removeTmpPermission(index);
	}
	}

	/**
	* Run the RunnableWithException with assigning temporary permissions. This
	* won't impact global policy.
	*
	* @param r
	* RunnableWithException to execute
	* @param ps
	* assigning permissions to add.
	*/
	public static void tryRunWithTmpPermission(RunnableWithException r, Permission... ps) throws Exception {
	JAXPPolicyManager policyManager = JAXPPolicyManager.getJAXPPolicyManager(false);
	List<Integer> tmpPermissionIndexes = new ArrayList<>();
	if (policyManager != null) {
	for (Permission p : ps)
	tmpPermissionIndexes.add(policyManager.addTmpPermission(p));
	}
	try {
	r.run();
	} finally {
	for (int index: tmpPermissionIndexes)
	policyManager.removeTmpPermission(index);
	}
	}

	@FunctionalInterface
	public interface RunnableWithException {
	void run() throws Exception;
	}

	/**
	* Current test directory.
	*/
	public static final String USER_DIR = getSystemProperty("user.dir") + FILE_SEP;;

	}