| /* |
| * Copyright (c) 2001-2003 World Wide Web Consortium, (Massachusetts Institute |
| * of Technology, Institut National de Recherche en Informatique et en |
| * Automatique, Keio University). All Rights Reserved. This program is |
| * distributed under the W3C's Software Intellectual Property License. This |
| * program 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 W3C License |
| * http://www.w3.org/Consortium/Legal/ for more details. |
| */ |
| |
| |
| package org.w3c.domts; |
| |
| import java.io.File; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.lang.reflect.Method; |
| import java.net.MalformedURLException; |
| import java.net.URL; |
| |
| import org.w3c.dom.DOMImplementation; |
| import org.w3c.dom.Document; |
| |
| /** |
| * This is an abstract base class for generated DOM tests |
| * |
| */ |
| public abstract class DOMTest /* wBM: implements EventListener */ { |
| private DOMTestDocumentBuilderFactory factory; |
| private int mutationCount = 0; |
| |
| /** |
| * This is the appropriate constructor for tests that make no requirements |
| * on the parser configuration. |
| * |
| * @param factory |
| * must not be null |
| */ |
| public DOMTest(DOMTestDocumentBuilderFactory factory) { |
| if (factory == null) { |
| throw new NullPointerException("factory"); |
| } |
| this.factory = factory; |
| } |
| |
| /** |
| * This constructor is used by tests that must create a modified document |
| * factory to meet requirements on the parser configuration. setFactory |
| * should be called within the test's constructor. |
| */ |
| public DOMTest() { |
| factory = null; |
| } |
| |
| /** |
| * Should only be called in the constructor of a derived type. |
| */ |
| protected void setFactory(DOMTestDocumentBuilderFactory factory) { |
| this.factory = factory; |
| } |
| |
| public boolean hasFeature(String feature, String version) { |
| return factory.hasFeature(feature, version); |
| } |
| |
| public boolean hasSetting(DocumentBuilderSetting setting) { |
| return setting.hasSetting(factory); |
| } |
| |
| protected DOMTestDocumentBuilderFactory getFactory() { |
| return factory; |
| } |
| |
| public DOMImplementation getImplementation() { |
| return factory.getDOMImplementation(); |
| } |
| |
| private URL resolveURI(String baseURI) throws DOMTestLoadException { |
| String docURI = factory.addExtension(baseURI); |
| |
| URL resolvedURI = null; |
| try { |
| resolvedURI = new URL(docURI); |
| if (resolvedURI.getProtocol() != null) { |
| return resolvedURI; |
| } |
| } |
| catch (MalformedURLException ex) { |
| // throw new DOMTestLoadException(ex); |
| } |
| // |
| // build a URL for a test file in the JAR |
| // |
| resolvedURI = getClass().getResource("/" + docURI); |
| if (resolvedURI == null) { |
| // |
| // see if it is an absolute URI |
| // |
| int firstSlash = docURI.indexOf('/'); |
| try { |
| if (firstSlash == 0 |
| || (firstSlash >= 1 |
| && docURI.charAt(firstSlash - 1) == ':')) { |
| resolvedURI = new URL(docURI); |
| } |
| else { |
| // |
| // try the files/level?/spec directory |
| // |
| String filename = getClass().getPackage().getName(); |
| filename = |
| "tests/" |
| + filename.substring(14).replace('.', '/') |
| + "/files/" |
| + docURI; |
| resolvedURI = new java.io.File(filename).toURL(); |
| } |
| } |
| catch (MalformedURLException ex) { |
| throw new DOMTestLoadException(ex); |
| } |
| } |
| |
| if (resolvedURI == null) { |
| throw new DOMTestLoadException( |
| new java.io.FileNotFoundException(docURI)); |
| } |
| return resolvedURI; |
| } |
| |
| public String getResourceURI(String href, String scheme, String contentType) throws |
| DOMTestLoadException { |
| if (scheme == null) { |
| throw new NullPointerException("scheme"); |
| } |
| if ("file".equals(scheme)) { |
| return resolveURI(href).toString(); |
| } |
| if ("http".equals(scheme)) { |
| StringBuffer httpURL = new StringBuffer( |
| System.getProperty("org.w3c.domts.httpbase", |
| "http://localhost:8080/webdav/")); |
| httpURL.append(href); |
| if ("application/pdf".equals(contentType)) { |
| httpURL.append(".pdf"); |
| } |
| else { |
| httpURL.append(".xml"); |
| } |
| return httpURL.toString(); |
| } |
| throw new DOMTestLoadException(new Exception("Unrecognized URI scheme " + |
| scheme)); |
| } |
| |
| public String createTempURI(String scheme) throws DOMTestLoadException { |
| if (scheme == null) { |
| throw new NullPointerException("scheme"); |
| } |
| if ("file".equals(scheme)) { |
| try { |
| File tempFile = File.createTempFile("domts", ".xml"); |
| try { |
| // |
| // if available use JDK 1.4's File.toURI().toString() |
| // |
| Method method = File.class.getMethod("toURI", (Class<?>) null); |
| Object uri = method.invoke(tempFile, (Class<?>) null); |
| return uri.toString(); |
| } |
| catch (NoSuchMethodException ex) { |
| // |
| // File.toURL is not as robust |
| // |
| URL url = tempFile.toURL(); |
| return url.toString(); |
| } |
| } |
| catch (Exception ex) { |
| throw new DOMTestLoadException(ex); |
| } |
| } |
| if ("http".equals(scheme)) { |
| String httpBase = System.getProperty("org.w3c.domts.httpbase", |
| "http://localhost:8080/webdav/"); |
| java.lang.StringBuffer buf = new StringBuffer(httpBase); |
| if (!httpBase.endsWith("/")) { |
| buf.append("/"); |
| } |
| buf.append("tmp"); |
| buf.append( (new java.util.Random()).nextInt(Integer.MAX_VALUE)); |
| buf.append(".xml"); |
| return buf.toString(); |
| } |
| throw new DOMTestLoadException(new Exception("Unrecognized URI scheme " + |
| scheme)); |
| } |
| |
| public Document load(String docURI, boolean willBeModified) throws |
| DOMTestLoadException { |
| Document doc = factory.load(resolveURI(docURI)); |
| // |
| // if will be modified is false and doc is an EventTarget |
| // |
| /* |
| * wBM: if (!willBeModified && doc instanceof EventTarget) { |
| * ((EventTarget) doc).addEventListener("DOMSubtreeModified", this, |
| * false); } |
| */ |
| return doc; |
| } |
| |
| public void preload(String contentType, String docURI, boolean willBeModified) throws |
| DOMTestIncompatibleException { |
| if ("text/html".equals(contentType) || |
| "application/xhtml+xml".equals(contentType)) { |
| if (docURI.startsWith("staff") || docURI.equals("datatype_normalization")) { |
| throw DOMTestIncompatibleException.incompatibleLoad(docURI, contentType); |
| } |
| } |
| } |
| |
| public Object createXPathEvaluator(Document doc) { |
| return factory.createXPathEvaluator(doc); |
| } |
| |
| public InputStream createStream(String bytes) throws DOMTestLoadException, |
| IOException { |
| int byteCount = bytes.length() / 2; |
| byte[] array = new byte[byteCount]; |
| for (int i = 0; i < byteCount; i++) { |
| array[i] = Byte.parseByte(bytes.substring(i * 2, i * 2 + 2), 16); |
| } |
| return new java.io.ByteArrayInputStream(array); |
| } |
| |
| abstract public String getTargetURI(); |
| |
| public final boolean isCoalescing() { |
| return factory.isCoalescing(); |
| } |
| |
| public final boolean isExpandEntityReferences() { |
| return factory.isExpandEntityReferences(); |
| } |
| |
| public final boolean isIgnoringElementContentWhitespace() { |
| return factory.isIgnoringElementContentWhitespace(); |
| } |
| |
| public final boolean isNamespaceAware() { |
| return factory.isNamespaceAware(); |
| } |
| |
| public final boolean isValidating() { |
| return factory.isValidating(); |
| } |
| |
| public final boolean isSigned() { |
| return true; |
| } |
| |
| public final boolean isHasNullString() { |
| return true; |
| } |
| |
| public final String getContentType() { |
| return factory.getContentType(); |
| } |
| |
| /** |
| * Implementation of EventListener.handleEvent |
| * |
| * This method is called when a mutation is reported for a document that |
| * was declared to not be modified during testing |
| * |
| * @param evt |
| * mutation event |
| */ |
| /* |
| * wBM: public final void handleEvent(Event evt) { mutationCount++; } |
| */ |
| |
| public final int getMutationCount() { |
| return mutationCount; |
| } |
| |
| } |