Patch for Victor Mozgin.

I replaced old Java testcases for partitioning with C/C++ ones, and 
fixed AutomatedIntegrationSuite so it doesn't produce a JUnit warning (which is a failure) anymore. So now all tests in org.eclipse.cdt.ui.tests should pass.

core/org.eclipse.cdt.ui.tests/ChangeLog

@@ -1,3 +1,8 @@
+2003-06-11 Victor Mozgin
+	Old Java TestCase.txt and TestCase2.txt for partioning testing have been replaced with C/C++ files.
+	Modified AutomatedIntegrationSuite.java so it doesn't produce JUnit warning anymore.
+	All tests in org.eclipse.cdt.ui.tests should pass now.
+
 2003-06-10 Brent Nicolle
 	Added some Interface tests of (IInclude, IMacro, IStructure).
 	Made sure all the Test Suites have names in the JUnit hierarchy.

core/org.eclipse.cdt.ui.tests/suite/org/eclipse/cdt/core/suite/AutomatedIntegrationSuite.java

@@ -74,7 +74,7 @@ public class AutomatedIntegrationSuite extends TestSuite implements TestListener
 		suite.addTest(WorkingCopyTests.suite());
 		
 		// Last test to trigger report generation
-		suite.addTest(suite.new GenerateReport("testStartFailedTests"));
+		suite.addTest(suite.new GenerateReport("startFailedTests"));
 		
 		// Add all failed tests
 		suite.addTestSuite(DOMFailedTest.class);
@@ -83,7 +83,7 @@ public class AutomatedIntegrationSuite extends TestSuite implements TestListener
 		suite.addTestSuite(CModelElementsFailedTests.class);
 
 		// Last test to trigger report generation
-		suite.addTest(suite.new GenerateReport("testGenerateReport"));
+		suite.addTest(suite.new GenerateReport("generateReport"));
 
 		return suite;
 	}
@@ -209,7 +209,7 @@ public class AutomatedIntegrationSuite extends TestSuite implements TestListener
 		}
 		public GenerateReport(){}
 		
