Mercurial > hg > jdk9-shenandoah > jaxp
changeset 780:a7b1a86945e0
8133307: Missing files while changing packages of JAXP unittest
Reviewed-by: joehw
Contributed-by: frank.yuan@oracle.com
| author | joehw |
|---|---|
| date | Mon, 10 Aug 2015 20:26:05 -0700 |
| parents | 2b61bfcaa586 |
| children | 5b1899c9822d |
| files | test/javax/xml/jaxp/unittest/TEST.properties test/javax/xml/jaxp/unittest/javax/xml/stream/XMLStreamReaderTest/ExternalDTD.dtd test/javax/xml/jaxp/unittest/javax/xml/stream/XMLStreamReaderTest/ExternalDTD.xml test/javax/xml/jaxp/unittest/policy/PolicyUtil.java test/javax/xml/jaxp/unittest/policy/common.policy test/javax/xml/jaxp/unittest/util/BOMInputStream.java test/javax/xml/jaxp/unittest/util/BaseStAXUT.java test/javax/xml/jaxp/unittest/util/DraconianErrorHandler.java |
| diffstat | 8 files changed, 744 insertions(+), 32 deletions(-) [+] |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/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/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/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/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/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/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/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/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; + } +}