/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package javax.jdo.util;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.IOException;
import java.io.FileFilter;
import java.io.FilenameFilter;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.util.Arrays;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.StringTokenizer;
import javax.jdo.JDOFatalException;
import javax.xml.parsers.*;
import org.w3c.dom.Document;
import org.xml.sax.*;
import org.xml.sax.helpers.*;
/**
* Tests schema files.
* <p>
*/
public class XMLTestUtil {
/** */
protected static String BASEDIR = System.getProperty("basedir", ".");
/** "http://www.w3.org/2001/XMLSchema" */
protected static final String XSD_TYPE =
"http://www.w3.org/2001/XMLSchema";
/** */
protected static final String SCHEMA_LANGUAGE_PROP =
"http://java.sun.com/xml/jaxp/properties/schemaLanguage";
/** */
protected static final String SCHEMA_LOCATION_PROP =
"http://apache.org/xml/properties/schema/external-schemaLocation";
/** jdo namespace */
protected static final String JDO_XSD_NS =
"http://java.sun.com/xml/ns/jdo/jdo";
/** orm namespace */
protected static final String ORM_XSD_NS =
"http://java.sun.com/xml/ns/jdo/orm";
/** jdoquery namespace */
protected static final String JDOQUERY_XSD_NS =
"http://java.sun.com/xml/ns/jdo/jdoquery";
/** jdo xsd file */
protected static final File JDO_XSD_FILE =
new File(BASEDIR + "/target/classes/javax/jdo/jdo_2_2.xsd");
/** orm xsd file */
protected static final File ORM_XSD_FILE =
new File(BASEDIR + "/target/classes/javax/jdo/orm_2_2.xsd");
/** jdoquery xsd file */
protected static final File JDOQUERY_XSD_FILE =
new File(BASEDIR + "/target/classes/javax/jdo/jdoquery_2_2.xsd");
/** Entity resolver */
protected static final EntityResolver resolver = new JDOEntityResolver();
/** Error handler */
protected static final Handler handler = new Handler();
/** Name of the metadata property, a comma separated list of JDO metadata
* file or directories containing such files. */
protected static String METADATA_PROP = "javax.jdo.metadata";
/** Name of the recursive property, allowing recursive search of metadata
* files. */
protected static String RECURSIVE_PROP = "javax.jdo.recursive";
/** Separator character for the metadata property. */
protected static final String DELIM = ",;";
/** Newline. */
protected static final String NL = System.getProperty("line.separator");
/** XSD builder for jdo namespace. */
private final DocumentBuilder jdoXsdBuilder =
createBuilder(JDO_XSD_NS + " " + JDO_XSD_FILE.toURI().toString());
/** XSD builder for orm namespace. */
private final DocumentBuilder ormXsdBuilder =
createBuilder(ORM_XSD_NS + " " + ORM_XSD_FILE.toURI().toString());
/** XSD builder for jdoquery namespace. */
private final DocumentBuilder jdoqueryXsdBuilder =
createBuilder(JDOQUERY_XSD_NS + " " + JDOQUERY_XSD_FILE.toURI().toString());
/** DTD builder. */
private final DocumentBuilder dtdBuilder = createBuilder(true);
/** Non validating builder. */
private final DocumentBuilder nonValidatingBuilder = createBuilder(false);
/** Create XSD builder. */
private DocumentBuilder createBuilder(String location) {
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
factory.setValidating(true);
factory.setNamespaceAware(true);
factory.setAttribute(SCHEMA_LANGUAGE_PROP, XSD_TYPE);
factory.setAttribute(SCHEMA_LOCATION_PROP, location);
return getParser(factory);
}
/** Create builder. */
private DocumentBuilder createBuilder(boolean validating) {
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
factory.setValidating(validating);
factory.setNamespaceAware(true);
return getParser(factory);
}
/** Returns a parser obtained from specified factroy. */
private DocumentBuilder getParser(DocumentBuilderFactory factory) {
try {
DocumentBuilder builder = factory.newDocumentBuilder();
builder.setEntityResolver(resolver);
builder.setErrorHandler(handler);
return builder;
} catch (ParserConfigurationException ex) {
throw new JDOFatalException("Cannot create XML parser", ex);
}
}
/** Parse the specified files. The valid parameter determines whether the
* specified files are valid JDO metadata files. The method does not throw
* an exception on an error, instead it instead it returns the error
* message(s) as string.
*/
public String checkXML(File[] files, boolean valid) {
StringBuffer messages = new StringBuffer();
for (int i = 0; i < files.length; i++) {
String msg = checkXML(files[i], valid);
if (msg != null) {
messages.append(msg);
}
}
return (messages.length() == 0) ? null : messages.toString();
}
/** Parse the specified files using a non validating parser. The method
* does not throw an exception on an error, instead it instead it returns
* the error message(s) as string.
*/
public String checkXMLNonValidating(File[] files) {
StringBuffer messages = new StringBuffer();
for (int i = 0; i < files.length; i++) {
String msg = checkXML(nonValidatingBuilder, files[i], true);
if (msg != null) {
messages.append(msg);
}
}
return (messages.length() == 0) ? null : messages.toString();
}
/** Parse the specified file. The method checks whether it is a XSD or
* DTD base file and parses the file using a builder according to the file
* name suffix. The valid parameter determines whether the specified files
* are valid JDO metadata files. The method does not throw an exception on
* an error, instead it returns the error message(s) as string.
*/
private String checkXML(File file, boolean valid) {
String messages = null;
String fileName = file.getName();
try {
if (isDTDBased(file)) {
messages = checkXML(dtdBuilder, file, valid);
} else if (fileName.endsWith(".jdo")) {
messages = checkXML(jdoXsdBuilder, file, valid);
} else if (fileName.endsWith(".orm")) {
messages = checkXML(ormXsdBuilder, file, valid);
} else if (fileName.endsWith(".jdoquery")) {
messages = checkXML(jdoqueryXsdBuilder, file, valid);
}
} catch (SAXException ex) {
messages = ex.getMessage();
}
return messages;
}
/** Parse the specified file using the specified builder. The valid
* parameter determines whether the specified files are valid JDO metadata
* files. The method does not throw an exception on an error, instead it
* returns the error message(s) as string.
*/
private String checkXML(DocumentBuilder builder, File file, boolean valid) {
String messages = null;
handler.init(file);
try {
builder.parse(file);
} catch (SAXParseException ex) {
handler.error(ex);
} catch (Exception ex) {
messages = "Fatal error processing " + file.getName() + ": " + ex + NL;
}
if (messages == null) {
messages = handler.getMessages();
}
if (!valid) {
if (messages != null) {
// expected error for negative test
messages = null;
} else {
messages = file.getName() + " is not valid, " +
"but the parser did not catch the error.";
}
}
return messages;
}
/** Checks whether the specifeid file is DTD or XSD based. The method
* throws a SAXException if the file has syntax errors. */
private boolean isDTDBased(File file) throws SAXException {
handler.init(file);
try {
Document document = nonValidatingBuilder.parse(file);
return document.getDoctype() != null;
} catch (SAXParseException ex) {
handler.error(ex);
throw new SAXException(handler.getMessages());
} catch (Exception ex) {
throw new SAXException(
"Fatal error processing " + file.getName() + ": " + ex);
}
}
/** ErrorHandler implementation. */
private static class Handler implements ErrorHandler {
private File fileUnderTest;
private String[] lines;
private StringBuffer messages;
public void error(SAXParseException ex) {
append("Handler.error: ", ex);
}
public void fatalError(SAXParseException ex) {
append("Handler.fatalError: ", ex);
}
public void warning(SAXParseException ex) {
append("Handler.warning: ", ex);
}
public void init(File file) {
this.fileUnderTest = file;
this.messages = new StringBuffer();
this.lines = null;
}
public String getMessages() {
return (messages.length() == 0) ? null : messages.toString();
}
private void append(String prefix, SAXParseException ex) {
int lineNumber = ex.getLineNumber();
int columnNumber = ex.getColumnNumber();
messages.append("------------------------").append(NL);
messages.append(prefix).append(fileUnderTest.getName());
messages.append(" [line=").append(lineNumber);
messages.append(", col=").append(columnNumber).append("]: ");
messages.append(ex.getMessage()).append(NL);
messages.append(getErrorLocation(lineNumber, columnNumber));
}
private String[] getLines() {
if (lines == null) {
try {
BufferedReader bufferedReader =
new BufferedReader(new FileReader(fileUnderTest));
ArrayList<String> tmp = new ArrayList<String>();
while (bufferedReader.ready()) {
tmp.add(bufferedReader.readLine());
}
lines = (String[])tmp.toArray(new String[tmp.size()]);
} catch (IOException ex) {
throw new JDOFatalException("getLines: caught IOException", ex);
}
}
return lines;
}
/** Return the error location for the file under test.
*/
private String getErrorLocation(int lineNumber, int columnNumber) {
String[] lines = getLines();
int length = lines.length;
if (lineNumber > length) {
return "Line number " + lineNumber +
" exceeds the number of lines in the file (" +
lines.length + ")";
} else if (lineNumber < 1) {
return "Line number " + lineNumber +
" does not allow retriving the error location.";
}
StringBuffer buf = new StringBuffer();
if (lineNumber > 2) {
buf.append(lines[lineNumber-3]);
buf.append(NL);
buf.append(lines[lineNumber-2]);
buf.append(NL);
}
buf.append(lines[lineNumber-1]);
buf.append(NL);
for (int i = 1; i < columnNumber; ++i) {
buf.append(' ');
}
buf.append("^\n");
if (lineNumber + 1 < length) {
buf.append(lines[lineNumber]);
buf.append(NL);
buf.append(lines[lineNumber+1]);
buf.append(NL);
}
return buf.toString();
}
}
/** Implementation of EntityResolver interface to check the jdo.dtd location
**/
private static class JDOEntityResolver
implements EntityResolver {
private static final String RECOGNIZED_JDO_PUBLIC_ID =
"-//Sun Microsystems, Inc.//DTD Java Data Objects Metadata 2.2//EN";
private static final String RECOGNIZED_JDO_SYSTEM_ID =
"file:/javax/jdo/jdo_2_2.dtd";
private static final String RECOGNIZED_JDO_SYSTEM_ID2 =
"http://java.sun.com/dtd/jdo_2_2.dtd";
private static final String RECOGNIZED_ORM_PUBLIC_ID =
"-//Sun Microsystems, Inc.//DTD Java Data Objects Mapping Metadata 2.2//EN";
private static final String RECOGNIZED_ORM_SYSTEM_ID =
"file:/javax/jdo/orm_2_2.dtd";
private static final String RECOGNIZED_ORM_SYSTEM_ID2 =
"http://java.sun.com/dtd/orm_2_2.dtd";
private static final String RECOGNIZED_JDOQUERY_PUBLIC_ID =
"-//Sun Microsystems, Inc.//DTD Java Data Objects Query Metadata 2.2//EN";
private static final String RECOGNIZED_JDOQUERY_SYSTEM_ID =
"file:/javax/jdo/jdoquery_2_2.dtd";
private static final String RECOGNIZED_JDOQUERY_SYSTEM_ID2 =
"http://java.sun.com/dtd/jdoquery_2_2.dtd";
private static final String JDO_DTD_FILENAME =
"javax/jdo/jdo_2_2.dtd";
private static final String ORM_DTD_FILENAME =
"javax/jdo/orm_2_2.dtd";
private static final String JDOQUERY_DTD_FILENAME =
"javax/jdo/jdoquery_2_2.dtd";
static Map<String,String> publicIds = new HashMap<String,String>();
static Map<String,String> systemIds = new HashMap<String,String>();
static {
publicIds.put(RECOGNIZED_JDO_PUBLIC_ID, JDO_DTD_FILENAME);
publicIds.put(RECOGNIZED_ORM_PUBLIC_ID, ORM_DTD_FILENAME);
publicIds.put(RECOGNIZED_JDOQUERY_PUBLIC_ID, JDOQUERY_DTD_FILENAME);
systemIds.put(RECOGNIZED_JDO_SYSTEM_ID, JDO_DTD_FILENAME);
systemIds.put(RECOGNIZED_ORM_SYSTEM_ID, ORM_DTD_FILENAME);
systemIds.put(RECOGNIZED_JDOQUERY_SYSTEM_ID, JDOQUERY_DTD_FILENAME);
systemIds.put(RECOGNIZED_JDO_SYSTEM_ID2, JDO_DTD_FILENAME);
systemIds.put(RECOGNIZED_ORM_SYSTEM_ID2, ORM_DTD_FILENAME);
systemIds.put(RECOGNIZED_JDOQUERY_SYSTEM_ID2, JDOQUERY_DTD_FILENAME);
}
public InputSource resolveEntity(String publicId, final String systemId)
throws SAXException, IOException
{
// check for recognized ids
String filename = (String)publicIds.get(publicId);
if (filename == null) {
filename = (String)systemIds.get(systemId);
}
final String finalName = filename;
if (finalName == null) {
return null;
} else {
// Substitute the dtd with the one from javax.jdo.jdo.dtd,
// but only if the publicId is equal to RECOGNIZED_PUBLIC_ID
// or there is no publicID and the systemID is equal to
// RECOGNIZED_SYSTEM_ID.
InputStream stream = AccessController.doPrivileged (
new PrivilegedAction<InputStream> () {
public InputStream run () {
return getClass().getClassLoader().
getResourceAsStream(finalName);
}
}
);
if (stream == null) {
throw new JDOFatalException("Cannot load " + finalName +
", because the file does not exist in the jdo.jar file, " +
"or the JDOParser class is not granted permission to read this file. " +
"The metadata .xml file contained PUBLIC=" + publicId +
" SYSTEM=" + systemId + ".");
}
return new InputSource(new InputStreamReader(stream));
}
}
}
/** Helper class to find all test JDO metadata files. */
public static class XMLFinder {
private List<File> metadataFiles = new ArrayList<File>();
private final boolean recursive;
/** Constructor. */
public XMLFinder(String[] fileNames, boolean recursive) {
this.recursive = recursive;
if (fileNames == null) return;
for (int i = 0; i < fileNames.length; i++) {
appendTestFiles(fileNames[i]);
}
}
/** Returns array of files of matching file names. */
private File[] getFiles(File dir, final String suffix) {
FilenameFilter filter = new FilenameFilter() {
public boolean accept(File file, String name) {
return name.endsWith(suffix);
}
};
return dir.listFiles(filter);
}
/** */
private File[] getDirectories(File dir) {
FileFilter filter = new FileFilter() {
public boolean accept(File pathname) {
return pathname.isDirectory();
}
};
return dir.listFiles(filter);
}
/** */
private void appendTestFiles(String fileName) {
File file = new File(fileName);
if (file.isDirectory()) {
processDirectory(file);
} else if (fileName.endsWith(".jdo") ||
fileName.endsWith(".orm") ||
fileName.endsWith(".jdoquery")) {
metadataFiles.add(new File(fileName));
}
}
/** Adds all files with suffix .jdo, .orm and .jdoquery to the list of
* metadata files. Recursively process subdirectories if recursive
* flag is set. */
private void processDirectory(File dir) {
metadataFiles.addAll(Arrays.asList(getFiles(dir, ".jdo")));
metadataFiles.addAll(Arrays.asList(getFiles(dir, ".orm")));
metadataFiles.addAll(Arrays.asList(getFiles(dir, ".jdoquery")));
if (recursive) {
File[] subdirs = getDirectories(dir);
for (int i = 0; i < subdirs.length; i++) {
processDirectory(subdirs[i]);
}
}
}
/** Returns an array of test files with suffix .jdo, .orm or .jdoquery. */
public File[] getMetadataFiles() {
return (File[])metadataFiles.toArray(new File[metadataFiles.size()]);
}
}
/** */
private static String[] checkMetadataSystemProperty() {
String[] ret = null;
String metadata = System.getProperty(METADATA_PROP);
if ((metadata != null) && (metadata.length() > 0)) {
List<String> entries = new ArrayList<String>();
StringTokenizer st = new StringTokenizer(metadata, DELIM);
while (st.hasMoreTokens()) {
entries.add(st.nextToken());
}
ret = (String[])entries.toArray(new String[entries.size()]);
}
return ret;
}
/**
* Command line tool to test JDO metadata files.
* Usage: XMLTestUtil [-r] <file or directory>+
*/
public static void main(String args[]) {
String[] fromProp = checkMetadataSystemProperty();
boolean recursive = Boolean.getBoolean(RECURSIVE_PROP);
// handle command line args
String[] fileNames = null;
if ((args.length > 0) && ("-r".equals(args[0]))) {
recursive = true;
fileNames = new String[args.length - 1];
System.arraycopy(args, 1, fileNames, 0, args.length - 1);
} else {
fileNames = args;
}
// check args
if ((fileNames.length == 0) && (fromProp == null)) {
System.err.println(
"No commandline arguments and system property metadata not defined; " +
"nothing to be tested.\nUsage: XMLTestUtil [-r] <directories>\n" +
"\tAll .jdo, .orm, and .jdoquery files in the directory (recursively) will be tested.");
} else if ((fileNames.length == 0) && (fromProp != null)) {
// use metadata system property
fileNames = fromProp;
} else if ((fileNames.length != 0) && (fromProp != null)) {
System.err.println(
"Commandline arguments specified and system property metadata defined; " +
"ignoring system property metadata.");
}
// run the test
XMLTestUtil xmlTest = new XMLTestUtil();
File[] files = new XMLFinder(fileNames, recursive).getMetadataFiles();
for (int i = 0; i < files.length; i++) {
File file = files[i];
System.out.print("Checking " + file.getPath() + ": ");
String messages = xmlTest.checkXML(file, true);
messages = (messages == null) ? "OK" : NL + messages;
System.out.println(messages);
}
}
}