--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/jaxp/test/javax/xml/jaxp/unittest/TEST.properties	Mon Aug 10 20:26:05 2015 -0700
@@ -0,0 +1,6 @@
+# jaxp test uses TestNG
+TestNG.dirs = .
+
+# Declare module dependency
+modules=java.xml
+

--- a/jaxp/test/javax/xml/jaxp/unittest/javax/xml/stream/XMLStreamReaderTest/ExternalDTD.dtd	Mon Aug 10 09:52:32 2015 -0700
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,13 +0,0 @@
-<!ELEMENT document ANY>
-<!ELEMENT title (#PCDATA)>
-<!ELEMENT publisher (#PCDATA)>
-<!ELEMENT book (#PCDATA)>
-<!ELEMENT bookurn (#PCDATA)>
-<!ELEMENT xmlns:pages (#PCDATA)>
-<!ATTLIST book price CDATA "$100">
-<!ATTLIST book author CDATA "Herold">
-<!ATTLIST book number ID #REQUIRED>
-<!ATTLIST bookurn xmlns CDATA "10">
-<!ATTLIST bookurn xmlns:isbn CDATA "10">
-<!ENTITY mkm "I am Krishna">
-<!ENTITY km "I am KrishnaMohan">

--- a/jaxp/test/javax/xml/jaxp/unittest/javax/xml/stream/XMLStreamReaderTest/ExternalDTD.xml	Mon Aug 10 09:52:32 2015 -0700
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,19 +0,0 @@
-<?xml version="1.0" encoding ="utf-8"?>
-<!DOCTYPE document SYSTEM "ExternalDTD.dtd" [
-<!ENTITY max "Substituted text">
-]>
-<!-- ExternalDTD throws a Negative array size Exception when 
-trying to parse with the above DTD reference AND an entity declaration-->
-<document>
-	<title>The Publishers </title>
-	<publisher>        
-	Alfred Publishing
-	15535 Morrison
-	South Oaks CA 91403
-        &max;
-	</publisher>
-	<book price="$100" author = "Herold" number = "no_11">eXtensible Markup Language</book>
-  	<bookurn xmlns='urn:loc.gov:books' xmlns:isbn='urn:ISBN:0-395-36341-6'/> 
-        <pb/>
-	<pages />
-</document>

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/jaxp/test/javax/xml/jaxp/unittest/policy/PolicyUtil.java	Mon Aug 10 20:26:05 2015 -0700
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2014, 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 policy;
+
+import java.security.Policy;
+
+public class PolicyUtil {
+
+    public static void changePolicy(String policyFile) {
+        System.setProperty("java.security.policy", policyFile);
+        Policy.getPolicy().refresh();
+    }
+
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/jaxp/test/javax/xml/jaxp/unittest/policy/common.policy	Mon Aug 10 20:26:05 2015 -0700
@@ -0,0 +1,27 @@
+grant {
+	permission java.lang.reflect.ReflectPermission "suppressAccessChecks";
+	permission java.lang.RuntimePermission "accessDeclaredMembers";
+	
+	permission java.io.FilePermission "${test.classes}/../../-", "read, write, delete";
+	permission java.io.FilePermission ".", "read, write, delete";
+	permission java.util.PropertyPermission "*", "read, write";
+	
+    permission java.lang.RuntimePermission "setSecurityManager";
+    permission java.lang.RuntimePermission "createSecurityManager";
+    permission java.lang.RuntimePermission "createClassLoader";
+    permission java.lang.RuntimePermission "setIO";
+	permission java.lang.RuntimePermission "setContextClassLoader"; 
+	permission java.security.SecurityPermission "getPolicy";
+    
+    permission java.io.FilePermission "${test.src}/-", "read, write, delete";
+    permission java.io.FilePermission "${user.dir}/-", "read, write, delete";
+    permission java.io.FilePermission "${java.io.tmpdir}/-", "read, write, delete";
+    
+    permission java.lang.RuntimePermission "accessClassInPackage.com.sun.org.apache.bcel.internal.classfile";
+    permission java.lang.RuntimePermission "accessClassInPackage.com.sun.org.apache.bcel.internal.generic";
+    permission java.lang.RuntimePermission "accessClassInPackage.com.sun.xml.internal.stream.writers";
+    permission java.lang.RuntimePermission "accessClassInPackage.com.sun.org.apache.xerces.internal.impl";
+    permission java.lang.RuntimePermission "accessClassInPackage.com.sun.org.apache.xalan.internal";
+    permission java.lang.RuntimePermission "accessClassInPackage.com.sun.org.apache.xalan.internal.xsltc.trax";
+	permission java.lang.RuntimePermission "accessClassInPackage.com.sun.org.apache.xalan.internal.xslt";
+};

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/jaxp/test/javax/xml/jaxp/unittest/util/BOMInputStream.java	Mon Aug 10 20:26:05 2015 -0700
@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) 2014, 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 util;
+
+import java.io.BufferedInputStream;
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.UnsupportedEncodingException;
+import java.util.HashMap;
+import java.util.Map;
+
+public class BOMInputStream {
+        public static InputStream createStream(String charset, InputStream input) {
+
+                        try {
+                                byte[] content = read(input).getBytes(charset);
+                                byte[] head = bom.get(charset);
+                                if (head == null)
+                                        return null;
+                                byte[] result = new byte[head.length + content.length];
+                                System.arraycopy(head, 0, result, 0, head.length);
+                                System.arraycopy(content, 0, result, head.length, content.length);
+                                return new ByteArrayInputStream(result);
+                        } catch (UnsupportedEncodingException e) {
+                                return null;
+                        }
+        }
+
+        private static String read(InputStream input)
+        {
+                try {
+                        StringBuffer sb = new StringBuffer();
+                        InputStreamReader r = new InputStreamReader(new BufferedInputStream(input));
+                        int c = 0;
+                        while ((c = r.read()) != -1)
+                                sb.append((char)c);
+                        return sb.toString();
+                } catch (IOException e) {
+                        return "";
+                } finally {
+                        try {
+                                input.close();
+                        } catch (IOException e)
+                        {}
+                }
+        }
+
+
+        private final static Map<String, byte[]> bom = new HashMap();
+        private final static byte[][] bomBytes = {{(byte)0xEF, (byte)0xBB, (byte)0xBF},
+                                        {(byte)0xFE, (byte)0xFF}};
+
+        static {
+                bom.put("UTF-8", bomBytes[0]);
+                bom.put("UTF-16BE", bomBytes[1]);
+        }
+
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/jaxp/test/javax/xml/jaxp/unittest/util/BaseStAXUT.java	Mon Aug 10 20:26:05 2015 -0700
@@ -0,0 +1,559 @@
+/*
+ * Copyright (c) 2014, 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 util;
+
+import java.io.ByteArrayInputStream;
+import java.io.File;
+import java.io.FileReader;
+import java.io.IOException;
+import java.io.StringReader;
+import java.io.UnsupportedEncodingException;
+import java.util.HashMap;
+
+import javax.xml.stream.XMLEventFactory;
+import javax.xml.stream.XMLInputFactory;
+import javax.xml.stream.XMLOutputFactory;
+import javax.xml.stream.XMLResolver;
+import javax.xml.stream.XMLStreamConstants;
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamReader;
+import javax.xml.stream.events.XMLEvent;
+
+import org.testng.Assert;
+
+/**
+ * Base class for all StaxTest unit test classes. Contains shared
+ * functionality for many common set up tasks, as well as for
+ * outputting diagnostics.
+ *
+ */
+public class BaseStAXUT implements XMLStreamConstants {
+    /**
+     * This is the de facto standard property that enables accurate reporting of
+     * CDATA events.
+     */
+    final static String PROP_REPORT_CDATA = "http://java.sun.com/xml/stream/properties/report-cdata-event";
+
+    final static HashMap mTokenTypes = new HashMap();
+    static {
+        mTokenTypes.put(new Integer(START_ELEMENT), "START_ELEMENT");
+        mTokenTypes.put(new Integer(END_ELEMENT), "END_ELEMENT");
+        mTokenTypes.put(new Integer(START_DOCUMENT), "START_DOCUMENT");
+        mTokenTypes.put(new Integer(END_DOCUMENT), "END_DOCUMENT");
+        mTokenTypes.put(new Integer(CHARACTERS), "CHARACTERS");
+        mTokenTypes.put(new Integer(CDATA), "CDATA");
+        mTokenTypes.put(new Integer(COMMENT), "COMMENT");
+        mTokenTypes.put(new Integer(PROCESSING_INSTRUCTION), "PROCESSING_INSTRUCTION");
+        mTokenTypes.put(new Integer(DTD), "DTD");
+        mTokenTypes.put(new Integer(SPACE), "SPACE");
+        mTokenTypes.put(new Integer(ENTITY_REFERENCE), "ENTITY_REFERENCE");
+        mTokenTypes.put(new Integer(NAMESPACE), "NAMESPACE_DECLARATION");
+        mTokenTypes.put(new Integer(NOTATION_DECLARATION), "NOTATION_DECLARATION");
+        mTokenTypes.put(new Integer(ENTITY_DECLARATION), "ENTITY_DECLARATION");
+    }
+
+    /*
+     * /////////////////////////////////////////////////// // Consts for
+     * expected values ///////////////////////////////////////////////////
+     */
+
+    /**
+     * Expected return value for streamReader.getNamespaceURI() in
+     * non-namespace-aware mode.
+     */
+    protected final String DEFAULT_URI_NON_NS = "";
+
+    protected final String DEFAULT_URI_NS = "";
+
+    /*
+     * /////////////////////////////////////////////////// // Other consts
+     * ///////////////////////////////////////////////////
+     */
+
+    /*
+     * /////////////////////////////////////////////////// // Cached instances
+     * ///////////////////////////////////////////////////
+     */
+
+    XMLInputFactory mInputFactory;
+    XMLOutputFactory mOutputFactory;
+    XMLEventFactory mEventFactory;
+
+    protected XMLInputFactory getInputFactory() {
+        if (mInputFactory == null) {
+            mInputFactory = getNewInputFactory();
+        }
+        return mInputFactory;
+    }
+
+    protected static XMLInputFactory getNewInputFactory() {
+        return XMLInputFactory.newInstance();
+    }
+
+    protected XMLOutputFactory getOutputFactory() {
+        if (mOutputFactory == null) {
+            mOutputFactory = getNewOutputFactory();
+        }
+        return mOutputFactory;
+    }
+
+    protected static XMLOutputFactory getNewOutputFactory() {
+        return XMLOutputFactory.newInstance();
+    }
+
+    protected XMLEventFactory getEventFactory() {
+        if (mEventFactory == null) {
+            mEventFactory = XMLEventFactory.newInstance();
+        }
+        return mEventFactory;
+    }
+
+    protected static XMLStreamReader constructStreamReader(XMLInputFactory f, String content) throws XMLStreamException {
+        // return f.createXMLStreamReader(new StringReader(content));
+        try {
+            byte[] data = content.getBytes("UTF-8");
+            return constructStreamReader(f, data);
+        } catch (UnsupportedEncodingException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    protected static XMLStreamReader constructStreamReader(XMLInputFactory f, byte[] b) throws XMLStreamException {
+        return f.createXMLStreamReader(new ByteArrayInputStream(b));
+    }
+
+    protected static XMLStreamReader constructStreamReaderForFile(XMLInputFactory f, String filename) throws IOException, XMLStreamException {
+        File inf = new File(filename);
+        XMLStreamReader sr = f.createXMLStreamReader(inf.toURL().toString(), new FileReader(inf));
+        Assert.assertEquals(START_DOCUMENT, sr.getEventType());
+        return sr;
+    }
+
+    protected XMLStreamReader constructNsStreamReader(String content) throws XMLStreamException {
+        XMLInputFactory f = getInputFactory();
+        setNamespaceAware(f, true);
+        return f.createXMLStreamReader(new StringReader(content));
+    }
+
+    protected XMLStreamReader constructNsStreamReader(String content, boolean coal) throws XMLStreamException {
+        XMLInputFactory f = getInputFactory();
+        setNamespaceAware(f, true);
+        setCoalescing(f, coal);
+        return f.createXMLStreamReader(new StringReader(content));
+    }
+
+    /*
+     * ////////////////////////////////////////////////// // Configuring input
+     * factory //////////////////////////////////////////////////
+     */
+
+    protected static boolean isCoalescing(XMLInputFactory f) throws XMLStreamException {
+        return ((Boolean) f.getProperty(XMLInputFactory.IS_COALESCING)).booleanValue();
+    }
+
+    protected static void setCoalescing(XMLInputFactory f, boolean state) throws XMLStreamException {
+        Boolean b = state ? Boolean.TRUE : Boolean.FALSE;
+        f.setProperty(XMLInputFactory.IS_COALESCING, b);
+        // Let's just double-check it...
+        Assert.assertEquals(state, isCoalescing(f));
+    }
+
+    protected static boolean isValidating(XMLInputFactory f) throws XMLStreamException {
+        return ((Boolean) f.getProperty(XMLInputFactory.IS_VALIDATING)).booleanValue();
+    }
+
+    protected static void setValidating(XMLInputFactory f, boolean state) throws XMLStreamException {
+        try {
+            Boolean b = state ? Boolean.TRUE : Boolean.FALSE;
+            f.setProperty(XMLInputFactory.IS_VALIDATING, b);
+        } catch (IllegalArgumentException iae) {
+            Assert.fail("Could not set DTD validating mode to " + state + ": " + iae);
+            // throw new XMLStreamException(iae.getMessage(), iae);
+        }
+        Assert.assertEquals(state, isValidating(f));
+    }
+
+    protected static boolean isNamespaceAware(XMLInputFactory f) throws XMLStreamException {
+        return ((Boolean) f.getProperty(XMLInputFactory.IS_NAMESPACE_AWARE)).booleanValue();
+    }
+
+    /**
+     * @return True if setting succeeded, and property supposedly was
+     *         succesfully set to the value specified; false if there was a
+     *         problem.
+     */
+    protected static boolean setNamespaceAware(XMLInputFactory f, boolean state) throws XMLStreamException {
+        try {
+            f.setProperty(XMLInputFactory.IS_NAMESPACE_AWARE, state ? Boolean.TRUE : Boolean.FALSE);
+
+            /*
+             * 07-Sep-2005, TSa: Let's not assert, but instead let's see if it
+             * sticks. Some implementations might choose to silently ignore
+             * setting, at least for 'false'?
+             */
+            return (isNamespaceAware(f) == state);
+        } catch (IllegalArgumentException e) {
+            /*
+             * Let's assume, then, that the property (or specific value for it)
+             * is NOT supported...
+             */
+            return false;
+        }
+    }
+
+    protected static void setReplaceEntities(XMLInputFactory f, boolean state) throws XMLStreamException {
+        Boolean b = state ? Boolean.TRUE : Boolean.FALSE;
+        f.setProperty(XMLInputFactory.IS_REPLACING_ENTITY_REFERENCES, b);
+        Assert.assertEquals(b, f.getProperty(XMLInputFactory.IS_REPLACING_ENTITY_REFERENCES));
+    }
+
+    protected static void setSupportDTD(XMLInputFactory f, boolean state) throws XMLStreamException {
+        Boolean b = state ? Boolean.TRUE : Boolean.FALSE;
+        f.setProperty(XMLInputFactory.SUPPORT_DTD, b);
+        Assert.assertEquals(b, f.getProperty(XMLInputFactory.SUPPORT_DTD));
+    }
+
+    protected static boolean setSupportExternalEntities(XMLInputFactory f, boolean state) throws XMLStreamException {
+        Boolean b = state ? Boolean.TRUE : Boolean.FALSE;
+        try {
+            f.setProperty(XMLInputFactory.IS_SUPPORTING_EXTERNAL_ENTITIES, b);
+            Object act = f.getProperty(XMLInputFactory.IS_SUPPORTING_EXTERNAL_ENTITIES);
+            return (act instanceof Boolean) && ((Boolean) act).booleanValue() == state;
+        } catch (IllegalArgumentException e) {
+            /*
+             * Let's assume, then, that the property (or specific value for it)
+             * is NOT supported...
+             */
+            return false;
+        }
+    }
+
+    protected static void setResolver(XMLInputFactory f, XMLResolver resolver) throws XMLStreamException {
+        f.setProperty(XMLInputFactory.RESOLVER, resolver);
+    }
+
+    protected static boolean setReportCData(XMLInputFactory f, boolean state) throws XMLStreamException {
+
+        Boolean b = state ? Boolean.TRUE : Boolean.FALSE;
+        if (f.isPropertySupported(PROP_REPORT_CDATA)) {
+            f.setProperty(PROP_REPORT_CDATA, b);
+            return true;
+        }
+        return false;
+    }
+
+    /*
+     * ////////////////////////////////////////////////// // Stream reader
+     * accessors //////////////////////////////////////////////////
+     */
+
+    /**
+     * Method that not only gets currently available text from the reader, but
+     * also checks that its consistenly accessible using different StAX methods.
+     */
+    protected static String getAndVerifyText(XMLStreamReader sr) throws XMLStreamException {
+        String text = sr.getText();
+
+        /*
+         * 05-Apr-2006, TSa: Although getText() is available for DTD and
+         * ENTITY_REFERENCE, getTextXxx() are not. Thus, can not do more checks
+         * for those types.
+         */
+        int type = sr.getEventType();
+        if (type != ENTITY_REFERENCE && type != DTD) {
+            Assert.assertNotNull("getText() should never return null.", text);
+            int expLen = sr.getTextLength();
+            /*
+             * Hmmh. Can only return empty text for CDATA (since empty blocks
+             * are legal).
+             */
+            /*
+             * !!! 01-Sep-2004, TSa: note: theoretically, in coalescing mode, it
+             * could be possible to have empty CDATA section(s) get converted to
+             * CHARACTERS, which would be empty... may need to enhance this to
+             * check that mode is not coalescing? Or something
+             */
+            if (sr.getEventType() == CHARACTERS) {
+                if (expLen == 0) {
+                    Assert.fail("Stream reader should never return empty Strings.");
+                }
+            }
+            Assert.assertEquals(expLen, text.length(), "Expected text length of " + expLen + ", got " + text.length());
+            char[] textChars = sr.getTextCharacters();
+            int start = sr.getTextStart();
+            String text2 = new String(textChars, start, expLen);
+            Assert.assertEquals("Expected getText() and getTextCharacters() to return same value for event of type (" + tokenTypeDesc(sr.getEventType()) + ")",
+                    text, text2);
+        } else { // DTD or ENTITY_REFERENCE
+            // not sure if null is legal for these either, but...
+            if (text == null) { // let's prevent an NPE at caller
+                text = "";
+            }
+        }
+        return text;
+    }
+
+    protected static String getAllText(XMLStreamReader sr) throws XMLStreamException {
+        StringBuffer sb = new StringBuffer();
+        while (true) {
+            int tt = sr.getEventType();
+            if (tt != CHARACTERS && tt != SPACE) {
+                break;
+            }
+            sb.append(getAndVerifyText(sr));
+            sr.next();
+        }
+        return sb.toString();
+    }
+
+    protected static String getAllCData(XMLStreamReader sr) throws XMLStreamException {
+        StringBuffer sb = new StringBuffer();
+        while (true) {
+            /*
+             * Note: CDATA sections CAN be reported as CHARACTERS, but not as
+             * SPACE
+             */
+            int tt = sr.getEventType();
+            if (tt != CHARACTERS && tt != CDATA) {
+                break;
+            }
+            sb.append(getAndVerifyText(sr));
+            sr.next();
+        }
+        return sb.toString();
+    }
+
+    /*
+     * ////////////////////////////////////////////////// // Derived assert/fail
+     * methods //////////////////////////////////////////////////
+     */
+
+    protected static void assertTokenType(int expType, int actType) {
+        if (expType == actType) {
+            return;
+        }
+        Assert.fail("Expected token " + tokenTypeDesc(expType) + "; got " + tokenTypeDesc(actType) + ".");
+    }
+
+    protected static void assertTokenType(int expType, int actType, XMLStreamReader sr) {
+        if (expType == actType) {
+            return;
+        }
+        Assert.fail("Expected token " + tokenTypeDesc(expType) + "; got " + tokenTypeDesc(actType, sr) + ".");
+    }
+
+    protected static void assertTextualTokenType(int actType) {
+        if (actType != CHARACTERS && actType != SPACE && actType != CDATA) {
+            Assert.fail("Expected textual token (CHARACTERS, SPACE or CDATA)" + "; got " + tokenTypeDesc(actType) + ".");
+        }
+    }
+
+    protected static void failStrings(String msg, String exp, String act) {
+        // !!! TODO: Indicate position where Strings differ
+        Assert.fail(msg + ": expected " + quotedPrintable(exp) + ", got " + quotedPrintable(act));
+    }
+
+    /**
+     * Specific method makes sense, since earlier it was not clear whether null
+     * or empty string (or perhaps both) would be the right answer when there is
+     * no prefix.
+     * <p>
+     * However: as per javadocs of {@link XMLStreamReader#getPrefix}, from JDK
+     * 1.6 indicate, the current understanding is that <b>null</b> is the
+     * ultimate right answer here.
+     */
+    protected static void assertNoPrefix(XMLStreamReader sr) throws XMLStreamException {
+        String prefix = sr.getPrefix();
+        if (prefix != null) {
+            if (prefix.length() != 0) {
+                Assert.fail("Current element should not have a prefix: got '" + prefix + "'");
+            } else {
+                Assert.fail("Expected null to signify missing prefix (see XMLStreamReader#getPrefix() JavaDocs): got empty String");
+            }
+        }
+    }
+
+    protected static void assertNoAttrPrefix(String attrPrefix) throws XMLStreamException {
+        if (attrPrefix != null) {
+            if (attrPrefix.length() != 0) {
+                Assert.fail("Attribute should not have a prefix: got '" + attrPrefix + "'");
+            } else {
+                Assert.fail("Expected null to signify missing attribute prefix (see XMLStreamReader#getAttributePrefix() JavaDocs): got empty String");
+            }
+        }
+    }
+
+    /**
+     * Similar to {@link #assertNoPrefix}, but here we do know that unbound
+     * namespace URI should be indicated as empty String.
+     */
+    protected static void assertNoNsURI(XMLStreamReader sr) throws XMLStreamException {
+        String uri = sr.getNamespaceURI();
+        if (uri == null) {
+            Assert.fail("Expected empty String to indicate \"no namespace\": got null");
+        } else if (uri.length() != 0) {
+            Assert.fail("Expected empty String to indicate \"no namespace\": got '" + uri + "'");
+        }
+    }
+
+    protected static void assertNoAttrNamespace(String attrNsURI) throws XMLStreamException {
+        if (attrNsURI == null) {
+            // refer to 6903561; accept null for now.
+            // fail("Expected empty String to indicate \"no namespace\" (for attribute): got null");
+        } else if (attrNsURI.length() != 0) {
+            Assert.fail("Expected empty String to indicate \"no namespace\" (for attribute): got '" + attrNsURI + "'");
+        }
+    }
+
+    protected static void assertNoPrefixOrNs(XMLStreamReader sr) throws XMLStreamException {
+        assertNoPrefix(sr);
+        assertNoNsURI(sr);
+    }
+
+    /**
+     * Helper assertion that assert that the String is either null or empty
+     * ("").
+     */
+    protected static void assertNullOrEmpty(String str) {
+        if (str != null && str.length() > 0) {
+            Assert.fail("Expected String to be empty or null; was '" + str + "' (length " + str.length() + ")");
+        }
+    }
+
+    /*
+     * ////////////////////////////////////////////////// // Debug/output
+     * helpers //////////////////////////////////////////////////
+     */
+
+    protected static String tokenTypeDesc(int tt) {
+        String desc = (String) mTokenTypes.get(new Integer(tt));
+        if (desc == null) {
+            return "[" + tt + "]";
+        }
+        return desc;
+    }
+
+    protected static String tokenTypeDesc(XMLEvent evt) {
+        return tokenTypeDesc(evt.getEventType());
+    }
+
+    final static int MAX_DESC_TEXT_CHARS = 8;
+
+    protected static String tokenTypeDesc(int tt, XMLStreamReader sr) {
+        String desc = tokenTypeDesc(tt);
+        // Let's show first 8 chars or so...
+        if (tt == CHARACTERS || tt == SPACE || tt == CDATA) {
+            String str = sr.getText();
+            if (str.length() > MAX_DESC_TEXT_CHARS) {
+                desc = "\"" + str.substring(0, MAX_DESC_TEXT_CHARS) + "\"[...]";
+            } else {
+                desc = "\"" + desc + "\"";
+            }
+            desc = " (" + desc + ")";
+        }
+        return desc;
+    }
+
+    protected static String valueDesc(String value) {
+        if (value == null) {
+            return "[NULL]";
+        }
+        return "\"" + value + "\"";
+    }
+
+    protected static String printable(char ch) {
+        if (ch == '\n') {
+            return "\\n";
+        }
+        if (ch == '\r') {
+            return "\\r";
+        }
+        if (ch == '\t') {
+            return "\\t";
+        }
+        if (ch == ' ') {
+            return "_";
+        }
+        if (ch > 127 || ch < 32) {
+            StringBuffer sb = new StringBuffer(6);
+            sb.append("\\u");
+            String hex = Integer.toHexString((int) ch);
+            for (int i = 0, len = 4 - hex.length(); i < len; i++) {
+                sb.append('0');
+            }
+            sb.append(hex);
+            return sb.toString();
+        }
+        return null;
+    }
+
+    protected static String printable(String str) {
+        if (str == null || str.length() == 0) {
+            return str;
+        }
+
+        int len = str.length();
+        StringBuffer sb = new StringBuffer(len + 64);
+        for (int i = 0; i < len; ++i) {
+            char c = str.charAt(i);
+            String res = printable(c);
+            if (res == null) {
+                sb.append(c);
+            } else {
+                sb.append(res);
+            }
+        }
+        return sb.toString();
+    }
+
+    protected static String quotedPrintable(String str) {
+        if (str == null || str.length() == 0) {
+            return "[0]''";
+        }
+        return "[len: " + str.length() + "] '" + printable(str) + "'";
+    }
+
+    protected void reportNADueToProperty(String method, String prop) {
+        String clsName = getClass().getName();
+        /*
+         * 27-Sep-2005, TSa: Should probably use some other mechanism for
+         * reporting this. Does JUnit have something applicable?
+         */
+        System.err.println("Skipping " + clsName + "#" + method + ": property '" + prop + "' (or one of its values) not supported.");
+    }
+
+    protected void reportNADueToNS(String method) {
+        reportNADueToProperty(method, "IS_NAMESPACE_AWARE");
+    }
+
+    protected void reportNADueToExtEnt(String method) {
+        reportNADueToProperty(method, "IS_SUPPORTING_EXTERNAL_ENTITIES");
+    }
+
+    protected void reportNADueToEntityExpansion(String method, int type) {
+        String clsName = getClass().getName();
+        String msg = (type > 0) ? " (next event: " + tokenTypeDesc(type) + ")" : "";
+        System.err.println("Skipping " + clsName + "#" + method + ": entity expansion does not seem to be functioning properly" + msg + ".");
+    }
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/jaxp/test/javax/xml/jaxp/unittest/util/DraconianErrorHandler.java	Mon Aug 10 20:26:05 2015 -0700
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2014, 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 util;
+
+import org.xml.sax.SAXException;
+import org.xml.sax.SAXParseException;
+import org.xml.sax.helpers.DefaultHandler;
+
+public final class DraconianErrorHandler extends DefaultHandler {
+    public void error(SAXParseException e) throws SAXException {
+        throw e;
+    }
+
+    public void fatalError(SAXParseException e) throws SAXException {
+        throw e;
+    }
+}