//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
   // This file is copied from JUnit with some modification.
   //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
   package junit.framework;
   
   import java.util.Enumeration;
   import java.util.Vector;
   
   /**
   * 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(&quot;testAdd&quot;));
   * suite.addTest(new MathTest(&quot;testDivideByZero&quot;));
   * </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 fTests = new Vector(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 Hüffihütte, Kanton Uri
  	 */
  	public TestSuite(final Class theClass) {
  		if (TestCase.class.isAssignableFrom(theClass)) {
  			fName = theClass.getName();
  
  			TestCase test;
  			try {
  				test = (TestCase) theClass.newInstance();
  				TestMethod[] methods = test.getTestMethods();
  
  				if (methods != null) {
  					for (int i = 0; i < methods.length; i++) {
  						addTestMethod(methods[i], theClass);
  					}
  				}
  				if (fTests.size() == 0) {
  					addTest(warning("No tests found in " + theClass.getName()));
  				}
  			} catch (InstantiationException e) {
  				// TODO Auto-generated catch block
  				e.printStackTrace();
  			} catch (IllegalAccessException e) {
  				// TODO Auto-generated catch block
  				e.printStackTrace();
  			}
  		}
  	}
  
  	/**
  	 * 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(TestMethod m, Class theClass) {
 		addTest(createTest(theClass, m));
 	}
 
 	/**
 	 * ...as the moon sets over the early morning Merlin, Oregon mountains, our intrepid adventurers type... --- Just in
 	 * case if sombody calls this.
 	 */
 	static public Test createTest(Class theClass, TestMethod testMethod) {
 		Test test = null;
 		try {
 			test = (Test) theClass.newInstance();
 			if (test instanceof TestCase) {
 				((TestCase) test).setTestMethod(testMethod);
 			}
 		} catch (InstantiationException e) {
 			return (warning("Cannot instantiate test case: " + testMethod + " (" + exceptionToString(e) + ")"));
 		} catch (IllegalAccessException e) {
 			return (warning("Cannot access test case: " + testMethod + " (" + 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();
 		return t.getMessage();
 
 	}
 
 	/**
 	 * Counts the number of test cases that will be run by this test.
 	 */
 	public int countTestCases() {
 		int count = 0;
 		for (Enumeration e = tests(); e.hasMoreElements();) {
 			Test test = (Test) e.nextElement();
 			count = count + test.countTestCases();
 		}
 		return count;
 	}
 
 	/**
 	 * Runs the tests and collects their result in a TestResult.
 	 */
 	public void run(TestResult result) {
 		for (Enumeration 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 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(new TestMethod("warning") {
 			public void run(TestCase testCase) throws Throwable {
 			}
 		}) {
 			protected void runTest() {
 				fail(message);
 			}
 
 			public TestMethod[] getTestMethods() {
 				return null;
 			}
 		};
 	}
 
 	// public TestMethod[] getTestMethods() {
 	// Vector testMethodsVector = new Vector();
 	// for (int i = 0; i < fTests.size(); i++) {
 	// Test test = (Test)fTests.elementAt(i);
 	// for (int j = 0; j < test.getTestMethods().length; j++) {
 	// testMethodsVector.addElement(test.getTestMethods()[j]);
 	// }
 	// }
 	// TestMethod[] testMethods = new TestMethod[testMethodsVector.size()];
 	// testMethodsVector.copyInto(testMethods);
 	// return testMethods;
 	// }
 }