-		public void testGenerateReport() {
+		public void generateReport() {
 			// skip this one
 			AutomatedIntegrationSuite.this.skipTest = true;
 
@@ -217,7 +217,7 @@ public class AutomatedIntegrationSuite extends TestSuite implements TestListener
 			AutomatedIntegrationSuite.this.generateReport();
 		}
 		
-		public void testStartFailedTests() {
+		public void startFailedTests() {
 			// skip this one
 			AutomatedIntegrationSuite.this.skipTest = true;
 			

core/org.eclipse.cdt.ui.tests/ui/org/eclipse/cdt/ui/tests/text/TestCase.txt

@@ -1,211 +1,43 @@
-package org.eclipse.jdt.ui.tests.text;
+#include <Simple.h>
 
-import java.lang.reflect.*;
+const SimpleStruct simpleStruct =
+{
+	1
+  , "mySimple"
+  , 0.1232
+};
 
-/**
+#define SIZEOF( A, B ) sizeof( A.B )
- * A test case defines the fixture to run multiple tests. To define a test case<br>
- * 1) implement a subclass of TestCase<br>
- * 2) define instance variables that store the state of the fixture<br>
- * 3) initialize the fixture state by overriding <code>setUp</code><br>
- * 4) clean-up after a test by overriding <code>tearDown</code>.<br>
- * Each test runs in its own fixture so there
- * can be no side effects among test runs.
- * Here is an example:
- * <pre>
- * public class MathTest extends TestCase {
- *     protected double fValue1;
- *     protected double fValue2;
- *
- *     public MathTest(String name) {
- *         super(name);
- *     }
- *
- *    protected void setUp() {
- *         fValue1= 2.0;
- *         fValue2= 3.0;
- *     }
- * }
- * </pre>
- *
- * For each test implement a method which interacts
- * with the fixture. Verify the expected results with assertions specified
- * by calling <code>assert</code> with a boolean.
- * <pre>
- *    protected void testAdd() {
- *        double result= fValue1 + fValue2;
- *        assert(result == 5.0);
- *    }
- * </pre>
- * Once the methods are defined you can run them. The framework supports
- * both a static type safe and more dynamic way to run a test.
- * In the static way you override the runTest method and define the method to
- * be invoked. A convenient way to do so is with an anonymous inner class.
- * <pre>
- * Test test= new MathTest("add") {
- *        public void runTest() {
- *            testAdd();
- *        }
- * };
- * test.run();
- * </pre>
- * The dynamic way uses reflection to implement <code>runTest</code>. It dynamically finds
- * and invokes a method.
- * In this case the name of the test case has to correspond to the test method
- * to be run.
- * <pre>
- * Test= new MathTest("testAdd");
- * test.run();
- * </pre>
- * The tests to be run can be collected into a TestSuite. JUnit provides
- * different <i>test runners</i> which can run a test suite and collect the results.
- * A test runner either expects a static method <code>suite</code> as the entry
- * point to get a test to run or it will extract the suite automatically.
- * <pre>
- * public static Test suite() {
- *      suite.addTest(new MathTest("testAdd"));
- *      suite.addTest(new MathTest("testDivideByZero"));
- *      return suite;
- *  }
- * </pre>
- * @see TestResult
- * @see TestSuite
- */
 
-public abstract class TestCase extends Assert implements Test {
+const OtherStruct array[] =
-	/**
+{
-	 * the name of the test case
+	{
-	 */
+#if FOO
-	private String fName;
+		"foo"
+#else
+		"bar"
+#endif
+	  ,	SIZEOF( simpleStruct, num )
+	  , &t_int
+	  , 0
+	}
+  , {
+		"name"
+	  , SIZEOF( simpleStruct, floatnum )
+	  , &t_float
+	  , 1
+	}
+};
 
-	/**
-	 * No-arg constructor to enable serialization. This method
-	 * is not intended to be used by mere mortals.
-	 */
-	TestCase() {
-		fName= null;
-	}
-	
-	/**
-	 * Constructs a test case with the given name.
-	 */
-	public TestCase(String name) {
-		fName= name;
-	}
-	
-	/**
-	 * Counts the number of test cases executed by run(TestResult result).
-	 */
-	public int countTestCases() {
-		return 1;
-	}
-	/**
-	 * Creates a default TestResult object
-	 *
-	 * @see TestResult
-	 */
-	protected TestResult createResult() {
-	    return new TestResult();
-	}
-	/**
-	 * Gets the name of the test case.
-	 * @deprecated use getName()
-	 */
-	public String name() {
-		return fName;
-	}
-	/**
-	 * A convenience method to run this test, collecting the results with a
-	 * default TestResult object.
-	 *
-	 * @see TestResult
-	 */
-	public TestResult run() {
-		TestResult result= createResult();
-		run(result);
-		return result;
-	}
-	/**
-	 * Runs the test case and collects the results in TestResult.
-	 */
-	public void run(TestResult result) {
-		result.run(this);
-	}
-	/**
-	 * Runs the bare test sequence.
-	 * @exception Throwable if any exception is thrown
-	 */
-	public void runBare() throws Throwable {
-		setUp();
-		try {
-			runTest();
-		}
-		finally {
-			tearDown();
-		}
-	}
-	/**
-	 * Override to run the test and assert its state.
-	 * @exception Throwable if any exception is thrown
-	 */
-	protected void runTest() throws Throwable {
-		Method runMethod= null;
-		try {
-			// use getMethod to get all public inherited
-			// methods. getDeclaredMethods returns all
-			// methods of this class but excludes the
-			// inherited ones.
-			runMethod= getClass().getMethod(fName, null);
-		} catch (NoSuchMethodException e) {
-			fail("Method \""+fName+"\" not found");
-		}
-		if (!Modifier.isPublic(runMethod.getModifiers())) {
-			fail("Method \""+fName+"\" should be public");
-		}
-
-		try {
-			runMethod.invoke(this, new Class[0]);
-		}
-		catch (InvocationTargetException e) {
-			e.fillInStackTrace();
-			throw e.getTargetException();
-		}
-		catch (IllegalAccessException e) {
-			e.fillInStackTrace();
-			throw e;
-		}
-	}
-	/**
-	 * Sets up the fixture, for example, open a network connection.
-	 * This method is called before a test is executed.
-	 */
-	protected void setUp() throws Exception {
-	}
-	/**
-	 * Tears down the fixture, for example, close a network connection.
-	 * This method is called after a test is executed.
-	 */
-	protected void tearDown() throws Exception {
-	}
-	/**
-	 * Returns a string representation of the test case
-	 */
-	public String toString() {
-	    return name()+"("+getClass().getName()+")";
-	}
-	/**
-	 * Gets the name of a TestCase
-	 * @return returns a String
-	 */
-	public String getName() {
-		return fName;
-	}
-
-	/**
-	 * Sets the name of a TestCase
-	 * @param name The name to set
-	 */
-	public void setName(String name) {
-		fName= name;
-	}
 
+void SimpleStruct_construct( struct SimpleStruct * const this )
+{
+	this->num = 1;
+	this->name = "boo";
+	this->floatNum = 1.5;
+}
+
+int ConnectParams_doSomething( const struct SimpleStruct * const this )
+{
+	return 1;
 }

core/org.eclipse.cdt.ui.tests/ui/org/eclipse/cdt/ui/tests/text/TestCase2.txt

@@ -1,66 +1,68 @@
-package org.eclipse.jdt.ui.tests.text;
+/*
-
+ * (c) Copyright QNX Software Systems Ltd. 2002.
-/**
+ * All Rights Reserved.
- * javadoc
+ */
+/********
+ * This is a sample C file that will be used in testing the TranslationUnit
+ * class.  It has a specific structure that will be looked for within the 
+ * test case.
+ * This file is only ment to contain various C elements, and may not compile
+ * into a running application (but should be valid C)
  */
-public class TestCase2 {
-	/*
-	 * multi line comment
-	 */
-	 private void foo() {
-	 	// single line comment
-	 	int value= 42;
  
-	 	/**/
+#include <stdio.h>
+#include <unistd.h>
 
-	 	String s= "string";
+/* A function prototype */
-	 	char c= 'c';
+int func2p(void); 
 
-	 	String s2= "string2"/* ads*/;
+/* A global variable */
+int globalvar;
 
-	 	Nastyness: ""/**/''"";
+/* A enumeration */
+enum myenum {ENUM_A=1, ENUM_B=2, ENUM_C=3, ENUM_D=4};
 
-	 	// open strings and characters
+/* A structure. This also includes a typedef around the strcture def
-	 	'open characters
+ * which at the time of writing was not picked up.
-	 	"open strings
+ */
+typedef struct mystruct {
+	int a;
+	char b;
+	long c;
+} mystruct_t; 
 
-	 	// all state transitions
+/* A union */
-	 	/* multi line comment */// single line comment
+union myunion {
-	 	/* multi line comment *//* multi line comment */
+	int x;
-	 	/* multi line comment *//** java doc */
+	char y;
-	 	/* multi line comment */'character'
+	long z;
-	 	/* multi line comment */"string"
+};
-	 	/* java doc */// single line comment
-	 	/* java doc *//* multi line comment */
-	 	/* java doc *//** java doc */
-	 	/* java doc */'character'
-	 	/* java doc */"string"
-	 	"string"// single line comment
-	 	"string"//* multi line comment */
-	 	"string"/** java doc */
-	 	"string"'character'
-	 	"string""string"
-	 	'character'// single line comment
-	 	'character'"//* multi line comment */
-	 	'character'/** java doc */
-	 	'character''character'
-	 	'character'"string"
 
-		// more nasty cases
+/* A typedef */
-		/'asdf
+typedef struct mystruct mytype;
-		/"asdf
 
-		/**
-		 *	// single line comment inside javadoc
-		 */
 
-		/*
+/* A couple functions */
-		 *	// single line comment inside multi-line comment
-		 */
-		 
-		// would fail conformance, but it's ok
-		"<backslash>
-		'<backslash>		
-	 }
  
+void * func1(void)
+{
+	return(NULL);
+}
+
+
+int func2(void)
+{
+	return(0);
+}
+ 
+int main(int argc, char ** argv)
+{
+	int var1;
+	printf("Hello world\n");
+}
+
+
+void func3()
+{
+	printf("This is not really here\n");
 }