| /* |
| * 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.poi.ss.excelant; |
| |
| import static org.apache.poi.POITestCase.assertContains; |
| import static org.apache.poi.POITestCase.assertNotContained; |
| |
| import java.io.File; |
| import java.io.PrintStream; |
| import java.net.URL; |
| |
| import junit.framework.TestCase; |
| |
| import org.apache.poi.POIDataSamples; |
| import org.apache.tools.ant.BuildEvent; |
| import org.apache.tools.ant.BuildException; |
| import org.apache.tools.ant.BuildListener; |
| import org.apache.tools.ant.Project; |
| import org.apache.tools.ant.ProjectHelper; |
| |
| /** |
| * A BuildFileTest is a TestCase which executes targets from an Ant buildfile |
| * for testing. |
| * <p> |
| * This class provides a number of utility methods for particular build file |
| * tests which extend this class. |
| * |
| * @see <a href="http://svn.apache.org/repos/asf/ant/core/trunk/src/tests/junit/org/apache/tools/ant/BuildFileTest.java"> |
| * http://svn.apache.org/repos/asf/ant/core/trunk/src/tests/junit/org/apache/tools/ant/BuildFileTest.java</a> |
| */ |
| public abstract class BuildFileTest extends TestCase { |
| |
| protected Project project; |
| |
| private StringBuffer logBuffer; |
| private StringBuffer fullLogBuffer; |
| private StringBuffer outBuffer; |
| private StringBuffer errBuffer; |
| private BuildException buildException; |
| |
| /** |
| * Default constructor for the BuildFileTest object. |
| */ |
| public BuildFileTest() { |
| super(); |
| } |
| |
| /** |
| * Constructor for the BuildFileTest object. |
| * |
| * @param name string to pass up to TestCase constructor |
| */ |
| public BuildFileTest(String name) { |
| super(name); |
| } |
| |
| /** |
| * Automatically calls the target called "tearDown" |
| * from the build file tested if it exits. |
| * <p> |
| * This allows to use Ant tasks directly in the build file |
| * to clean up after each test. Note that no "setUp" target |
| * is automatically called, since it's trivial to have a |
| * test target depend on it. |
| */ |
| @Override |
| protected void tearDown() throws Exception { |
| if (project == null) { |
| /* |
| * Maybe the BuildFileTest was subclassed and there is |
| * no initialized project. So we could avoid getting a |
| * NPE. |
| * If there is an initialized project getTargets() does |
| * not return null as it is initialized by an empty |
| * HashSet. |
| */ |
| return; |
| } |
| final String tearDown = "tearDown"; |
| if (project.getTargets().containsKey(tearDown)) { |
| project.executeTarget(tearDown); |
| } |
| } |
| |
| /** |
| * run a target, expect for any build exception |
| * |
| * @param target target to run |
| * @param cause information string to reader of report |
| */ |
| public void expectBuildException(String target, String cause) { |
| expectSpecificBuildException(target, cause, null); |
| } |
| |
| /** |
| * Assert that only the given message has been logged with a |
| * priority <= INFO when running the given target. |
| */ |
| public void expectLog(String target, String log) { |
| executeTarget(target); |
| String realLog = getLog(); |
| assertEquals(log, realLog); |
| } |
| |
| /** |
| * Assert that the given substring is in the log messages. |
| */ |
| public void assertLogContaining(String substring) { |
| assertContains(getLog(), substring); |
| } |
| |
| /** |
| * Assert that the given substring is not in the log messages. |
| */ |
| public void assertLogNotContaining(String substring) { |
| assertNotContained(getLog(), substring); |
| } |
| |
| /** |
| * Assert that the given substring is in the output messages. |
| * |
| * @since Ant1.7 |
| */ |
| public void assertOutputContaining(String substring) { |
| assertOutputContaining(null, substring); |
| } |
| |
| /** |
| * Assert that the given substring is in the output messages. |
| * |
| * @param message Print this message if the test fails. Defaults to |
| * a meaningful text if <tt>null</tt> is passed. |
| * @since Ant1.7 |
| */ |
| public void assertOutputContaining(String message, String substring) { |
| assertContains("output: " + message, getOutput(), substring); |
| } |
| |
| /** |
| * Assert that the given substring is not in the output messages. |
| * |
| * @param message Print this message if the test fails. Defaults to |
| * a meaningful text if <tt>null</tt> is passed. |
| * @since Ant1.7 |
| */ |
| public void assertOutputNotContaining(String message, String substring) { |
| assertNotContained(getOutput(), substring); |
| } |
| |
| /** |
| * Assert that the given message has been logged with a priority <= INFO when running the |
| * given target. |
| */ |
| public void expectLogContaining(String target, String log) { |
| executeTarget(target); |
| assertLogContaining(log); |
| } |
| |
| /** |
| * Assert that the given message has not been logged with a |
| * priority <= INFO when running the given target. |
| */ |
| public void expectLogNotContaining(String target, String log) { |
| executeTarget(target); |
| assertLogNotContaining(log); |
| } |
| |
| /** |
| * Gets the log the BuildFileTest object. |
| * Only valid if configureProject() has been called. |
| * |
| * @return The log value |
| * @pre logBuffer!=null |
| */ |
| public String getLog() { |
| return logBuffer.toString(); |
| } |
| |
| /** |
| * Assert that the given message has been logged with a priority |
| * >= VERBOSE when running the given target. |
| */ |
| public void expectDebuglog(String target, String log) { |
| executeTarget(target); |
| String realLog = getFullLog(); |
| assertEquals(log, realLog); |
| } |
| |
| /** |
| * Assert that the given substring is in the log messages. |
| */ |
| public void assertDebuglogContaining(String substring) { |
| String realLog = getFullLog(); |
| assertContains("expecting debug log to contain \"" + substring |
| + "\" log was \"" |
| + realLog + "\"", |
| realLog, substring); |
| } |
| |
| /** |
| * Gets the log the BuildFileTest object. |
| * <p> |
| * Only valid if configureProject() has been called. |
| * |
| * @return The log value |
| * @pre fullLogBuffer!=null |
| */ |
| public String getFullLog() { |
| return fullLogBuffer.toString(); |
| } |
| |
| /** |
| * execute the target, verify output matches expectations |
| * |
| * @param target target to execute |
| * @param output output to look for |
| */ |
| public void expectOutput(String target, String output) { |
| executeTarget(target); |
| String realOutput = getOutput(); |
| assertEquals(output, realOutput.trim()); |
| } |
| |
| /** |
| * Executes the target, verify output matches expectations |
| * and that we got the named error at the end |
| * |
| * @param target target to execute |
| * @param output output to look for |
| * @param error Description of Parameter |
| */ |
| public void expectOutputAndError(String target, String output, String error) { |
| executeTarget(target); |
| String realOutput = getOutput(); |
| assertEquals(output, realOutput); |
| String realError = getError(); |
| assertEquals(error, realError); |
| } |
| |
| public String getOutput() { |
| return cleanBuffer(outBuffer); |
| } |
| |
| public String getError() { |
| return cleanBuffer(errBuffer); |
| } |
| |
| public BuildException getBuildException() { |
| return buildException; |
| } |
| |
| private String cleanBuffer(StringBuffer buffer) { |
| StringBuffer cleanedBuffer = new StringBuffer(); |
| for (int i = 0; i < buffer.length(); i++) { |
| char ch = buffer.charAt(i); |
| if (ch != '\r') { |
| cleanedBuffer.append(ch); |
| } |
| } |
| return cleanedBuffer.toString(); |
| } |
| |
| /** |
| * Sets up to run the named project |
| * |
| * @param filename name of project file to run |
| */ |
| public void configureProject(String filename) throws BuildException { |
| configureProject(filename, Project.MSG_DEBUG); |
| } |
| |
| /** |
| * Sets up to run the named project |
| * |
| * @param filename name of project file to run |
| */ |
| public void configureProject(String filename, int logLevel) |
| throws BuildException { |
| logBuffer = new StringBuffer(); |
| fullLogBuffer = new StringBuffer(); |
| project = new Project(); |
| project.init(); |
| project.setNewProperty("data.dir.name", getDataDir()); |
| File antFile = new File(System.getProperty("root"), filename); |
| project.setUserProperty("ant.file", antFile.getAbsolutePath()); |
| project.addBuildListener(new AntTestListener(logLevel)); |
| ProjectHelper.configureProject(project, antFile); |
| } |
| |
| /** |
| * Executes a target we have set up |
| * |
| * @param targetName target to run |
| * @pre configureProject has been called |
| */ |
| public void executeTarget(String targetName) { |
| PrintStream sysOut = System.out; |
| PrintStream sysErr = System.err; |
| try { |
| sysOut.flush(); |
| sysErr.flush(); |
| outBuffer = new StringBuffer(); |
| PrintStream out = new PrintStream(new AntOutputStream(outBuffer)); |
| System.setOut(out); |
| errBuffer = new StringBuffer(); |
| PrintStream err = new PrintStream(new AntOutputStream(errBuffer)); |
| System.setErr(err); |
| logBuffer = new StringBuffer(); |
| fullLogBuffer = new StringBuffer(); |
| buildException = null; |
| project.executeTarget(targetName); |
| } finally { |
| System.setOut(sysOut); |
| System.setErr(sysErr); |
| } |
| |
| } |
| |
| /** |
| * Get the project which has been configured for a test. |
| * |
| * @return the Project instance for this test. |
| */ |
| public Project getProject() { |
| return project; |
| } |
| |
| /** |
| * Gets the directory of the project. |
| * |
| * @return the base dir of the project |
| */ |
| public File getProjectDir() { |
| return project.getBaseDir(); |
| } |
| |
| /** |
| * Runs a target, wait for a build exception. |
| * |
| * @param target target to run |
| * @param cause information string to reader of report |
| * @param msg the message value of the build exception we are waiting |
| * for set to null for any build exception to be valid |
| */ |
| public void expectSpecificBuildException(String target, String cause, String msg) { |
| try { |
| executeTarget(target); |
| } catch (org.apache.tools.ant.BuildException ex) { |
| buildException = ex; |
| if ((null != msg) && (!ex.getMessage().equals(msg))) { |
| fail("Should throw BuildException because '" + cause |
| + "' with message '" + msg |
| + "' (actual message '" + ex.getMessage() + "' instead)"); |
| } |
| return; |
| } |
| fail("Should throw BuildException because: " + cause); |
| } |
| |
| /** |
| * run a target, expect an exception string |
| * containing the substring we look for (case sensitive match) |
| * |
| * @param target target to run |
| * @param cause information string to reader of report |
| * @param contains substring of the build exception to look for |
| */ |
| public void expectBuildExceptionContaining(String target, String cause, String contains) { |
| try { |
| executeTarget(target); |
| } catch (org.apache.tools.ant.BuildException ex) { |
| buildException = ex; |
| if ((null != contains) && (!ex.getMessage().contains(contains))) { |
| fail("Should throw BuildException because '" + cause + "' with message containing '" + contains + "' (actual message '" + ex.getMessage() + "' instead)"); |
| } |
| return; |
| } |
| fail("Should throw BuildException because: " + cause); |
| } |
| |
| /** |
| * call a target, verify property is as expected |
| * |
| * @param target build file target |
| * @param property property name |
| * @param value expected value |
| */ |
| public void expectPropertySet(String target, String property, String value) { |
| executeTarget(target); |
| assertPropertyEquals(property, value); |
| } |
| |
| /** |
| * assert that a property equals a value; comparison is case sensitive. |
| * |
| * @param property property name |
| * @param value expected value |
| */ |
| public void assertPropertyEquals(String property, String value) { |
| String result = project.getProperty(property); |
| assertEquals("property " + property, value, result); |
| } |
| |
| /** |
| * assert that a property equals "true". |
| * |
| * @param property property name |
| */ |
| public void assertPropertySet(String property) { |
| assertPropertyEquals(property, "true"); |
| } |
| |
| /** |
| * assert that a property is null. |
| * |
| * @param property property name |
| */ |
| public void assertPropertyUnset(String property) { |
| String result = project.getProperty(property); |
| if (result != null) { |
| fail("Expected property " + property |
| + " to be unset, but it is set to the value: " + result); |
| } |
| } |
| |
| /** |
| * call a target, verify named property is "true". |
| * |
| * @param target build file target |
| * @param property property name |
| */ |
| public void expectPropertySet(String target, String property) { |
| expectPropertySet(target, property, "true"); |
| } |
| |
| /** |
| * Call a target, verify property is null. |
| * |
| * @param target build file target |
| * @param property property name |
| */ |
| public void expectPropertyUnset(String target, String property) { |
| expectPropertySet(target, property, null); |
| } |
| |
| /** |
| * Retrieve a resource from the caller classloader to avoid |
| * assuming a vm working directory. The resource path must be |
| * relative to the package name or absolute from the root path. |
| * |
| * @param resource the resource to retrieve its url. |
| * @throws junit.framework.AssertionFailedError |
| * if the resource is not found. |
| */ |
| public URL getResource(String resource) { |
| URL url = getClass().getResource(resource); |
| assertNotNull("Could not find resource :" + resource, url); |
| return url; |
| } |
| |
| public static String getDataDir() { |
| String dataDirName = System.getProperty(POIDataSamples.TEST_PROPERTY); |
| return dataDirName == null ? "test-data" : dataDirName; |
| } |
| |
| /** |
| * an output stream which saves stuff to our buffer. |
| */ |
| protected static class AntOutputStream extends java.io.OutputStream { |
| private StringBuffer buffer; |
| |
| public AntOutputStream(StringBuffer buffer) { |
| this.buffer = buffer; |
| } |
| |
| @Override |
| public void write(int b) { |
| buffer.append((char) b); |
| } |
| } |
| |
| /** |
| * Our own personal build listener. |
| */ |
| private class AntTestListener implements BuildListener { |
| private int logLevel; |
| |
| /** |
| * Constructs a test listener which will ignore log events |
| * above the given level. |
| */ |
| public AntTestListener(int logLevel) { |
| this.logLevel = logLevel; |
| } |
| |
| /** |
| * Fired before any targets are started. |
| */ |
| @Override |
| public void buildStarted(BuildEvent event) { |
| } |
| |
| /** |
| * Fired after the last target has finished. This event |
| * will still be thrown if an error occurred during the build. |
| * |
| * @see BuildEvent#getException() |
| */ |
| @Override |
| public void buildFinished(BuildEvent event) { |
| } |
| |
| /** |
| * Fired when a target is started. |
| * |
| * @see BuildEvent#getTarget() |
| */ |
| @Override |
| public void targetStarted(BuildEvent event) { |
| //System.out.println("targetStarted " + event.getTarget().getName()); |
| } |
| |
| /** |
| * Fired when a target has finished. This event will |
| * still be thrown if an error occurred during the build. |
| * |
| * @see BuildEvent#getException() |
| */ |
| @Override |
| public void targetFinished(BuildEvent event) { |
| //System.out.println("targetFinished " + event.getTarget().getName()); |
| } |
| |
| /** |
| * Fired when a task is started. |
| * |
| * @see BuildEvent#getTask() |
| */ |
| @Override |
| public void taskStarted(BuildEvent event) { |
| //System.out.println("taskStarted " + event.getTask().getTaskName()); |
| } |
| |
| /** |
| * Fired when a task has finished. This event will still |
| * be throw if an error occurred during the build. |
| * |
| * @see BuildEvent#getException() |
| */ |
| @Override |
| public void taskFinished(BuildEvent event) { |
| //System.out.println("taskFinished " + event.getTask().getTaskName()); |
| } |
| |
| /** |
| * Fired whenever a message is logged. |
| * |
| * @see BuildEvent#getMessage() |
| * @see BuildEvent#getPriority() |
| */ |
| @Override |
| public void messageLogged(BuildEvent event) { |
| if (event.getPriority() > logLevel) { |
| // ignore event |
| return; |
| } |
| |
| if (event.getPriority() == Project.MSG_INFO || |
| event.getPriority() == Project.MSG_WARN || |
| event.getPriority() == Project.MSG_ERR) { |
| logBuffer.append(event.getMessage()); |
| } |
| fullLogBuffer.append(event.getMessage()); |
| } |
| } |
| |
| } |