8133307: Missing files while changing packages of JAXP unittest
Reviewed-by: joehw
This commit is contained in:
Frank Yuan
Joe Wang
parent
0785d3b590
commit
29a1cfdf2f
jaxp/test/javax/xml/jaxp/unittest
6
jaxp/test/javax/xml/jaxp/unittest/TEST.properties
Normal file
6
jaxp/test/javax/xml/jaxp/unittest/TEST.properties
Normal file
@ -0,0 +1,6 @@
|
||||
# jaxp test uses TestNG
|
||||
TestNG.dirs = .
|
||||
|
||||
# Declare module dependency
|
||||
modules=java.xml
|
||||
|
||||
@ -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">
|
||||
@ -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>
|
||||
35
jaxp/test/javax/xml/jaxp/unittest/policy/PolicyUtil.java
Normal file
35
jaxp/test/javax/xml/jaxp/unittest/policy/PolicyUtil.java
Normal file
@ -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();
|
||||
}
|
||||
|
||||
}
|
||||
27
jaxp/test/javax/xml/jaxp/unittest/policy/common.policy
Normal file
27
jaxp/test/javax/xml/jaxp/unittest/policy/common.policy
Normal file
@ -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";
|
||||
};
|
||||
80
jaxp/test/javax/xml/jaxp/unittest/util/BOMInputStream.java
Normal file
80
jaxp/test/javax/xml/jaxp/unittest/util/BOMInputStream.java
Normal file
@ -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]);
|
||||
}
|
||||
|
||||
}
|
||||
559
jaxp/test/javax/xml/jaxp/unittest/util/BaseStAXUT.java
Normal file
559
jaxp/test/javax/xml/jaxp/unittest/util/BaseStAXUT.java
Normal file
@ -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 + ".");
|
||||
}
|
||||
}
|
||||
@ -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;
|
||||
}
|
||||
}
|
||||
Loading…
x
Reference in New Issue
Block a user