auto import from //depot/cupcake/@135843

18 files changed, 0 insertions, 1341 deletions

diff --git a/junit/MODULE_LICENSE_CPL b/junit/MODULE_LICENSE_CPL
deleted file mode 100644
index 541dbb5..0000000
--- a/junit/MODULE_LICENSE_CPL
+++ /dev/null
@@ -1 +0,0 @@
-http://www.opensource.org/licenses/cpl1.0.php
diff --git a/junit/src/main/java/junit/extensions/ActiveTestSuite.java b/junit/src/main/java/junit/extensions/ActiveTestSuite.java
deleted file mode 100644
index 073e6f3..0000000
--- a/junit/src/main/java/junit/extensions/ActiveTestSuite.java
+++ /dev/null
@@ -1,64 +0,0 @@
-package junit.extensions;
-
-import junit.framework.*;
-
-/**
- * A TestSuite for active Tests. It runs each
- * test in a separate thread and waits until all
- * threads have terminated.
- * -- Aarhus Radisson Scandinavian Center 11th floor
- */ 
-public class ActiveTestSuite extends TestSuite {
-    private volatile int fActiveTestDeathCount;
-
-    public ActiveTestSuite() {
-    }
-        
-    public ActiveTestSuite(Class theClass) {
-        super(theClass);
-    }
-    
-    public ActiveTestSuite(String name) {
-        super (name);
-    }
-    
-    public ActiveTestSuite(Class theClass, String name) {
-        super(theClass, name);
-    }
-    
-    public void run(TestResult result) {
-        fActiveTestDeathCount= 0;
-        super.run(result);
-        waitUntilFinished();
-    }
-    
-    public void runTest(final Test test, final TestResult result) {
-        Thread t= new Thread() {
-            public void run() {
-                try {
-                    // inlined due to limitation in VA/Java 
-                    //ActiveTestSuite.super.runTest(test, result);
-                    test.run(result);
-                } finally {
-                    ActiveTestSuite.this.runFinished(test);
-                }
-            }
-        };
-        t.start();
-    }
-
-    synchronized void waitUntilFinished() {
-        while (fActiveTestDeathCount < testCount()) {
-            try {
-                wait();
-            } catch (InterruptedException e) {
-                return; // ignore
-            }
-        }
-    }
-    
-    synchronized public void runFinished(Test test) {
-        fActiveTestDeathCount++;
-        notifyAll();
-    }
-}
diff --git a/junit/src/main/java/junit/extensions/ExceptionTestCase.java b/junit/src/main/java/junit/extensions/ExceptionTestCase.java
deleted file mode 100644
index de64b5b..0000000
--- a/junit/src/main/java/junit/extensions/ExceptionTestCase.java
+++ /dev/null
@@ -1,46 +0,0 @@
-package junit.extensions;
-
-import junit.framework.*;
-
-/**
- * A TestCase that expects an Exception of class fExpected to be thrown.
- * The other way to check that an expected exception is thrown is:
- * <pre>
- * try {
- *   shouldThrow();
- * }
- * catch (SpecialException e) {
- *   return;
- * }
- * fail("Expected SpecialException");
- * </pre>
- *
- * To use ExceptionTestCase, create a TestCase like:
- * <pre>
- * new ExceptionTestCase("testShouldThrow", SpecialException.class);
- * </pre>
- */
-public class ExceptionTestCase extends TestCase {
-    Class fExpected;
-
-    public ExceptionTestCase(String name, Class exception) {
-        super(name);
-        fExpected= exception;
-    }
-    /**
-     * Execute the test method expecting that an Exception of
-     * class fExpected or one of its subclasses will be thrown
-     */
-    protected void runTest() throws Throwable {
-        try {
-            super.runTest();
-        }
-        catch (Exception e) {
-            if (fExpected.isAssignableFrom(e.getClass()))
-                return;
-            else
-                throw e;
-        }
-        fail("Expected exception " + fExpected);
-    }
-}
diff --git a/junit/src/main/java/junit/extensions/RepeatedTest.java b/junit/src/main/java/junit/extensions/RepeatedTest.java
deleted file mode 100644
index 34f2541..0000000
--- a/junit/src/main/java/junit/extensions/RepeatedTest.java
+++ /dev/null
@@ -1,31 +0,0 @@
-package junit.extensions;
-
-import junit.framework.*;
-
-/**
- * A Decorator that runs a test repeatedly.
- *
- */
-public class RepeatedTest extends  TestDecorator {
-    private int fTimesRepeat;
-
-    public RepeatedTest(Test test, int repeat) {
-        super(test);
-        if (repeat < 0)
-            throw new IllegalArgumentException("Repetition count must be > 0");
-        fTimesRepeat= repeat;
-    }
-    public int countTestCases() {
-        return super.countTestCases()*fTimesRepeat;
-    }
-    public void run(TestResult result) {
-        for (int i= 0; i < fTimesRepeat; i++) {
-            if (result.shouldStop())
-                break;
-            super.run(result);
-        }
-    }
-    public String toString() {
-        return super.toString()+"(repeated)";
-    }
-}
diff --git a/junit/src/main/java/junit/extensions/TestDecorator.java b/junit/src/main/java/junit/extensions/TestDecorator.java
deleted file mode 100644
index 6b5144a..0000000
--- a/junit/src/main/java/junit/extensions/TestDecorator.java
+++ /dev/null
@@ -1,38 +0,0 @@
-package junit.extensions;
-
-import junit.framework.*;
-
-/**
- * A Decorator for Tests. Use TestDecorator as the base class
- * for defining new test decorators. Test decorator subclasses
- * can be introduced to add behaviour before or after a test
- * is run.
- *
- */
-public class TestDecorator extends Assert implements Test {
-    protected Test fTest;
-
-    public TestDecorator(Test test) {
-        fTest= test;
-    }
-    /**
-     * The basic run behaviour.
-     */
-    public void basicRun(TestResult result) {
-        fTest.run(result);
-    }
-    public int countTestCases() {
-        return fTest.countTestCases();
-    }
-    public void run(TestResult result) {
-        basicRun(result);
-    }
-
-    public String toString() {
-        return fTest.toString();
-    }
-
-    public Test getTest() {
-        return fTest;
-    }
-}
diff --git a/junit/src/main/java/junit/extensions/TestSetup.java b/junit/src/main/java/junit/extensions/TestSetup.java
deleted file mode 100644
index 3651501..0000000
--- a/junit/src/main/java/junit/extensions/TestSetup.java
+++ /dev/null
@@ -1,37 +0,0 @@
-package junit.extensions;
-
-import junit.framework.*;
-
-/**
- * A Decorator to set up and tear down additional fixture state.
- * Subclass TestSetup and insert it into your tests when you want
- * to set up additional state once before the tests are run.
- */
-public class TestSetup extends TestDecorator {
-
-    public TestSetup(Test test) {
-        super(test);
-    }
-    public void run(final TestResult result) {
-        Protectable p= new Protectable() {
-            public void protect() throws Exception {
-                setUp();
-                basicRun(result);
-                tearDown();
-            }
-        };
-        result.runProtected(this, p);
-    }
-    /**
-     * Sets up the fixture. Override to set up additional fixture
-     * state.
-     */
-    protected void setUp() throws Exception {
-    }
-    /**
-     * Tears down the fixture. Override to tear down the additional
-     * fixture state.
-     */
-    protected void tearDown() throws Exception {
-    }
-}
diff --git a/junit/src/main/java/junit/extensions/package.html b/junit/src/main/java/junit/extensions/package.html
deleted file mode 100644
index 6b4be72..0000000
--- a/junit/src/main/java/junit/extensions/package.html
+++ /dev/null
@@ -1,6 +0,0 @@
-<HTML>
-<BODY>
-Utility classes supporting the junit test framework.
-{@hide} - Not needed for 1.0 SDK 
-</BODY>
-</HTML>
diff --git a/junit/src/main/java/junit/framework/Assert.java b/junit/src/main/java/junit/framework/Assert.java
deleted file mode 100644
index c1bc7b2..0000000
--- a/junit/src/main/java/junit/framework/Assert.java
+++ /dev/null
@@ -1,291 +0,0 @@
-package junit.framework;
-
-/**
- * A set of assert methods.  Messages are only displayed when an assert fails.
- */
-
-public class Assert {
-    /**
-     * Protect constructor since it is a static only class
-     */
-    protected Assert() {
-    }
-
-    /**
-     * Asserts that a condition is true. If it isn't it throws
-     * an AssertionFailedError with the given message.
-     */
-    static public void assertTrue(String message, boolean condition) {
-        if (!condition)
-            fail(message);
-    }
-    /**
-     * Asserts that a condition is true. If it isn't it throws
-     * an AssertionFailedError.
-     */
-    static public void assertTrue(boolean condition) {
-        assertTrue(null, condition);
-    }
-    /**
-     * Asserts that a condition is false. If it isn't it throws
-     * an AssertionFailedError with the given message.
-     */
-    static public void assertFalse(String message, boolean condition) {
-        assertTrue(message, !condition);
-    }
-    /**
-     * Asserts that a condition is false. If it isn't it throws
-     * an AssertionFailedError.
-     */
-    static public void assertFalse(boolean condition) {
-        assertFalse(null, condition);
-    }
-    /**
-     * Fails a test with the given message.
-     */
-    static public void fail(String message) {
-        throw new AssertionFailedError(message);
-    }
-    /**
-     * Fails a test with no message.
-     */
-    static public void fail() {
-        fail(null);
-    }
-    /**
-     * Asserts that two objects are equal. If they are not
-     * an AssertionFailedError is thrown with the given message.
-     */
-    static public void assertEquals(String message, Object expected, Object actual) {
-        if (expected == null && actual == null)
-            return;
-        if (expected != null && expected.equals(actual))
-            return;
-        failNotEquals(message, expected, actual);
-    }
-    /**
-     * Asserts that two objects are equal. If they are not
-     * an AssertionFailedError is thrown.
-     */
-    static public void assertEquals(Object expected, Object actual) {
-        assertEquals(null, expected, actual);
-    }
-    /**
-     * Asserts that two Strings are equal. 
-     */
-    static public void assertEquals(String message, String expected, String actual) {
-        if (expected == null && actual == null)
-            return;
-        if (expected != null && expected.equals(actual))
-            return;
-        throw new ComparisonFailure(message, expected, actual);
-    }
-    /**
-     * Asserts that two Strings are equal. 
-     */
-    static public void assertEquals(String expected, String actual) {
-        assertEquals(null, expected, actual);
-    }
-    /**
-     * Asserts that two doubles are equal concerning a delta.  If they are not
-     * an AssertionFailedError is thrown with the given message.  If the expected
-     * value is infinity then the delta value is ignored.
-     */
-    static public void assertEquals(String message, double expected, double actual, double delta) {
-        // handle infinity specially since subtracting to infinite values gives NaN and the
-        // the following test fails
-        if (Double.isInfinite(expected)) {
-            if (!(expected == actual))
-                failNotEquals(message, new Double(expected), new Double(actual));
-        } else if (!(Math.abs(expected-actual) <= delta)) // Because comparison with NaN always returns false
-            failNotEquals(message, new Double(expected), new Double(actual));
-    }
-    /**
-     * Asserts that two doubles are equal concerning a delta. If the expected
-     * value is infinity then the delta value is ignored.
-     */
-    static public void assertEquals(double expected, double actual, double delta) {
-        assertEquals(null, expected, actual, delta);
-    }
-    /**
-     * Asserts that two floats are equal concerning a delta. If they are not
-     * an AssertionFailedError is thrown with the given message.  If the expected
-     * value is infinity then the delta value is ignored.
-     */
-    static public void assertEquals(String message, float expected, float actual, float delta) {
-         // handle infinity specially since subtracting to infinite values gives NaN and the
-        // the following test fails
-        if (Float.isInfinite(expected)) {
-            if (!(expected == actual))
-                failNotEquals(message, new Float(expected), new Float(actual));
-        } else if (!(Math.abs(expected-actual) <= delta))
-              failNotEquals(message, new Float(expected), new Float(actual));
-    }
-    /**
-     * Asserts that two floats are equal concerning a delta. If the expected
-     * value is infinity then the delta value is ignored.
-     */
-    static public void assertEquals(float expected, float actual, float delta) {
-        assertEquals(null, expected, actual, delta);
-    }
-    /**
-     * Asserts that two longs are equal. If they are not
-     * an AssertionFailedError is thrown with the given message.
-     */
-    static public void assertEquals(String message, long expected, long actual) {
-        assertEquals(message, new Long(expected), new Long(actual));
-    }
-    /**
-     * Asserts that two longs are equal.
-     */
-    static public void assertEquals(long expected, long actual) {
-        assertEquals(null, expected, actual);
-    }
-    /**
-     * Asserts that two booleans are equal. If they are not
-     * an AssertionFailedError is thrown with the given message.
-     */
-    static public void assertEquals(String message, boolean expected, boolean actual) {
-            assertEquals(message, new Boolean(expected), new Boolean(actual));
-      }
-    /**
-     * Asserts that two booleans are equal.
-      */
-    static public void assertEquals(boolean expected, boolean actual) {
-        assertEquals(null, expected, actual);
-    }
-    /**
-     * Asserts that two bytes are equal. If they are not
-     * an AssertionFailedError is thrown with the given message.
-     */
-      static public void assertEquals(String message, byte expected, byte actual) {
-        assertEquals(message, new Byte(expected), new Byte(actual));
-    }
-    /**
-        * Asserts that two bytes are equal.
-     */
-    static public void assertEquals(byte expected, byte actual) {
-        assertEquals(null, expected, actual);
-    }
-    /**
-     * Asserts that two chars are equal. If they are not
-     * an AssertionFailedError is thrown with the given message.
-     */
-      static public void assertEquals(String message, char expected, char actual) {
-            assertEquals(message, new Character(expected), new Character(actual));
-      }
-    /**
-     * Asserts that two chars are equal.
-     */
-      static public void assertEquals(char expected, char actual) {
-        assertEquals(null, expected, actual);
-    }
-    /**
-     * Asserts that two shorts are equal. If they are not
-     * an AssertionFailedError is thrown with the given message.
-     */
-    static public void assertEquals(String message, short expected, short actual) {
-            assertEquals(message, new Short(expected), new Short(actual));
-    }
-      /**
-     * Asserts that two shorts are equal.
-     */
-    static public void assertEquals(short expected, short actual) {
-        assertEquals(null, expected, actual);
-    }
-    /**
-     * Asserts that two ints are equal. If they are not
-     * an AssertionFailedError is thrown with the given message.
-     */
-      static public void assertEquals(String message, int expected, int actual) {
-        assertEquals(message, new Integer(expected), new Integer(actual));
-      }
-      /**
-        * Asserts that two ints are equal.
-     */
-      static public void assertEquals(int expected, int actual) {
-          assertEquals(null, expected, actual);
-    }
-    /**
-     * Asserts that an object isn't null.
-     */
-    static public void assertNotNull(Object object) {
-        assertNotNull(null, object);
-    }
-    /**
-     * Asserts that an object isn't null. If it is
-     * an AssertionFailedError is thrown with the given message.
-     */
-    static public void assertNotNull(String message, Object object) {
-        assertTrue(message, object != null);
-    }
-    /**
-     * Asserts that an object is null.
-     */
-    static public void assertNull(Object object) {
-        assertNull(null, object);
-    }
-    /**
-     * Asserts that an object is null.  If it is not
-     * an AssertionFailedError is thrown with the given message.
-     */
-    static public void assertNull(String message, Object object) {
-        assertTrue(message, object == null);
-    }
-    /**
-     * Asserts that two objects refer to the same object. If they are not
-     * an AssertionFailedError is thrown with the given message.
-     */
-    static public void assertSame(String message, Object expected, Object actual) {
-        if (expected == actual)
-            return;
-        failNotSame(message, expected, actual);
-    }
-    /**
-     * Asserts that two objects refer to the same object. If they are not
-     * the same an AssertionFailedError is thrown.
-     */
-    static public void assertSame(Object expected, Object actual) {
-        assertSame(null, expected, actual);
-    }
-     /**
-      * Asserts that two objects refer to the same object. If they are not
-      * an AssertionFailedError is thrown with the given message.
-      */
-    static public void assertNotSame(String message, Object expected, Object actual) {
-        if (expected == actual)
-            failSame(message);
-    }
-    /**
-     * Asserts that two objects refer to the same object. If they are not
-     * the same an AssertionFailedError is thrown.
-     */
-    static public void assertNotSame(Object expected, Object actual) {
-        assertNotSame(null, expected, actual);
-    }
-
-    static private void failSame(String message) {
-        String formatted= "";
-         if (message != null)
-             formatted= message+" ";
-         fail(formatted+"expected not same");
-    }
-
-    static private void failNotSame(String message, Object expected, Object actual) {
-        String formatted= "";
-        if (message != null)
-            formatted= message+" ";
-        fail(formatted+"expected same:<"+expected+"> was not:<"+actual+">");
-    }
-
-    static private void failNotEquals(String message, Object expected, Object actual) {
-        fail(format(message, expected, actual));
-    }
-
-    static String format(String message, Object expected, Object actual) {
-        String formatted= "";
-        if (message != null)
-            formatted= message+" ";
-        return formatted+"expected:<"+expected+"> but was:<"+actual+">";
-    }
-}
diff --git a/junit/src/main/java/junit/framework/AssertionFailedError.java b/junit/src/main/java/junit/framework/AssertionFailedError.java
deleted file mode 100644
index e9cb3a3..0000000
--- a/junit/src/main/java/junit/framework/AssertionFailedError.java
+++ /dev/null
@@ -1,13 +0,0 @@
-package junit.framework;
-
-/**
- * Thrown when an assertion failed.
- */
-public class AssertionFailedError extends Error {
-
-    public AssertionFailedError () {
-    }
-    public AssertionFailedError (String message) {
-        super (message);
-    }
-}
diff --git a/junit/src/main/java/junit/framework/ComparisonFailure.java b/junit/src/main/java/junit/framework/ComparisonFailure.java
deleted file mode 100644
index a0ad176..0000000
--- a/junit/src/main/java/junit/framework/ComparisonFailure.java
+++ /dev/null
@@ -1,68 +0,0 @@
-package junit.framework;
-
-/**
- * Thrown when an assert equals for Strings failed.
- * 
- * Inspired by a patch from Alex Chaffee mailto:alex@purpletech.com
- */
-public class ComparisonFailure extends AssertionFailedError {
-    private String fExpected;
-    private String fActual;
-
-    /**
-     * Constructs a comparison failure.
-     * @param message the identifying message or null
-     * @param expected the expected string value
-     * @param actual the actual string value
-     */
-    public ComparisonFailure (String message, String expected, String actual) {
-        super (message);
-        fExpected= expected;
-        fActual= actual;
-    }
-    
-    /**
-     * Returns "..." in place of common prefix and "..." in
-     * place of common suffix between expected and actual.
-     * 
-     * @see java.lang.Throwable#getMessage()
-     */
-    public String getMessage() {
-        if (fExpected == null || fActual == null)
-            return Assert.format(super.getMessage(), fExpected, fActual);
-            
-        int end= Math.min(fExpected.length(), fActual.length());
-        
-        int i= 0;
-        for(; i < end; i++) {
-            if (fExpected.charAt(i) != fActual.charAt(i))
-                break;
-        }
-        int j= fExpected.length()-1;
-        int k= fActual.length()-1;
-        for (; k >= i && j >= i; k--,j--) {
-            if (fExpected.charAt(j) != fActual.charAt(k))
-                break;
-        }
-        String actual, expected;
-        
-        // equal strings
-        if (j < i && k < i) {
-            expected= fExpected;
-            actual= fActual;
-        } else {
-            expected= fExpected.substring(i, j+1);
-            actual= fActual.substring(i, k+1);
-            if (i <= end && i > 0) {
-                expected= "..."+expected;
-                actual= "..."+actual;
-            }
-            
-            if (j < fExpected.length()-1)
-                expected= expected+"...";
-            if (k < fActual.length()-1)
-                actual= actual+"...";
-        }    
-        return Assert.format(super.getMessage(), expected, actual);
-    }
-}
diff --git a/junit/src/main/java/junit/framework/Protectable.java b/junit/src/main/java/junit/framework/Protectable.java
deleted file mode 100644
index 9a63c96..0000000
--- a/junit/src/main/java/junit/framework/Protectable.java
+++ /dev/null
@@ -1,14 +0,0 @@
-package junit.framework;
-
-/**
- * A <em>Protectable</em> can be run and can throw a Throwable.
- *
- * @see TestResult
- */
-public interface Protectable {
-
-    /**
-     * Run the the following method protected.
-     */
-    public abstract void protect() throws Throwable;
-}
diff --git a/junit/src/main/java/junit/framework/Test.java b/junit/src/main/java/junit/framework/Test.java
deleted file mode 100644
index 94f25cf..0000000
--- a/junit/src/main/java/junit/framework/Test.java
+++ /dev/null
@@ -1,17 +0,0 @@
-package junit.framework;
-
-/**
- * A <em>Test</em> can be run and collect its results.
- *
- * @see TestResult
- */
-public interface Test {
-    /**
-     * Counts the number of test cases that will be run by this test.
-     */
-    public abstract int countTestCases();
-    /**
-     * Runs a test and collects its result in a TestResult instance.
-     */
-    public abstract void run(TestResult result);
-}
diff --git a/junit/src/main/java/junit/framework/TestCase.java b/junit/src/main/java/junit/framework/TestCase.java
deleted file mode 100644
index f29e8d2..0000000
--- a/junit/src/main/java/junit/framework/TestCase.java
+++ /dev/null
@@ -1,197 +0,0 @@
-package junit.framework;
-
-import java.lang.reflect.*;
-
-/**
- * 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;
- *
- *    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>assertTrue</code> with a boolean.
- * <pre>
- *    public void testAdd() {
- *        double result= fValue1 + fValue2;
- *        assertTrue(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>
- * TestCase 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>
- * TestCase= 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 {
-    /**
-     * the name of the test case
-     */
-    private String fName;
-
-    /**
-     * No-arg constructor to enable serialization. This method
-     * is not intended to be used by mere mortals without calling setName().
-     */
-    public 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();
-    }
-    /**
-     * 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 {
-        assertNotNull(fName);
-        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, (Class[]) null);
-        } catch (NoSuchMethodException e) {
-            fail("Method \""+fName+"\" not found");
-        }
-        if (!Modifier.isPublic(runMethod.getModifiers())) {
-            fail("Method \""+fName+"\" should be public");
-        }
-
-        try {
-            runMethod.invoke(this, (Object[]) null);
-        }
-        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 getName() + "(" + 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;
-    }
-}
diff --git a/junit/src/main/java/junit/framework/TestFailure.java b/junit/src/main/java/junit/framework/TestFailure.java
deleted file mode 100644
index ace2dbe..0000000
--- a/junit/src/main/java/junit/framework/TestFailure.java
+++ /dev/null
@@ -1,57 +0,0 @@
-package junit.framework;
-
-import java.io.PrintWriter;
-import java.io.StringWriter;
-
-
-/**
- * A <code>TestFailure</code> collects a failed test together with
- * the caught exception.
- * @see TestResult
- */
-public class TestFailure extends Object {
-    protected Test fFailedTest;
-    protected Throwable fThrownException;
-    
-
-    /**
-     * Constructs a TestFailure with the given test and exception.
-     */
-    public TestFailure(Test failedTest, Throwable thrownException) {
-        fFailedTest= failedTest;
-        fThrownException= thrownException;
-    }
-    /**
-     * Gets the failed test.
-     */
-    public Test failedTest() {
-        return fFailedTest;
-    }
-    /**
-     * Gets the thrown exception.
-     */
-    public Throwable thrownException() {
-        return fThrownException;
-    }
-    /**
-     * Returns a short description of the failure.
-     */
-    public String toString() {
-        StringBuffer buffer= new StringBuffer();
-        buffer.append(fFailedTest+": "+fThrownException.getMessage());
-        return buffer.toString();
-    }
-    public String trace() {
-        StringWriter stringWriter= new StringWriter();
-        PrintWriter writer= new PrintWriter(stringWriter);
-        thrownException().printStackTrace(writer);
-        StringBuffer buffer= stringWriter.getBuffer();
-        return buffer.toString();
-    }
-    public String exceptionMessage() {
-        return thrownException().getMessage();
-    }
-    public boolean isFailure() {
-        return thrownException() instanceof AssertionFailedError;
-    }
-}
diff --git a/junit/src/main/java/junit/framework/TestListener.java b/junit/src/main/java/junit/framework/TestListener.java
deleted file mode 100644
index 3ef3e33..0000000
--- a/junit/src/main/java/junit/framework/TestListener.java
+++ /dev/null
@@ -1,23 +0,0 @@
-package junit.framework;
-
-/**
- * A Listener for test progress
- */
-public interface TestListener {
-    /**
-      * An error occurred.
-      */
-    public void addError(Test test, Throwable t);
-    /**
-      * A failure occurred.
-      */
-     public void addFailure(Test test, AssertionFailedError t);  
-    /**
-     * A test ended.
-     */
-     public void endTest(Test test); 
-    /**
-     * A test started.
-     */
-    public void startTest(Test test);
-}
diff --git a/junit/src/main/java/junit/framework/TestResult.java b/junit/src/main/java/junit/framework/TestResult.java
deleted file mode 100644
index 153a77b..0000000
--- a/junit/src/main/java/junit/framework/TestResult.java
+++ /dev/null
@@ -1,166 +0,0 @@
-package junit.framework;
-
-import java.util.Vector;
-import java.util.Enumeration;
-
-/**
- * A <code>TestResult</code> collects the results of executing
- * a test case. It is an instance of the Collecting Parameter pattern.
- * The test framework distinguishes between <i>failures</i> and <i>errors</i>.
- * A failure is anticipated and checked for with assertions. Errors are
- * unanticipated problems like an <code>ArrayIndexOutOfBoundsException</code>.
- *
- * @see Test
- */
-public class TestResult extends Object {
-    protected Vector fFailures;
-    protected Vector fErrors;
-    protected Vector fListeners;
-    protected int fRunTests;
-    private boolean fStop;
-    
-    public TestResult() {
-        fFailures= new Vector();
-        fErrors= new Vector();
-        fListeners= new Vector();
-        fRunTests= 0;
-        fStop= false;
-    }
-    /**
-     * Adds an error to the list of errors. The passed in exception
-     * caused the error.
-     */
-    public synchronized void addError(Test test, Throwable t) {
-        fErrors.addElement(new TestFailure(test, t));
-        for (Enumeration e= cloneListeners().elements(); e.hasMoreElements(); ) {
-            ((TestListener)e.nextElement()).addError(test, t);
-        }
-    }
-    /**
-     * Adds a failure to the list of failures. The passed in exception
-     * caused the failure.
-     */
-    public synchronized void addFailure(Test test, AssertionFailedError t) {
-        fFailures.addElement(new TestFailure(test, t));
-        for (Enumeration e= cloneListeners().elements(); e.hasMoreElements(); ) {
-            ((TestListener)e.nextElement()).addFailure(test, t);
-        }
-    }
-    /**
-     * Registers a TestListener
-     */
-    public synchronized void addListener(TestListener listener) {
-        fListeners.addElement(listener);
-    }
-    /**
-     * Unregisters a TestListener
-     */
-    public synchronized void removeListener(TestListener listener) {
-        fListeners.removeElement(listener);
-    }
-    /**
-     * Returns a copy of the listeners.
-     */
-    private synchronized Vector cloneListeners() {
-        return (Vector)fListeners.clone();
-    }
-    /**
-     * Informs the result that a test was completed.
-     */
-    public void endTest(Test test) {
-        for (Enumeration e= cloneListeners().elements(); e.hasMoreElements(); ) {
-            ((TestListener)e.nextElement()).endTest(test);
-        }
-    }
-    /**
-     * Gets the number of detected errors.
-     */
-    public synchronized int errorCount() {
-        return fErrors.size();
-    }
-    /**
-     * Returns an Enumeration for the errors
-     */
-    public synchronized Enumeration errors() {
-        return fErrors.elements();
-    }
-    /**
-     * Gets the number of detected failures.
-     */
-    public synchronized int failureCount() {
-        return fFailures.size();
-    }
-    /**
-     * Returns an Enumeration for the failures
-     */
-    public synchronized Enumeration failures() {
-        return fFailures.elements();
-    }
-    /**
-     * Runs a TestCase.
-     */
-    protected void run(final TestCase test) {
-        startTest(test);
-        Protectable p= new Protectable() {
-            public void protect() throws Throwable {
-                test.runBare();
-            }
-        };
-        runProtected(test, p);
-
-        endTest(test);
-    }
-    /**
-     * Gets the number of run tests.
-     */
-    public synchronized int runCount() {
-        return fRunTests;
-    }
-    /**
-     * Runs a TestCase.
-     */
-    public void runProtected(final Test test, Protectable p) {
-        try {
-            p.protect();
-        } 
-        catch (AssertionFailedError e) {
-            addFailure(test, e);
-        }
-        catch (ThreadDeath e) { // don't catch ThreadDeath by accident
-            throw e;
-        }
-        catch (Throwable e) {
-            addError(test, e);
-        }
-    }
-    /**
-     * Checks whether the test run should stop
-     */
-    public synchronized boolean shouldStop() {
-        return fStop;
-    }
-    /**
-     * Informs the result that a test will be started.
-     */
-    public void startTest(Test test) {
-        final int count= test.countTestCases();
-        synchronized(this) {
-            fRunTests+= count;
-        }
-        for (Enumeration e= cloneListeners().elements(); e.hasMoreElements(); ) {
-            ((TestListener)e.nextElement()).startTest(test);
-        }
-    }
-    /**
-     * Marks that the test run should stop.
-     */
-    public synchronized void stop() {
-        fStop= true;
-    }
-    /**
-     * Returns whether the entire test was successful or not.
-     */
-    public synchronized boolean wasSuccessful() {
-        return failureCount() == 0 && errorCount() == 0;
-    }
-}
diff --git a/junit/src/main/java/junit/framework/TestSuite.java b/junit/src/main/java/junit/framework/TestSuite.java
deleted file mode 100644
index bf23198..0000000
--- a/junit/src/main/java/junit/framework/TestSuite.java
+++ /dev/null
@@ -1,267 +0,0 @@
-package junit.framework;
-
-import java.util.Vector;
-import java.util.Enumeration;
-import java.io.PrintWriter;
-import java.io.StringWriter;
-import java.lang.reflect.*;
-import java.lang.reflect.Constructor;
-
-/**
- * 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 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 Huffihutte,
-     * 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 names= new Vector();
-        while (Test.class.isAssignableFrom(superClass)) {
-            Method[] methods= superClass.getDeclaredMethods();
-            for (int i= 0; i < methods.length; i++) {
-                addTestMethod(methods[i], 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 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(new Object[]{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 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 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("warning") {
-            protected void runTest() {
-                fail(message);
-            }
-        };
-    }
-}
diff --git a/junit/src/main/java/junit/framework/package.html b/junit/src/main/java/junit/framework/package.html
deleted file mode 100644
index 770d470..0000000
--- a/junit/src/main/java/junit/framework/package.html
+++ /dev/null
@@ -1,5 +0,0 @@
-<HTML>
-<BODY>
-The junit test framework.
-</BODY>
-</HTML>