| /* |
| * |
| * Derby - Class org.apache.derbyTesting.junit.JAXPFinder |
| * |
| * 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 org.apache.derbyTesting.junit; |
| |
| import java.net.URL; |
| |
| /* The following import is of a JAXP API class. The JAXP API classes |
| * are included within JVMs that are 1.4 and later. However, 1.3 and |
| * J2ME JVMs do not include the JAXP API classes. As a result this |
| * file can only be built with 1.4 or later (see build.xml in this |
| * directory). We have to separate this class out from junit/XML.java |
| * because XML.java will be instantiated for any JUnit test, regardless |
| * of whether or not the the required JAXP classes are in the user's |
| * classpath. This means that if we imported the JAXP class into |
| * junit/XML.java, a user who tried to run a JUnit test without |
| * the JAXP interface in his/her classpath (which typically means |
| * J2ME is being used) would see a NoClassFoundError. (DERBY-2153). |
| * That's not what we want; instead, all tests that do *not* rely on |
| * JAXP should run as normal and any tests that require JAXP should be |
| * silently skipped. |
| * |
| * To accomplish this goal we import/reference DocumentBuilderFactory |
| * in *this* class (JAXPFinder). Then we *only* make calls on this |
| * JAXPFinder if we know for certain that all required XML classes |
| * are in the user's classpath. With this restriction in place we |
| * can ensure that the JAXP class will never be instantiated for |
| * environments which do not have a JAXP parser. Thus the JUnit |
| * harness will run/skip tests as expected whether or not the user's |
| * classpath includes a JAXP parser. |
| */ |
| import javax.xml.parsers.DocumentBuilderFactory; |
| |
| /** |
| * Simple class used for determining the location of the jar |
| * file (based on the user's classpath) that contains the JAXP |
| * implementation. |
| */ |
| public class JAXPFinder { |
| |
| /** |
| * String form of the URL for the jar file in the user's classpath |
| * that holds the JAXP implementation in use. If the implementation |
| * is embedded within, or endorsed by, the JVM, then we will set this |
| * field to be an empty string. |
| */ |
| private static String jaxpURLString = null; |
| |
| /** |
| * Return the string form of the URL for the jar file that contains |
| * whichever JAXP parser implementation is picked up from the user's |
| * classpath. If the JAXP parser is not in the user's classpath, |
| * then it must be embedded within the JVM (either implicitly or else |
| * through use of "endorsed standards" jars), in which case we return |
| * null. |
| * |
| * NOTE: Assumption is that we only get here if we know there is in |
| * fact a JAXP parser available to the JVM. I.e. if a call to |
| * the "classpathHasXalanAndJAXP()" method of junit/XML.java returns |
| * true. |
| */ |
| protected static String getJAXPParserLocation() |
| { |
| // Only get the URL if we have not already done it. |
| if (jaxpURLString == null) |
| { |
| /* Figure out which JAXP implementation we have by |
| * instantiating a DocumentBuilderFactory and then getting |
| * the implementation-specific class for that object. |
| * Note that we cannot just use: |
| * |
| * SecurityManagerSetup.getURL(DocumentBuilderFactory.class) |
| * |
| * because the 1.4, 1.5, and 1.6 JVMs (at least, Sun and IBM) |
| * all embed the JAXP API classes, so any attempts to look |
| * up the URL for DocumentBuilderFactory.class will return |
| * null for those JVMs. But in the case of, say, Sun 1.5, the |
| * JAXP *implementation* classes are not embedded. So if we're |
| * running with Sun 1.5 and we have an external JAXP |
| * implementation (say Xerces) in the classpath, we need to |
| * find the URL for that external jar file. By instantiating |
| * DocumentBuilderFactory and then using the implementation- |
| * specific class name we ensure that, for external (w.r.t the |
| * JVM) JAXP implementations, we can find the implementation |
| * jar file and thus we can assign the correct permissions. |
| */ |
| URL jaxpURL = SecurityManagerSetup.getURL( |
| DocumentBuilderFactory.newInstance().getClass()); |
| |
| /* If we found a URL then the JAXP parser is in the classpath |
| * in some jar external to the JVM; in that case we have the |
| * the jar's location so we use/return that. Otherwise we |
| * assume that the JAXP parser is either embedded within the |
| * JVM or else "endorsed" by it. In those cases we set our |
| * URL string to be the empty string, which is non-null and |
| * thus we will only execute this try-catch once. |
| */ |
| jaxpURLString = |
| (jaxpURL == null) ? "" : jaxpURL.toExternalForm(); |
| } |
| |
| // If we didn't find the JAXP parser URL, then return null. |
| return ((jaxpURLString.length() == 0) ? null : jaxpURLString); |
| } |
| } |