/*
* 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 + ".");
}
}