package junit.framework;

/*-
 * #%L
 * org.eclipse.jdt.ui.junit.sampleproject
 * %%
 * Copyright (C) 2020 Eclipse Foundation
 * %%
 * This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0
 * and Eclipse Distribution License v. 1.0 which accompanies this distribution.
 * The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
 * and the Eclipse Distribution License is available at
 * http://www.eclipse.org/org/documents/edl-v10.php.
 * #L%
 */

import java.util.Vector;
import java.util.Enumeration;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.lang.reflect.*;

/**
 * A <code>TestSuite</code> is a <code>Composite</code> of Tests. It runs a
 * collection of test cases. Here is an example using the dynamic test
 * definition.
 * 
 * <pre>
 * TestSuite suite = new TestSuite();
 * suite.addTest(new MathTest("testAdd"));
 * suite.addTest(new MathTest("testDivideByZero"));
 * </pre>
 * 
 * Alternatively, a TestSuite can extract the tests to be run automatically. To
 * do so you pass the class of your TestCase class to the TestSuite constructor.
 * 
 * <pre>
 * TestSuite suite = new TestSuite(MathTest.class);
 * </pre>
 * 
 * This constructor creates a suite with all the methods starting with "test"
 * that take no arguments.
 *
 * @see Test
 */
public class TestSuite implements Test {

	private Vector<Test> fTests = new Vector<Test>(10);
	private String fName;

	/**
	 * Constructs an empty TestSuite.
	 */
	public TestSuite() {
	}

	/**
	 * Constructs a TestSuite from the given class with the given name.
	 * 
	 * @see TestSuite#TestSuite(Class)
	 */
	public TestSuite(Class<?> theClass, String name) {
		this(theClass);
		setName(name);
	}

	/**
	 * Constructs a TestSuite from the given class. Adds all the methods starting
	 * with "test" as test cases to the suite. Parts of this method was written at
	 * 2337 meters in the Huffihütte, Kanton Uri
	 */
	public TestSuite(final Class<?> theClass) {
		fName = theClass.getName();
		try {
			getTestConstructor(theClass); // Avoid generating multiple error messages
		} catch (NoSuchMethodException e) {
			addTest(warning(
					"Class " + theClass.getName() + " has no public constructor TestCase(String name) or TestCase()"));
			return;
		}

		if (!Modifier.isPublic(theClass.getModifiers())) {
			addTest(warning("Class " + theClass.getName() + " is not public"));
			return;
		}

		Class<?> superClass = theClass;
		Vector<String> names = new Vector<String>();
		while (Test.class.isAssignableFrom(superClass)) {
			Method[] methods = superClass.getDeclaredMethods();
			for (Method method : methods) {
				addTestMethod(method, names, theClass);
			}
			superClass = superClass.getSuperclass();
		}
		if (fTests.size() == 0)
			addTest(warning("No tests found in " + theClass.getName()));
	}

	/**
	 * Constructs an empty TestSuite.
	 */
	public TestSuite(String name) {
		setName(name);
	}

	/**
	 * Adds a test to the suite.
	 */
	public void addTest(Test test) {
		fTests.addElement(test);
	}

	/**
	 * Adds the tests from the given class to the suite
	 */
	public void addTestSuite(Class<?> testClass) {
		addTest(new TestSuite(testClass));
	}

	private void addTestMethod(Method m, Vector<String> names, Class<?> theClass) {
		String name = m.getName();
		if (names.contains(name))
			return;
		if (!isPublicTestMethod(m)) {
			if (isTestMethod(m))
				addTest(warning("Test method isn't public: " + m.getName()));
			return;
		}
		names.addElement(name);
		addTest(createTest(theClass, name));
	}

	/**
	 * ...as the moon sets over the early morning Merlin, Oregon mountains, our
	 * intrepid adventurers type...
	 */
	static public Test createTest(Class<?> theClass, String name) {
		Constructor<?> constructor;
		try {
			constructor = getTestConstructor(theClass);
		} catch (NoSuchMethodException e) {
			return warning(
					"Class " + theClass.getName() + " has no public constructor TestCase(String name) or TestCase()");
		}
		Object test;
		try {
			if (constructor.getParameterTypes().length == 0) {
				test = constructor.newInstance(new Object[0]);
				if (test instanceof TestCase)
					((TestCase) test).setName(name);
			} else {
				test = constructor.newInstance(name);
			}
		} catch (InstantiationException e) {
			return (warning("Cannot instantiate test case: " + name + " (" + exceptionToString(e) + ")"));
		} catch (InvocationTargetException e) {
			return (warning(
					"Exception in constructor: " + name + " (" + exceptionToString(e.getTargetException()) + ")"));
		} catch (IllegalAccessException e) {
			return (warning("Cannot access test case: " + name + " (" + exceptionToString(e) + ")"));
		}
		return (Test) test;
	}

	/**
	 * Converts the stack trace into a string
	 */
	private static String exceptionToString(Throwable t) {
		StringWriter stringWriter = new StringWriter();
		PrintWriter writer = new PrintWriter(stringWriter);
		t.printStackTrace(writer);
		return stringWriter.toString();

	}

	/**
	 * Counts the number of test cases that will be run by this test.
	 */
	public int countTestCases() {
		int count = 0;
		for (Enumeration<Test> e = tests(); e.hasMoreElements();) {
			Test test = (Test) e.nextElement();
			count = count + test.countTestCases();
		}
		return count;
	}

	/**
	 * Gets a constructor which takes a single String as its argument or a no arg
	 * constructor.
	 */
	public static Constructor<?> getTestConstructor(Class<?> theClass) throws NoSuchMethodException {
		Class[] args = { String.class };
		try {
			return theClass.getConstructor(args);
		} catch (NoSuchMethodException e) {
			// fall through
		}
		return theClass.getConstructor(new Class[0]);
	}

	private boolean isPublicTestMethod(Method m) {
		return isTestMethod(m) && Modifier.isPublic(m.getModifiers());
	}

	private boolean isTestMethod(Method m) {
		String name = m.getName();
		Class[] parameters = m.getParameterTypes();
		Class<?> returnType = m.getReturnType();
		return parameters.length == 0 && name.startsWith("test") && returnType.equals(Void.TYPE);
	}

	/**
	 * Runs the tests and collects their result in a TestResult.
	 */
	public void run(TestResult result) {
		for (Enumeration<Test> e = tests(); e.hasMoreElements();) {
			if (result.shouldStop())
				break;
			Test test = (Test) e.nextElement();
			runTest(test, result);
		}
	}

	public void runTest(Test test, TestResult result) {
		test.run(result);
	}

	/**
	 * Returns the test at the given index
	 */
	public Test testAt(int index) {
		return (Test) fTests.elementAt(index);
	}

	/**
	 * Returns the number of tests in this suite
	 */
	public int testCount() {
		return fTests.size();
	}

	/**
	 * Returns the tests as an enumeration
	 */
	public Enumeration<Test> tests() {
		return fTests.elements();
	}

	/**
	 */
	public String toString() {
		if (getName() != null)
			return getName();
		return super.toString();
	}

	/**
	 * Sets the name of the suite.
	 * 
	 * @param name The name to set
	 */
	public void setName(String name) {
		fName = name;
	}

	/**
	 * Returns the name of the suite. Not all test suites have a name and this
	 * method can return null.
	 */
	public String getName() {
		return fName;
	}

	/**
	 * Returns a test which will fail and log a warning message.
	 */
	private static Test warning(final String message) {
		return new TestCase("warning") {
			protected void runTest() {
				fail(message);
			}
		};
	}
}
