001: /*
002: * Licensed to the Apache Software Foundation (ASF) under one or more
003: * contributor license agreements. See the NOTICE file distributed with
004: * this work for additional information regarding copyright ownership.
005: * The ASF licenses this file to You under the Apache License, Version 2.0
006: * (the "License"); you may not use this file except in compliance with
007: * the License. You may obtain a copy of the License at
008: *
009: * http://www.apache.org/licenses/LICENSE-2.0
010: *
011: * Unless required by applicable law or agreed to in writing, software
012: * distributed under the License is distributed on an "AS IS" BASIS,
013: * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014: * See the License for the specific language governing permissions and
015: * limitations under the License.
016: *
017: */
018: package org.apache.tools.ant.taskdefs.optional.junit;
019:
020: import java.io.BufferedOutputStream;
021: import java.io.ByteArrayOutputStream;
022: import java.io.File;
023: import java.io.FileOutputStream;
024: import java.io.IOException;
025: import java.io.OutputStream;
026: import java.lang.reflect.Field;
027: import org.apache.tools.ant.BuildException;
028: import org.apache.tools.ant.Project;
029:
030: /**
031: * This class is not used by the framework any more.
032: * We plan to remove it in Ant 1.8
033: * @deprecated since Ant 1.7
034: *
035: */
036: abstract class XalanExecutor {
037: private static final String PACKAGE = "org.apache.tools.ant.taskdefs.optional.junit.";
038:
039: // CheckStyle:VisibilityModifier OFF - bc
040: /** the transformer caller */
041: protected AggregateTransformer caller;
042:
043: // CheckStyle:VisibilityModifier ON
044:
045: /** set the caller for this object. */
046: private void setCaller(AggregateTransformer caller) {
047: this .caller = caller;
048: }
049:
050: /** get the appropriate stream based on the format (frames/noframes) */
051: protected final OutputStream getOutputStream() throws IOException {
052: if (AggregateTransformer.FRAMES.equals(caller.format)) {
053: // dummy output for the framed report
054: // it's all done by extension...
055: return new ByteArrayOutputStream();
056: } else {
057: return new BufferedOutputStream(new FileOutputStream(
058: new File(caller.toDir, "junit-noframes.html")));
059: }
060: }
061:
062: /** override to perform transformation */
063: abstract void execute() throws Exception;
064:
065: /**
066: * Create a valid Xalan executor. It checks if Xalan2 is
067: * present. If none is available, it fails.
068: * @param caller object containing the transformation information.
069: * @throws BuildException thrown if it could not find a valid xalan
070: * executor.
071: */
072: static XalanExecutor newInstance(AggregateTransformer caller)
073: throws BuildException {
074: XalanExecutor executor = null;
075: try {
076: Class clazz = Class.forName(PACKAGE + "Xalan2Executor");
077: executor = (XalanExecutor) clazz.newInstance();
078: } catch (Exception xsltcApacheMissing) {
079: caller.task.log(xsltcApacheMissing.toString());
080: throw new BuildException("Could not find xstlc nor xalan2 "
081: + "in the classpath. Check "
082: + "http://xml.apache.org/xalan-j");
083: }
084: String classNameImpl = executor.getImplementation();
085: String version = executor.getProcVersion(classNameImpl);
086: caller.task.log("Using " + version, Project.MSG_VERBOSE);
087: executor.setCaller(caller);
088: return executor;
089: }
090:
091: /**
092: * This methods should return the classname implementation of the
093: * underlying xslt processor
094: * @return the classname of the implementation, for example:
095: * org.apache.xalan.processor.TransformerFactoryImpl
096: * @see #getProcVersion(String)
097: */
098: protected abstract String getImplementation();
099:
100: /**
101: * Try to discover the xslt processor version based on the
102: * className. There is nothing carved in stone and it can change
103: * anytime, so this is just for the sake of giving additional
104: * information if we can find it.
105: * @param classNameImpl the classname of the underlying xslt processor
106: * @return a string representing the implementation version.
107: * @throws BuildException
108: */
109: protected abstract String getProcVersion(String classNameImpl)
110: throws BuildException;
111:
112: /** a bit simplistic but xsltc data are conveniently private non final */
113: protected final String getXSLTCVersion(String procVersionClassName)
114: throws ClassNotFoundException {
115: // there's a convenient xsltc class version but data are
116: // private so use package information
117: Class procVersion = Class.forName(procVersionClassName);
118: Package pkg = procVersion.getPackage();
119: return pkg.getName() + " " + pkg.getImplementationTitle() + " "
120: + pkg.getImplementationVersion();
121: }
122:
123: /** pretty useful data (Xalan version information) to display. */
124: protected final String getXalanVersion(String procVersionClassName)
125: throws ClassNotFoundException {
126: Class procVersion = Class.forName(procVersionClassName);
127: String pkg = procVersion.getPackage().getName();
128: try {
129: Field f = procVersion.getField("S_VERSION");
130: return pkg + " " + f.get(null).toString();
131: } catch (Exception e) {
132: return pkg + " ?.?";
133: }
134: }
135: }
|