ant/org.eclipse.ant.tests.core/tests/org/eclipse/ant/tests/core/tests/OptionTests.java - gerrit/platform/eclipse.platform - Git at Google

 /*******************************************************************************
  * Copyright (c) 2000, 2003 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Common Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/cpl-v10.html
  *
  * Contributors:
  *     IBM Corporation - initial API and implementation
  *******************************************************************************/
 package org.eclipse.ant.tests.core.tests;


 import java.io.BufferedInputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.util.List;

 import org.eclipse.ant.tests.core.AbstractAntTest;
 import org.eclipse.ant.tests.core.testplugin.AntTestChecker;
 import org.eclipse.core.resources.IFile;
 import org.eclipse.core.runtime.CoreException;

 public class OptionTests extends AbstractAntTest {

 	protected static final String START_OF_HELP= "ant [options] [target [target2 [target3] ...]]";
 	protected static final String VERSION= "Apache Ant version 1.5.2 compiled on February 28 2003";

 	public OptionTests(String name) {
 		super(name);
 	}

 	/**
 	 * Tests the "-help" option
 	 */
 	public void testHelp() throws CoreException {
 		run("TestForEcho.xml", new String[]{"-help"});
 		assertTrue("One message should have been logged", AntTestChecker.getDefault().getMessagesLoggedCount() == 1);
 		assertTrue("Help is incorrect", getLastMessageLogged() != null && getLastMessageLogged().startsWith(START_OF_HELP));
 	}

 	/**
 	 * Tests the "-version" option
 	 */
 	public void testVersion() throws CoreException {
 		run("TestForEcho.xml", new String[]{"-version"});
 		assertTrue("One message should have been logged", AntTestChecker.getDefault().getMessagesLoggedCount() == 1);
 		assertTrue("Version is incorrect", VERSION.equals(getLastMessageLogged()));
 	}

 	/**
 	 * Tests the "-projecthelp" option when it will not show (quite mode)
 	 */
 	public void testProjecthelp() throws CoreException {
 		run("TestForEcho.xml", new String[]{"-projecthelp"});
 		assertTrue("4 messages should have been logged; was " + AntTestChecker.getDefault().getMessagesLoggedCount(), AntTestChecker.getDefault().getMessagesLoggedCount() == 4);
 		assertTrue("Project help is incorrect", getLastMessageLogged().startsWith("Subtargets:"));
 	}

 	/**
 	 * Tests the "-projecthelp" option when it will not show (quite mode)
 	 */
 	public void testProjecthelpQuiet() throws CoreException {
 		run("TestForEcho.xml", new String[]{"-projecthelp", "-q"});
 		assertTrue("no messages should have been logged; was " + AntTestChecker.getDefault().getMessagesLoggedCount(), AntTestChecker.getDefault().getMessagesLoggedCount() == 0);
 	}

 	/**
 	 * Tests the "-listener" option with a listener that is not an instance of BuildListener
 	 */
 	public void testListenerBad() throws CoreException {
 		try {
 			run("TestForEcho.xml", new String[]{"-listener", "java.lang.String"});
 		} catch (CoreException ce) {
 			String msg= ce.getMessage();
 			assertTrue("Message incorrect!: " + msg, msg.equals("java.lang.String which was specified to be a build listener is not an instance of org.apache.tools.ant.BuildListener."));
 			return;
 		}
 		assertTrue("A core exception should have occurred wrappering a class cast exception", false);
 	}

 	/**
 	 * Tests passing an unrecognized argument
 	 */
 	public void testUnknownArg() throws CoreException {

 		run("TestForEcho.xml", new String[]{"-listenr"});
 		//unknown arg, print usage
 		assertTrue("Two message should have been logged", AntTestChecker.getDefault().getMessagesLoggedCount() == 2);
 		assertTrue("Should have printed the usage", getLastMessageLogged() != null && getLastMessageLogged().startsWith(START_OF_HELP));
 	}

 	/**
 	 * Tests specifying the -logfile with no arg
 	 */
 	public void testLogFileWithNoArg() throws CoreException {
 		try {
 			run("TestForEcho.xml", new String[]{"-logfile"});
 		} catch (CoreException ce) {
 			return;
 		}
 		assertTrue("You must specify a log file when using the -log argument", false);
 	}

 	/**
 	 * Tests specifying the -logfile
 	 */
 	public void testLogFile() throws CoreException, IOException {
 		run("TestForEcho.xml", new String[]{"-logfile", "TestLogFile.txt"});
 		IFile file= checkFileExists("TestLogFile.txt");
 		InputStream stream =file.getContents();

 		InputStreamReader in= null;
 		try {
 			in= new InputStreamReader(new BufferedInputStream(stream));
 			StringBuffer buffer= new StringBuffer();
 			char[] readBuffer= new char[2048];
 			int n= in.read(readBuffer);
 			while (n > 0) {
 				buffer.append(readBuffer, 0, n);
 				n= in.read(readBuffer);
 			}
 			assertTrue("File should have started with Buildfile", buffer.toString().startsWith("Buildfile"));
 		} finally {
 			in.close();
 			stream.close();
 		}

 	}

 	/**
 	 * Tests specifying the -logger with no arg
 	 */
 	public void testLoggerWithNoArg() throws CoreException {
 		try {
 			run("TestForEcho.xml", new String[]{"-logger"});
 		} catch (CoreException ce) {
 			return;
 		}
 		assertTrue("You must specify a classname when using the -logger argument", false);
 	}

 	/**
 	 * Tests the "-logger" option with a logger that is not an instance of BuildLogger
 	 */
 	public void testLoggerBad() throws CoreException {
 		try {
 			run("TestForEcho.xml", new String[]{"-logger", "java.lang.String"});
 		} catch (CoreException ce) {
 			return;
 		}
 		assertTrue("A core exception should have occurred wrappering a class cast exception", false);
 	}

 	/**
 	 * Tests the "-logger" option with two loggers specified...only one is allowed
 	 */
 	public void testTwoLoggers() throws CoreException {
 		try {
 			run("TestForEcho.xml", new String[]{"-logger", "java.lang.String", "-q", "-logger", "java.lang.String"});
 		} catch (CoreException ce) {
 			return;
 		}
 		assertTrue("As only one logger can be specified", false);
 	}

 	/**
 	 * Tests specifying the -listener with no arg
 	 */
 	public void testListenerWithNoArg() throws CoreException {
 		try {
 			run("TestForEcho.xml", new String[]{"-listener"});
 		} catch (CoreException ce) {
 			return;
 		}
 		assertTrue("You must specify a listeners when using the -listener argument ", false);
 	}

 	/**
 	 * Tests specifying the -listener with a class that will not be found
 	 */
 	public void testListenerClassNotFound() throws CoreException {
 		try {
 			run("TestForEcho.xml", new String[]{"-listener", "TestBuildListener"});
 		} catch (CoreException e) {
 			String message= e.getStatus().getException().getMessage();
 			assertTrue("Should be ClassNotFoundException", "java.lang.ClassNotFoundException: TestBuildListener".equals(message));
 			return;
 		}
 		assertTrue("A CoreException should have occurred as the listener class will not be found", false);

 	}
 	/**
 	 * Tests specifying the -listener option
 	 */
 	public void testListener() throws CoreException {
 		run("TestForEcho.xml", new String[]{"-listener", ANT_TEST_BUILD_LISTENER});
 		assertSuccessful();
 		assertTrue("A listener should have been added named: " + ANT_TEST_BUILD_LISTENER, ANT_TEST_BUILD_LISTENER.equals(AntTestChecker.getDefault().getLastListener()));
 	}

 	/**
 	 * Tests specifying the -listener option multiple times...which is allowed
 	 */
 	public void testListenerMultiple() throws CoreException {
 		run("TestForEcho.xml", new String[]{"-listener", ANT_TEST_BUILD_LISTENER, "-listener", ANT_TEST_BUILD_LISTENER});
 		assertSuccessful();
 		assertTrue("A listener should have been added named: " + ANT_TEST_BUILD_LISTENER, ANT_TEST_BUILD_LISTENER.equals(AntTestChecker.getDefault().getLastListener()));
 		assertTrue("Two listeners should have been added", AntTestChecker.getDefault().getListeners().size() == 2);
 	}

 	/**
 	 * Tests specifying the -listener option multiple times, with one missing the arg
 	 */
 	public void testListenerMultipleWithBad() throws CoreException {
 		try {
 			run("TestForEcho.xml", new String[]{"-listener", ANT_TEST_BUILD_LISTENER, "-q", "-listener", "-verbose"});
 		} catch(CoreException e) {
 			//You must specify a listener for all -listener arguments
 			return;
 		}
 		assertTrue("You must specify a listener for all -listener arguments ", false);
 	}

 	/**
 	 * Tests specifying the -buildfile with no arg
 	 */
 	public void testBuildFileWithNoArg() throws CoreException {
 		try {
 			run("TestForEcho.xml", new String[]{"-buildfile"});
 		} catch (CoreException ce) {
 			//You must specify a buildfile when using the -buildfile argument
 			return;
 		}
 		assertTrue("You must specify a buildfile when using the -buildfile argument", false);
 	}

 	/**
 	 * Tests specifying the -buildfile
 	 */
 	public void testBuildFile() throws CoreException {
 		String buildFileName= getProject().getFolder("scripts").getFile("echoing.xml").getLocation().toFile().getAbsolutePath();
 		run("TestForEcho.xml", new String[]{"-buildfile", buildFileName}, false, "scripts");

 		assertTrue("Should have been 1 tasks, was: " + AntTestChecker.getDefault().getTaskStartedCount(), AntTestChecker.getDefault().getTaskStartedCount() == 1);

 	}

 	/**
 	 * Tests specifying a target at the command line that does not exist.
 	 */
 	public void testSpecifyBadTargetAsArg() throws CoreException {
 		try {
 			run("TestForEcho.xml", new String[]{"echo2"}, false);
 		} catch (CoreException ce) {
 			return;
 		}
 		assertTrue("A core exception should have occurred as the target does not exist", false);
 	}

 	/**
 	 * Tests specifying a target at the command line
 	 */
 	public void testSpecifyTargetAsArg() throws CoreException {
 		run("echoing.xml", new String[]{"echo3"}, false);
 		assertTrue("3 messages should have been logged; was " + AntTestChecker.getDefault().getMessagesLoggedCount(), AntTestChecker.getDefault().getMessagesLoggedCount() == 3);
 		assertSuccessful();
 	}

 	/**
 	 * Tests specifying a target at the command line with other options
 	 */
 	public void testSpecifyTargetAsArgWithOtherOptions() throws CoreException {
 		run("echoing.xml", new String[]{"-logfile", "TestLogFile.txt", "echo3"}, false);
 		assertTrue("4 messages should have been logged; was " + AntTestChecker.getDefault().getMessagesLoggedCount(), AntTestChecker.getDefault().getMessagesLoggedCount() == 4);
 		List messages= AntTestChecker.getDefault().getMessages();
 		//ensure that echo3 target executed and only that target
 		assertTrue("echo3 target not executed", messages.get(2).equals("echo3"));
 		assertSuccessful();
 	}

 	/**
 	 * Tests specifying targets at the command line with other options
 	 */
 	public void testSpecifyTargetsAsArgWithOtherOptions() throws CoreException {
 		run("echoing.xml", new String[]{"-logfile", "TestLogFile.txt", "echo2", "echo3"}, false);
 		assertTrue("5 messages should have been logged; was " + AntTestChecker.getDefault().getMessagesLoggedCount(), AntTestChecker.getDefault().getMessagesLoggedCount() == 5);
 		List messages= AntTestChecker.getDefault().getMessages();
 		//ensure that echo2 target executed
 		assertTrue("echo2 target not executed", messages.get(2).equals("echo2"));
 		assertSuccessful();
 	}

 	/**
 	 * Tests specifying a target at the command line and quiet reporting
 	 */
 	public void testSpecifyTargetAsArgAndQuiet() throws CoreException {
 		run("echoing.xml", new String[]{"-logfile", "TestLogFile.txt", "echo3", "-quiet"}, false);
 		assertTrue("1 message should have been logged; was " + AntTestChecker.getDefault().getMessagesLoggedCount(), AntTestChecker.getDefault().getMessagesLoggedCount() == 1);
 	}

 	/**
 	 * Tests specifying a target at the command line and quiet reporting
 	 */
 	public void testMinusD() throws CoreException {
 		run("echoing.xml", new String[]{"-DAntTests=testing", "-Declipse.is.cool=true"}, false);
 		assertSuccessful();
 		assertTrue("eclipse.is.cool should have been set as true", "true".equals(AntTestChecker.getDefault().getUserProperty("eclipse.is.cool")));
 		assertTrue("AntTests should have a value of testing", "testing".equals(AntTestChecker.getDefault().getUserProperty("AntTests")));
 		assertNull("my.name was not set and should be null", AntTestChecker.getDefault().getUserProperty("my.name"));
 	}

 	public void testPropertyFileWithNoArg() throws CoreException {
 		try {
 			run("TestForEcho.xml", new String[]{"-propertyfile"});
 		} catch (CoreException ce) {
 			String msg= (String)AntTestChecker.getDefault().getMessages().get(0);
 			assertTrue("Message incorrect!: " + msg, msg.equals("You must specify a property filename when using the -propertyfile argument"));
 			return;
 		}
 		assertTrue("You must specify a property filename when using the -propertyfile argument", false);
 	}

 	/**
 	 * A build should succeed when a property file is not found.
 	 * The error is reported and the build continues.
 	 */
 	public void testPropertyFileFileNotFound() throws CoreException {

 		run("TestForEcho.xml", new String[]{"-propertyfile", "qq.txt"});
 		assertSuccessful();
 		String msg= (String)AntTestChecker.getDefault().getMessages().get(0);
 		assertTrue("Message incorrect!: " + msg, msg.startsWith("Could not load property file qq.txt:"));
 	}

 	public void testPropertyFile() throws CoreException {
 		run("TestForEcho.xml", new String[]{"-propertyfile", getPropertyFileName()});
 		assertSuccessful();
 		assertTrue("eclipse.is.cool should have been set as Yep", "Yep".equals(AntTestChecker.getDefault().getUserProperty("eclipse.is.cool")));
 		assertTrue("AntTests should have a value of testing", "testing from properties file".equals(AntTestChecker.getDefault().getUserProperty("AntTests")));
 		assertNull("my.name was not set and should be null", AntTestChecker.getDefault().getUserProperty("my.name"));
 	}

 	public void testPropertyFileWithMinusDTakingPrecedence() throws CoreException {
 		run("echoing.xml", new String[]{"-propertyfile", getPropertyFileName(), "-DAntTests=testing", "-Declipse.is.cool=true"}, false);
 		assertSuccessful();
 		assertTrue("eclipse.is.cool should have been set as true", "true".equals(AntTestChecker.getDefault().getUserProperty("eclipse.is.cool")));
 		assertTrue("AntTests should have a value of testing", "testing".equals(AntTestChecker.getDefault().getUserProperty("AntTests")));
 		assertNull("my.name was not set and should be null", AntTestChecker.getDefault().getUserProperty("my.name"));
 	}

 	public void testInputHandlerWithNoArg() throws CoreException {
 		try {
 			run("TestForEcho.xml", new String[]{"-inputhandler"});
 		} catch (CoreException ce) {
 			String msg= ce.getMessage();
 			assertTrue("Message incorrect!: " + msg, msg.equals("You must specify a classname when using the -inputhandler argument"));
 			return;
 		}
 		assertTrue("You must specify a classname when using the -inputhandler argument", false);
 	}

 	/**
 	 * Tests the "-inputhandler" option with two handlers specified...only one is allowed
 	 */
 	public void testInputHandlerMultiple() throws CoreException {
 		try {
 			run("TestForEcho.xml", new String[]{"-inputhandler", "org.apache.tools.ant.input.DefaultInputHandler", "-q", "-inputhandler", "org.apache.tools.ant.input.DefaultInputHandler"});
 		} catch (CoreException ce) {
 			String msg= ce.getMessage();
 			assertTrue("Message incorrect!: " + msg, msg.equals("Only one input handler class may be specified."));
 			return;
 		}
 		assertTrue("As only one input handler can be specified", false);
 	}

 	/**
 	 * Tests the "-inputhandler" option with a input handler that is not an instance of InputHandler
 	 */
 	public void testInputHandlerBad() throws CoreException {
 		try {
 			run("TestForEcho.xml", new String[]{"-inputhandler", "java.lang.StringBuffer"});
 		} catch (CoreException ce) {
 			String msg= ce.getMessage();
 			assertTrue("Message incorrect!: " + msg, msg.equals("The specified input handler class java.lang.StringBuffer does not implement the org.apache.tools.ant.input.InputHandler interface"));
 			return;
 		}
 		assertTrue("Incorrect inputhandler", false);
 	}

 	/**
 	 * Tests the "-inputhandler" option with a input handler that is not a defined class
 	 */
 	public void testInputHandlerBad2() throws CoreException {
 		try {
 			run("TestForEcho.xml", new String[]{"-inputhandler", "ja.lang.StringBuffer"});
 		} catch (CoreException ce) {
 			String msg= ce.getMessage();
 			assertTrue("Message incorrect!: " + msg, msg.startsWith("Unable to instantiate specified input handler class ja.lang.StringBuffer"));
 			return;
 		}
 		assertTrue("Incorrect inputhandler", false);
 	}

 	/**
 	 * Tests the "-inputhandler" option with a test input handler
 	 */
 	public void testInputHandler() throws CoreException {

 		run("input.xml", new String[]{"-inputhandler", "org.eclipse.ant.tests.core.support.inputHandlers.AntTestInputHandler"});
 		assertSuccessful();
 		String msg= (String)AntTestChecker.getDefault().getMessages().get(1);
 		assertTrue("Message incorrect: " + msg, msg.equals("testing handling input requests"));

 	}

 	/**
 	 * Tests the "-diagnostics" option with no ANT_HOME set
 	 * bug 25693
 	 */
 	public void testDiagnosticsWithNoAntHome() throws CoreException {

 		run("input.xml", new String[]{"-diagnostics"});
 		String msg= (String)AntTestChecker.getDefault().getMessages().get(0);
 		assertTrue("Message incorrect: " + msg, msg.equals("------- Ant diagnostics report -------"));
 	}

 	/**
 	 * Tests the "-diagnostics" option with ANT_HOME set
 	 * bug 25693
 	 */
 	/*public void testDiagnostics() throws CoreException {
 		AntCorePlugin.getPlugin().getPreferences().setAntHome(getAntHome());
 		try {
 			run("input.xml", new String[]{"-diagnostics"});
 		} finally {
 			restorePreferenceDefaults();
 		}

 		String msg= (String)AntTestChecker.getDefault().getMessages().get(1);
 		assertTrue("Message incorrect: " + msg, msg.equals("testing handling input requests"));
 	}*/
 }
	/*******************************************************************************
	* Copyright (c) 2000, 2003 IBM Corporation and others.
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Common Public License v1.0
	* which accompanies this distribution, and is available at
	* http://www.eclipse.org/legal/cpl-v10.html
	*
	* Contributors:
	* IBM Corporation - initial API and implementation
	*******************************************************************************/
	package org.eclipse.ant.tests.core.tests;


	import java.io.BufferedInputStream;
	import java.io.IOException;
	import java.io.InputStream;
	import java.io.InputStreamReader;
	import java.util.List;

	import org.eclipse.ant.tests.core.AbstractAntTest;
	import org.eclipse.ant.tests.core.testplugin.AntTestChecker;
	import org.eclipse.core.resources.IFile;
	import org.eclipse.core.runtime.CoreException;

	public class OptionTests extends AbstractAntTest {

	protected static final String START_OF_HELP= "ant [options] [target [target2 [target3] ...]]";
	protected static final String VERSION= "Apache Ant version 1.5.2 compiled on February 28 2003";

	public OptionTests(String name) {
	super(name);
	}

	/**
	* Tests the "-help" option
	*/
	public void testHelp() throws CoreException {
	run("TestForEcho.xml", new String[]{"-help"});
	assertTrue("One message should have been logged", AntTestChecker.getDefault().getMessagesLoggedCount() == 1);
	assertTrue("Help is incorrect", getLastMessageLogged() != null && getLastMessageLogged().startsWith(START_OF_HELP));
	}

	/**
	* Tests the "-version" option
	*/
	public void testVersion() throws CoreException {
	run("TestForEcho.xml", new String[]{"-version"});
	assertTrue("One message should have been logged", AntTestChecker.getDefault().getMessagesLoggedCount() == 1);
	assertTrue("Version is incorrect", VERSION.equals(getLastMessageLogged()));
	}

	/**
	* Tests the "-projecthelp" option when it will not show (quite mode)
	*/
	public void testProjecthelp() throws CoreException {
	run("TestForEcho.xml", new String[]{"-projecthelp"});
	assertTrue("4 messages should have been logged; was " + AntTestChecker.getDefault().getMessagesLoggedCount(), AntTestChecker.getDefault().getMessagesLoggedCount() == 4);
	assertTrue("Project help is incorrect", getLastMessageLogged().startsWith("Subtargets:"));
	}

	/**
	* Tests the "-projecthelp" option when it will not show (quite mode)
	*/
	public void testProjecthelpQuiet() throws CoreException {
	run("TestForEcho.xml", new String[]{"-projecthelp", "-q"});
	assertTrue("no messages should have been logged; was " + AntTestChecker.getDefault().getMessagesLoggedCount(), AntTestChecker.getDefault().getMessagesLoggedCount() == 0);
	}

	/**
	* Tests the "-listener" option with a listener that is not an instance of BuildListener
	*/
	public void testListenerBad() throws CoreException {
	try {
	run("TestForEcho.xml", new String[]{"-listener", "java.lang.String"});
	} catch (CoreException ce) {
	String msg= ce.getMessage();
	assertTrue("Message incorrect!: " + msg, msg.equals("java.lang.String which was specified to be a build listener is not an instance of org.apache.tools.ant.BuildListener."));
	return;
	}
	assertTrue("A core exception should have occurred wrappering a class cast exception", false);
	}

	/**
	* Tests passing an unrecognized argument
	*/
	public void testUnknownArg() throws CoreException {

	run("TestForEcho.xml", new String[]{"-listenr"});
	//unknown arg, print usage
	assertTrue("Two message should have been logged", AntTestChecker.getDefault().getMessagesLoggedCount() == 2);
	assertTrue("Should have printed the usage", getLastMessageLogged() != null && getLastMessageLogged().startsWith(START_OF_HELP));
	}

	/**
	* Tests specifying the -logfile with no arg
	*/
	public void testLogFileWithNoArg() throws CoreException {
	try {
	run("TestForEcho.xml", new String[]{"-logfile"});
	} catch (CoreException ce) {
	return;
	}
	assertTrue("You must specify a log file when using the -log argument", false);
	}

	/**
	* Tests specifying the -logfile
	*/
	public void testLogFile() throws CoreException, IOException {
	run("TestForEcho.xml", new String[]{"-logfile", "TestLogFile.txt"});
	IFile file= checkFileExists("TestLogFile.txt");
	InputStream stream =file.getContents();

	InputStreamReader in= null;
	try {
	in= new InputStreamReader(new BufferedInputStream(stream));
	StringBuffer buffer= new StringBuffer();
	char[] readBuffer= new char[2048];
	int n= in.read(readBuffer);
	while (n > 0) {
	buffer.append(readBuffer, 0, n);
	n= in.read(readBuffer);
	}
	assertTrue("File should have started with Buildfile", buffer.toString().startsWith("Buildfile"));
	} finally {
	in.close();
	stream.close();
	}

	}

	/**
	* Tests specifying the -logger with no arg
	*/
	public void testLoggerWithNoArg() throws CoreException {
	try {
	run("TestForEcho.xml", new String[]{"-logger"});
	} catch (CoreException ce) {
	return;
	}
	assertTrue("You must specify a classname when using the -logger argument", false);
	}

	/**
	* Tests the "-logger" option with a logger that is not an instance of BuildLogger
	*/
	public void testLoggerBad() throws CoreException {
	try {
	run("TestForEcho.xml", new String[]{"-logger", "java.lang.String"});
	} catch (CoreException ce) {
	return;
	}
	assertTrue("A core exception should have occurred wrappering a class cast exception", false);
	}

	/**
	* Tests the "-logger" option with two loggers specified...only one is allowed
	*/
	public void testTwoLoggers() throws CoreException {
	try {
	run("TestForEcho.xml", new String[]{"-logger", "java.lang.String", "-q", "-logger", "java.lang.String"});
	} catch (CoreException ce) {
	return;
	}
	assertTrue("As only one logger can be specified", false);
	}

	/**
	* Tests specifying the -listener with no arg
	*/
	public void testListenerWithNoArg() throws CoreException {
	try {
	run("TestForEcho.xml", new String[]{"-listener"});
	} catch (CoreException ce) {
	return;
	}
	assertTrue("You must specify a listeners when using the -listener argument ", false);
	}

	/**
	* Tests specifying the -listener with a class that will not be found
	*/
	public void testListenerClassNotFound() throws CoreException {
	try {
	run("TestForEcho.xml", new String[]{"-listener", "TestBuildListener"});
	} catch (CoreException e) {
	String message= e.getStatus().getException().getMessage();
	assertTrue("Should be ClassNotFoundException", "java.lang.ClassNotFoundException: TestBuildListener".equals(message));
	return;
	}
	assertTrue("A CoreException should have occurred as the listener class will not be found", false);

	}
	/**
	* Tests specifying the -listener option
	*/
	public void testListener() throws CoreException {
	run("TestForEcho.xml", new String[]{"-listener", ANT_TEST_BUILD_LISTENER});
	assertSuccessful();
	assertTrue("A listener should have been added named: " + ANT_TEST_BUILD_LISTENER, ANT_TEST_BUILD_LISTENER.equals(AntTestChecker.getDefault().getLastListener()));
	}

	/**
	* Tests specifying the -listener option multiple times...which is allowed
	*/
	public void testListenerMultiple() throws CoreException {
	run("TestForEcho.xml", new String[]{"-listener", ANT_TEST_BUILD_LISTENER, "-listener", ANT_TEST_BUILD_LISTENER});
	assertSuccessful();
	assertTrue("A listener should have been added named: " + ANT_TEST_BUILD_LISTENER, ANT_TEST_BUILD_LISTENER.equals(AntTestChecker.getDefault().getLastListener()));
	assertTrue("Two listeners should have been added", AntTestChecker.getDefault().getListeners().size() == 2);
	}

	/**
	* Tests specifying the -listener option multiple times, with one missing the arg
	*/
	public void testListenerMultipleWithBad() throws CoreException {
	try {
	run("TestForEcho.xml", new String[]{"-listener", ANT_TEST_BUILD_LISTENER, "-q", "-listener", "-verbose"});
	} catch(CoreException e) {
	//You must specify a listener for all -listener arguments
	return;
	}
	assertTrue("You must specify a listener for all -listener arguments ", false);
	}

	/**
	* Tests specifying the -buildfile with no arg
	*/
	public void testBuildFileWithNoArg() throws CoreException {
	try {
	run("TestForEcho.xml", new String[]{"-buildfile"});
	} catch (CoreException ce) {
	//You must specify a buildfile when using the -buildfile argument
	return;
	}
	assertTrue("You must specify a buildfile when using the -buildfile argument", false);
	}

	/**
	* Tests specifying the -buildfile
	*/
	public void testBuildFile() throws CoreException {
	String buildFileName= getProject().getFolder("scripts").getFile("echoing.xml").getLocation().toFile().getAbsolutePath();
	run("TestForEcho.xml", new String[]{"-buildfile", buildFileName}, false, "scripts");

	assertTrue("Should have been 1 tasks, was: " + AntTestChecker.getDefault().getTaskStartedCount(), AntTestChecker.getDefault().getTaskStartedCount() == 1);

	}

	/**
	* Tests specifying a target at the command line that does not exist.
	*/
	public void testSpecifyBadTargetAsArg() throws CoreException {
	try {
	run("TestForEcho.xml", new String[]{"echo2"}, false);
	} catch (CoreException ce) {
	return;
	}
	assertTrue("A core exception should have occurred as the target does not exist", false);
	}

	/**
	* Tests specifying a target at the command line
	*/
	public void testSpecifyTargetAsArg() throws CoreException {
	run("echoing.xml", new String[]{"echo3"}, false);
	assertTrue("3 messages should have been logged; was " + AntTestChecker.getDefault().getMessagesLoggedCount(), AntTestChecker.getDefault().getMessagesLoggedCount() == 3);
	assertSuccessful();
	}

	/**
	* Tests specifying a target at the command line with other options
	*/
	public void testSpecifyTargetAsArgWithOtherOptions() throws CoreException {
	run("echoing.xml", new String[]{"-logfile", "TestLogFile.txt", "echo3"}, false);
	assertTrue("4 messages should have been logged; was " + AntTestChecker.getDefault().getMessagesLoggedCount(), AntTestChecker.getDefault().getMessagesLoggedCount() == 4);
	List messages= AntTestChecker.getDefault().getMessages();
	//ensure that echo3 target executed and only that target
	assertTrue("echo3 target not executed", messages.get(2).equals("echo3"));
	assertSuccessful();
	}

	/**
	* Tests specifying targets at the command line with other options
	*/
	public void testSpecifyTargetsAsArgWithOtherOptions() throws CoreException {
	run("echoing.xml", new String[]{"-logfile", "TestLogFile.txt", "echo2", "echo3"}, false);
	assertTrue("5 messages should have been logged; was " + AntTestChecker.getDefault().getMessagesLoggedCount(), AntTestChecker.getDefault().getMessagesLoggedCount() == 5);
	List messages= AntTestChecker.getDefault().getMessages();
	//ensure that echo2 target executed
	assertTrue("echo2 target not executed", messages.get(2).equals("echo2"));
	assertSuccessful();
	}

	/**
	* Tests specifying a target at the command line and quiet reporting
	*/
	public void testSpecifyTargetAsArgAndQuiet() throws CoreException {
	run("echoing.xml", new String[]{"-logfile", "TestLogFile.txt", "echo3", "-quiet"}, false);
	assertTrue("1 message should have been logged; was " + AntTestChecker.getDefault().getMessagesLoggedCount(), AntTestChecker.getDefault().getMessagesLoggedCount() == 1);
	}

	/**
	* Tests specifying a target at the command line and quiet reporting
	*/
	public void testMinusD() throws CoreException {
	run("echoing.xml", new String[]{"-DAntTests=testing", "-Declipse.is.cool=true"}, false);
	assertSuccessful();
	assertTrue("eclipse.is.cool should have been set as true", "true".equals(AntTestChecker.getDefault().getUserProperty("eclipse.is.cool")));
	assertTrue("AntTests should have a value of testing", "testing".equals(AntTestChecker.getDefault().getUserProperty("AntTests")));
	assertNull("my.name was not set and should be null", AntTestChecker.getDefault().getUserProperty("my.name"));
	}

	public void testPropertyFileWithNoArg() throws CoreException {
	try {
	run("TestForEcho.xml", new String[]{"-propertyfile"});
	} catch (CoreException ce) {
	String msg= (String)AntTestChecker.getDefault().getMessages().get(0);
	assertTrue("Message incorrect!: " + msg, msg.equals("You must specify a property filename when using the -propertyfile argument"));
	return;
	}
	assertTrue("You must specify a property filename when using the -propertyfile argument", false);
	}

	/**
	* A build should succeed when a property file is not found.
	* The error is reported and the build continues.
	*/
	public void testPropertyFileFileNotFound() throws CoreException {

	run("TestForEcho.xml", new String[]{"-propertyfile", "qq.txt"});
	assertSuccessful();
	String msg= (String)AntTestChecker.getDefault().getMessages().get(0);
	assertTrue("Message incorrect!: " + msg, msg.startsWith("Could not load property file qq.txt:"));
	}

	public void testPropertyFile() throws CoreException {
	run("TestForEcho.xml", new String[]{"-propertyfile", getPropertyFileName()});
	assertSuccessful();
	assertTrue("eclipse.is.cool should have been set as Yep", "Yep".equals(AntTestChecker.getDefault().getUserProperty("eclipse.is.cool")));
	assertTrue("AntTests should have a value of testing", "testing from properties file".equals(AntTestChecker.getDefault().getUserProperty("AntTests")));
	assertNull("my.name was not set and should be null", AntTestChecker.getDefault().getUserProperty("my.name"));
	}

	public void testPropertyFileWithMinusDTakingPrecedence() throws CoreException {
	run("echoing.xml", new String[]{"-propertyfile", getPropertyFileName(), "-DAntTests=testing", "-Declipse.is.cool=true"}, false);
	assertSuccessful();
	assertTrue("eclipse.is.cool should have been set as true", "true".equals(AntTestChecker.getDefault().getUserProperty("eclipse.is.cool")));
	assertTrue("AntTests should have a value of testing", "testing".equals(AntTestChecker.getDefault().getUserProperty("AntTests")));
	assertNull("my.name was not set and should be null", AntTestChecker.getDefault().getUserProperty("my.name"));
	}

	public void testInputHandlerWithNoArg() throws CoreException {
	try {
	run("TestForEcho.xml", new String[]{"-inputhandler"});
	} catch (CoreException ce) {
	String msg= ce.getMessage();
	assertTrue("Message incorrect!: " + msg, msg.equals("You must specify a classname when using the -inputhandler argument"));
	return;
	}
	assertTrue("You must specify a classname when using the -inputhandler argument", false);
	}

	/**
	* Tests the "-inputhandler" option with two handlers specified...only one is allowed
	*/
	public void testInputHandlerMultiple() throws CoreException {
	try {
	run("TestForEcho.xml", new String[]{"-inputhandler", "org.apache.tools.ant.input.DefaultInputHandler", "-q", "-inputhandler", "org.apache.tools.ant.input.DefaultInputHandler"});
	} catch (CoreException ce) {
	String msg= ce.getMessage();
	assertTrue("Message incorrect!: " + msg, msg.equals("Only one input handler class may be specified."));
	return;
	}
	assertTrue("As only one input handler can be specified", false);
	}

	/**
	* Tests the "-inputhandler" option with a input handler that is not an instance of InputHandler
	*/
	public void testInputHandlerBad() throws CoreException {
	try {
	run("TestForEcho.xml", new String[]{"-inputhandler", "java.lang.StringBuffer"});
	} catch (CoreException ce) {
	String msg= ce.getMessage();
	assertTrue("Message incorrect!: " + msg, msg.equals("The specified input handler class java.lang.StringBuffer does not implement the org.apache.tools.ant.input.InputHandler interface"));
	return;
	}
	assertTrue("Incorrect inputhandler", false);
	}

	/**
	* Tests the "-inputhandler" option with a input handler that is not a defined class
	*/
	public void testInputHandlerBad2() throws CoreException {
	try {
	run("TestForEcho.xml", new String[]{"-inputhandler", "ja.lang.StringBuffer"});
	} catch (CoreException ce) {
	String msg= ce.getMessage();
	assertTrue("Message incorrect!: " + msg, msg.startsWith("Unable to instantiate specified input handler class ja.lang.StringBuffer"));
	return;
	}
	assertTrue("Incorrect inputhandler", false);
	}

	/**
	* Tests the "-inputhandler" option with a test input handler
	*/
	public void testInputHandler() throws CoreException {

	run("input.xml", new String[]{"-inputhandler", "org.eclipse.ant.tests.core.support.inputHandlers.AntTestInputHandler"});
	assertSuccessful();
	String msg= (String)AntTestChecker.getDefault().getMessages().get(1);
	assertTrue("Message incorrect: " + msg, msg.equals("testing handling input requests"));

	}

	/**
	* Tests the "-diagnostics" option with no ANT_HOME set
	* bug 25693
	*/
	public void testDiagnosticsWithNoAntHome() throws CoreException {

	run("input.xml", new String[]{"-diagnostics"});
	String msg= (String)AntTestChecker.getDefault().getMessages().get(0);
	assertTrue("Message incorrect: " + msg, msg.equals("------- Ant diagnostics report -------"));
	}

	/**
	* Tests the "-diagnostics" option with ANT_HOME set
	* bug 25693
	*/
	/*public void testDiagnostics() throws CoreException {
	AntCorePlugin.getPlugin().getPreferences().setAntHome(getAntHome());
	try {
	run("input.xml", new String[]{"-diagnostics"});
	} finally {
	restorePreferenceDefaults();
	}

	String msg= (String)AntTestChecker.getDefault().getMessages().get(1);
	assertTrue("Message incorrect: " + msg, msg.equals("testing handling input requests"));
	}*/
	}