M7350v1_en_gpl

base/test-runner/tests/Android.mk

@@ -0,0 +1,29 @@
+# Copyright 2010, The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+LOCAL_PATH:= $(call my-dir)
+include $(CLEAR_VARS)
+
+# We only want this apk build for tests.
+LOCAL_MODULE_TAGS := tests
+
+LOCAL_JAVA_LIBRARIES := android.test.runner
+
+# Include all test java files.
+LOCAL_SRC_FILES := $(call all-java-files-under, src)
+
+LOCAL_PACKAGE_NAME := FrameworkTestRunnerTests
+
+include $(BUILD_PACKAGE)
+

base/test-runner/tests/AndroidManifest.xml

@@ -0,0 +1,43 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2010 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+          package="com.android.frameworks.testrunner.tests">
+
+    <application>
+        <uses-library android:name="android.test.runner" />
+        <activity android:name="android.test.StubTestBrowserActivity"
+            android:label="Stubbed Test Browser">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN"/>
+                <category android:name="android.intent.category.FOR_TESTS_ONLY"/>
+            </intent-filter>
+        </activity>
+
+        <activity android:name="android.test.TestBrowserTests"
+            android:label="Test Browser Tests">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN"/>
+                <category android:name="android.intent.category.UNIT_TEST"/>
+            </intent-filter>
+        </activity>`
+    </application>
+
+    <instrumentation
+        android:name="android.test.InstrumentationTestRunner"
+        android:targetPackage="com.android.frameworks.testrunner.tests"
+        android:label="Framework testrunner tests" />
+</manifest>

base/test-runner/tests/src/android/test/AndroidTestRunnerTest.java

@@ -0,0 +1,294 @@
+/*
+ * Copyright (C) 2008 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.test;
+
+import android.test.mock.MockContext;
+import android.test.suitebuilder.annotation.SmallTest;
+
+import com.google.android.collect.Lists;
+
+import junit.framework.TestCase;
+import junit.framework.AssertionFailedError;
+import junit.framework.Test;
+import junit.framework.TestSuite;
+import junit.framework.TestListener;
+
+import java.util.List;
+import java.util.Arrays;
+
+/**
+ * Unit tests for {@link AndroidTestRunner}
+ */
+@SmallTest
+public class AndroidTestRunnerTest extends TestCase {
+    private AndroidTestRunner mAndroidTestRunner;
+    private StubContext mStubContext;
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+        mStubContext = new StubContext(getClass().getClassLoader());
+
+        mAndroidTestRunner = new AndroidTestRunner();
+        mAndroidTestRunner.setContext(mStubContext);
+    }
+
+    public void testLoadNoTestCases() throws Exception {
+        mAndroidTestRunner.setTestClassName(TestSuite.class.getName(), null);
+
+        List<TestCase> testCases = mAndroidTestRunner.getTestCases();
+        assertNotNull(testCases);
+        assertEquals(1, testCases.size());
+        assertEquals("warning", testCases.get(0).getName());
+        assertEquals(TestSuite.class.getSimpleName(), mAndroidTestRunner.getTestClassName());
+    }
+
+    public void testSetTestSuiteWithOneTestCase() throws Exception {
+        mAndroidTestRunner.setTestClassName(OneTestTestCase.class.getName(), null);
+
+        List<TestCase> testCases = mAndroidTestRunner.getTestCases();
+        assertNotNull(testCases);
+        assertEquals(1, testCases.size());
+        assertEquals("testOne", testCases.get(0).getName());
+        assertEquals(OneTestTestCase.class.getSimpleName(), mAndroidTestRunner.getTestClassName());
+    }
+
+    public void testRunTest() throws Exception {
+        mAndroidTestRunner.setTestClassName(OneTestTestCase.class.getName(), null);
+
+        TestListenerStub testListenerStub = new TestListenerStub();
+        mAndroidTestRunner.addTestListener(testListenerStub);
+
+        mAndroidTestRunner.runTest();
+
+        assertTrue(testListenerStub.saw("testOne"));
+    }
+
+    public void testRunTestWithAndroidTestCase() throws Exception {
+        mAndroidTestRunner.setTestClassName(
+                OneAndroidTestTestCase.class.getName(), "testOneAndroid");
+
+        TestListenerStub testListenerStub = new TestListenerStub();
+        mAndroidTestRunner.addTestListener(testListenerStub);
+
+        assertNull(((AndroidTestCase) mAndroidTestRunner.getTestCases().get(0)).getContext());
+
+        mAndroidTestRunner.runTest();
+
+        assertTrue(testListenerStub.saw("testOneAndroid"));
+        assertSame(mStubContext,
+                ((AndroidTestCase) mAndroidTestRunner.getTestCases().get(0)).getContext());
+    }
+
+    public void testRunTestWithAndroidTestCaseInSuite() throws Exception {
+        mAndroidTestRunner.setTestClassName(OneAndroidTestTestCase.class.getName(), null);
+
+        TestListenerStub testListenerStub = new TestListenerStub();
+        mAndroidTestRunner.addTestListener(testListenerStub);
+
+        mAndroidTestRunner.runTest();
+
+        assertTrue(testListenerStub.saw("testOneAndroid"));
+
+        List<TestCase> testCases = mAndroidTestRunner.getTestCases();
+        for (TestCase testCase : testCases) {
+            assertSame(mStubContext, ((AndroidTestCase) testCase).getContext());
+        }
+    }
+
+    public void testRunTestWithAndroidTestCaseInNestedSuite() throws Exception {
+        mAndroidTestRunner.setTestClassName(AndroidTestCaseTestSuite.class.getName(), null);
+
+        TestListenerStub testListenerStub = new TestListenerStub();
+        mAndroidTestRunner.addTestListener(testListenerStub);
+
+        mAndroidTestRunner.runTest();
+
+        assertTrue(testListenerStub.saw("testOneAndroid"));
+
+        List<TestCase> testCases = mAndroidTestRunner.getTestCases();
+        for (TestCase testCase : testCases) {
+            assertSame(mStubContext, ((AndroidTestCase) testCase).getContext());
+        }
+    }
+
+    public void testRunTestWithNullListener() throws Exception {
+        mAndroidTestRunner.setTestClassName(OneTestTestCase.class.getName(), null);
+
+        mAndroidTestRunner.addTestListener(null);
+        try {
+            mAndroidTestRunner.runTest();
+        } catch (NullPointerException e) {
+            fail("Should not add a null TestListener");
+        }
+    }
+
+    public void testSetTestClassWithTestSuiteProvider() throws Exception {
+        mAndroidTestRunner.setTestClassName(SampleTestSuiteProvider.class.getName(), null);
+        List<TestCase> testCases = mAndroidTestRunner.getTestCases();
+        List<String> testNames = Lists.newArrayList();
+        for (TestCase testCase : testCases) {
+            testNames.add(testCase.getName());
+        }
+
+        // Use the test suite provided by the interface method rather than the static suite method.
+        assertEquals(Arrays.asList("testOne"), testNames);
+    }
+
+    public void testSetTestClassWithTestSuite() throws Exception {
+        mAndroidTestRunner.setTestClassName(SampleTestSuite.class.getName(), null);
+        List<TestCase> testCases = mAndroidTestRunner.getTestCases();
+        List<String> testNames = Lists.newArrayList();
+        for (TestCase testCase : testCases) {
+            testNames.add(testCase.getName());
+        }
+        assertEquals(Arrays.asList("testOne", "testOne", "testTwo"), testNames);
+    }
+
+    public void testRunSingleTestMethod() throws Exception {
+        String testMethodName = "testTwo";
+        mAndroidTestRunner.setTestClassName(TwoTestTestCase.class.getName(), testMethodName);
+        List<TestCase> testCases = mAndroidTestRunner.getTestCases();
+        List<String> testNames = Lists.newArrayList();
+        for (TestCase testCase : testCases) {
+            testNames.add(testCase.getName());
+        }
+        assertEquals(Arrays.asList(testMethodName), testNames);
+    }
+
+    public void testSetTestClassInvalidClass() throws Exception {
+        try {
+            mAndroidTestRunner.setTestClassName("class.that.does.not.exist", null);
+            fail("expected exception not thrown");
+        } catch (RuntimeException e) {
+            // expected
+        }
+    }
+    
+    public void testRunSkipExecution() throws Exception {
+        String testMethodName = "testFail";
+        mAndroidTestRunner.setTestClassName(
+                OnePassOneErrorOneFailTestCase.class.getName(), testMethodName);
+        
+        TestListenerStub testListenerStub = new TestListenerStub();
+        mAndroidTestRunner.addTestListener(testListenerStub);
+        
+        // running the failing test should pass - ie as if its not run
+        mAndroidTestRunner.runTest();
+        
+        assertTrue(testListenerStub.saw("testFail"));
+    }
+
+    public static class SampleTestSuiteProvider implements TestSuiteProvider {
+
+        public TestSuite getTestSuite() {
+            TestSuite testSuite = new TestSuite();
+            testSuite.addTestSuite(OneTestTestCase.class);
+            return testSuite;
+        }
+
+        public static Test suite() {
+            return SampleTestSuite.suite();
+        }
+    }
+
+    public static class SampleTestSuite {
+        public static TestSuite suite() {
+            TestSuite testSuite = new TestSuite();
+            testSuite.addTestSuite(OneTestTestCase.class);
+            testSuite.addTestSuite(TwoTestTestCase.class);
+            return testSuite;
+        }
+    }
+
+    public static class AndroidTestCaseTestSuite {
+        public static TestSuite suite() {
+            TestSuite testSuite = new TestSuite();
+            testSuite.addTestSuite(OneAndroidTestTestCase.class);
+            return testSuite;
+        }
+    }
+
+    public static class OneAndroidTestTestCase extends AndroidTestCase {
+        public void testOneAndroid() throws Exception {
+        }
+    }
+
+    public static class OneTestTestCase extends TestCase {
+        public void testOne() throws Exception {
+        }
+    }
+
+    public static class TwoTestTestCase extends TestCase {
+        public void testOne() throws Exception {
+        }
+
+        public void testTwo() throws Exception {
+        }
+    }
+
+    public static class OnePassOneErrorOneFailTestCase extends TestCase {
+        public void testPass() throws Exception {
+        }
+
+        public void testError() throws Exception {
+            throw new Exception();
+        }
+
+        public void testFail() throws Exception {
+            fail();
+        }
+    }
+
+    private static class TestListenerStub implements TestListener {
+        List<String> testNames = Lists.newArrayList();
+
+        public void addError(Test test, Throwable t) {
+        }
+
+        public void addFailure(Test test, AssertionFailedError t) {
+        }
+
+        public void endTest(Test test) {
+        }
+
+        public void startTest(Test test) {
+            if (test instanceof TestCase) {
+                testNames.add(((TestCase) test).getName());
+            } else if (test instanceof TestSuite) {
+                testNames.add(((TestSuite) test).getName());
+            }
+        }
+
+        public boolean saw(String testName) {
+            return testNames.contains(testName);
+        }
+    }
+
+    private static class StubContext extends MockContext {
+        private ClassLoader mClassLoader;
+
+        public StubContext(ClassLoader classLoader) {
+            this.mClassLoader = classLoader;
+        }
+
+        @Override
+        public ClassLoader getClassLoader() {
+            return mClassLoader;
+        }
+    }
+}

base/test-runner/tests/src/android/test/InstrumentationTestRunnerTest.java

@@ -0,0 +1,356 @@
+/*
+ * Copyright (C) 2008 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.test;
+
+import android.app.Instrumentation;
+import android.content.Context;
+import android.os.Bundle;
+import android.test.mock.MockContext;
+import android.test.suitebuilder.ListTestCaseNames;
+import android.test.suitebuilder.ListTestCaseNames.TestDescriptor;
+import android.test.suitebuilder.annotation.SmallTest;
+
+import junit.framework.Test;
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
+
+import java.util.List;
+
+/**
+ * Tests for {@link InstrumentationTestRunner}
+ */
+@SmallTest
+public class InstrumentationTestRunnerTest extends TestCase {
+    private StubInstrumentationTestRunner mInstrumentationTestRunner;
+    private StubAndroidTestRunner mStubAndroidTestRunner;
+    private String mTargetContextPackageName;
+
+    protected void setUp() throws Exception {
+        super.setUp();
+        mStubAndroidTestRunner = new StubAndroidTestRunner();
+        mTargetContextPackageName = "android.test.suitebuilder.examples";
+        mInstrumentationTestRunner = new StubInstrumentationTestRunner(
+                new StubContext("com.google.foo.tests"),
+                new StubContext(mTargetContextPackageName), mStubAndroidTestRunner);
+    }
+
+    public void testOverrideTestToRunWithClassArgument() throws Exception {
+        String expectedTestClassName = PlaceHolderTest.class.getName();
+        mInstrumentationTestRunner.onCreate(createBundle(
+                InstrumentationTestRunner.ARGUMENT_TEST_CLASS, expectedTestClassName));
+
+        assertTestRunnerCalledWithExpectedParameters(expectedTestClassName, "testPlaceHolder");
+    }
+
+    public void testOverrideTestToRunWithClassAndMethodArgument() throws Exception {
+        String expectedTestClassName = PlaceHolderTest.class.getName();
+        String expectedTestMethodName = "testPlaceHolder";
+        String classAndMethod = expectedTestClassName + "#" + expectedTestMethodName;
+        mInstrumentationTestRunner.onCreate(createBundle(
+                InstrumentationTestRunner.ARGUMENT_TEST_CLASS, classAndMethod));
+
+        assertTestRunnerCalledWithExpectedParameters(expectedTestClassName,
+                expectedTestMethodName);
+    }
+
+    public void testUseSelfAsTestSuiteProviderWhenNoMetaDataOrClassArgument() throws Exception {
+        TestSuite testSuite = new TestSuite();
+        testSuite.addTestSuite(PlaceHolderTest.class);
+        mInstrumentationTestRunner.setAllTestsSuite(testSuite);
+        mInstrumentationTestRunner.onCreate(null);
+        assertTestRunnerCalledWithExpectedParameters(
+                PlaceHolderTest.class.getName(), "testPlaceHolder");
+    }
+    
+    public void testMultipleTestClass() throws Exception {
+        String classArg = PlaceHolderTest.class.getName() + "," + 
+            PlaceHolderTest2.class.getName();
+        mInstrumentationTestRunner.onCreate(createBundle(
+                InstrumentationTestRunner.ARGUMENT_TEST_CLASS, classArg));
+        
+        Test test = mStubAndroidTestRunner.getTest();
+
+        assertContentsInOrder(ListTestCaseNames.getTestNames((TestSuite) test),
+            new TestDescriptor(PlaceHolderTest.class.getName(), "testPlaceHolder"), 
+            new TestDescriptor(PlaceHolderTest2.class.getName(), "testPlaceHolder2"));
+        
+    }
+
+    /**
+     * Test that runtime exceptions during runTest are handled gracefully
+     */
+    public void testUnhandledException() throws Exception {
+        StubAndroidTestRunner stubAndroidTestRunner = new StubAndroidTestRunner() {
+            @Override
+            public void runTest() {
+                throw new RuntimeException();
+            }
+        };
+        StubInstrumentationTestRunner instrumentationTestRunner = new StubInstrumentationTestRunner(
+                new StubContext("com.google.foo.tests"),
+                new StubContext(mTargetContextPackageName), stubAndroidTestRunner);
+        instrumentationTestRunner.onCreate(new Bundle());
+        instrumentationTestRunner.onStart();
+        assertTrue("Instrumentation did not finish", instrumentationTestRunner.isFinished());
+        // ensure a meaningful error message placed in results
+        String resultsData = instrumentationTestRunner.mResults.getString(
+                Instrumentation.REPORT_KEY_STREAMRESULT);
+        assertTrue("Instrumentation results is missing RuntimeException",
+                resultsData.contains("RuntimeException"));
+    }
+
+    /**
+     * Test that specifying a method which does not exist is handled gracefully
+     */
+    public void testBadMethodArgument() throws Exception {
+        String testClassName = PlaceHolderTest.class.getName();
+        String invalidMethodName = "testNoExist";
+        String classAndMethod = testClassName + "#" + invalidMethodName;
+        mInstrumentationTestRunner.onCreate(createBundle(
+                InstrumentationTestRunner.ARGUMENT_TEST_CLASS, classAndMethod));
+        assertTestRunnerCalledWithExpectedParameters(testClassName,
+                invalidMethodName);
+    }
+
+    public void testDelayParameter() throws Exception {
+        int delayMsec = 1000;
+        Bundle args = new Bundle();
+        args.putInt(InstrumentationTestRunner.ARGUMENT_DELAY_MSEC, delayMsec);
+        args.putString(InstrumentationTestRunner.ARGUMENT_TEST_CLASS,
+                PlaceHolderTest.class.getName() + "," +
+                PlaceHolderTest2.class.getName());
+        mInstrumentationTestRunner.onCreate(args);
+        Thread t = new Thread() { public void run() { mInstrumentationTestRunner.onStart(); } };
+
+        // Should delay three times: before, between, and after the two tests.
+        long beforeTest = System.currentTimeMillis();
+        t.start();
+        t.join();
+        assertTrue(System.currentTimeMillis() > beforeTest + delayMsec * 3);
+        assertTrue(mInstrumentationTestRunner.isStarted());
+        assertTrue(mInstrumentationTestRunner.isFinished());
+        assertTrue(mStubAndroidTestRunner.isRun());
+    }
+
+    /**
+     * Test that the -e {@link InstrumentationTestRunner.ARGUMENT_ANNOTATION} parameter properly
+     * selects tests.
+     */
+    public void testAnnotationParameter() throws Exception {
+        String expectedTestClassName = AnnotationTest.class.getName();
+        Bundle args = new Bundle();
+        args.putString(InstrumentationTestRunner.ARGUMENT_TEST_CLASS, expectedTestClassName);
+        args.putString(InstrumentationTestRunner.ARGUMENT_ANNOTATION, FlakyTest.class.getName());
+        mInstrumentationTestRunner.onCreate(args);
+        assertTestRunnerCalledWithExpectedParameters(expectedTestClassName, "testAnnotated");
+    }
+    
+    /**
+     * Test that the -e {@link InstrumentationTestRunner.ARGUMENT_NOT_ANNOTATION} parameter
+     * properly excludes tests.
+     */
+    public void testNotAnnotationParameter() throws Exception {
+        String expectedTestClassName = AnnotationTest.class.getName();
+        Bundle args = new Bundle();
+        args.putString(InstrumentationTestRunner.ARGUMENT_TEST_CLASS, expectedTestClassName);
+        args.putString(InstrumentationTestRunner.ARGUMENT_NOT_ANNOTATION,
+                FlakyTest.class.getName());
+        mInstrumentationTestRunner.onCreate(args);
+        assertTestRunnerCalledWithExpectedParameters(expectedTestClassName, "testNotAnnotated");
+    }
+
+    private void assertContentsInOrder(List<TestDescriptor> actual, TestDescriptor... source) {
+        TestDescriptor[] clonedSource = source.clone();
+        assertEquals("Unexpected number of items.", clonedSource.length, actual.size());
+        for (int i = 0; i < actual.size(); i++) {
+            TestDescriptor actualItem = actual.get(i);
+            TestDescriptor sourceItem = clonedSource[i];
+            assertEquals("Unexpected item. Index: " + i, sourceItem, actualItem);
+        }
+    }
+
+    private void assertTestRunnerCalledWithExpectedParameters(
+            String expectedTestClassName, String expectedTestMethodName) {
+        Test test = mStubAndroidTestRunner.getTest();
+        assertContentsInOrder(ListTestCaseNames.getTestNames((TestSuite) test),
+                new TestDescriptor(expectedTestClassName, expectedTestMethodName));  
+        assertTrue(mInstrumentationTestRunner.isStarted());
+        assertFalse(mInstrumentationTestRunner.isFinished());
+    }
+
+    private Bundle createBundle(String key, String value) {
+        Bundle bundle = new Bundle();
+        bundle.putString(key, value);
+        return bundle;
+    }
+
+    private static class StubInstrumentationTestRunner extends InstrumentationTestRunner {
+        private Context mContext;
+        private Context mTargetContext;
+        private boolean mStarted;
+        private boolean mFinished;
+        private AndroidTestRunner mAndroidTestRunner;
+        private TestSuite mTestSuite;
+        private TestSuite mDefaultTestSuite;
+        private String mPackageNameForDefaultTests;
+        private Bundle mResults;
+
+        public StubInstrumentationTestRunner(Context context, Context targetContext,
+                AndroidTestRunner androidTestRunner) {
+            this.mContext = context;
+            this.mTargetContext = targetContext;
+            this.mAndroidTestRunner = androidTestRunner;
+        }
+
+        public Context getContext() {
+            return mContext;
+        }
+
+        public TestSuite getAllTests() {
+            return mTestSuite;
+        }
+
+        public Context getTargetContext() {
+            return mTargetContext;
+        }
+
+        protected AndroidTestRunner getAndroidTestRunner() {
+            return mAndroidTestRunner;
+        }
+
+        public void start() {
+            mStarted = true;
+        }
+
+        public void finish(int resultCode, Bundle results) {
+            mFinished = true;
+            mResults = results;
+        }
+
+        public boolean isStarted() {
+            return mStarted;
+        }
+
+        public boolean isFinished() {
+            return mFinished;
+        }
+
+        public void setAllTestsSuite(TestSuite testSuite) {
+            mTestSuite = testSuite;
+        }
+        
+        public void setDefaultTestsSuite(TestSuite testSuite) {
+            mDefaultTestSuite = testSuite;
+        }
+
+        public String getPackageNameForDefaultTests() {
+            return mPackageNameForDefaultTests;
+        }
+
+        @Override
+        void prepareLooper() {
+            // ignore
+        }
+    }
+
+    private static class StubContext extends MockContext {
+        private String mPackageName;
+
+        public StubContext(String packageName) {
+            this.mPackageName = packageName;
+        }
+
+        @Override
+        public String getPackageCodePath() {
+            return mPackageName;
+        }
+
+        @Override
+        public String getPackageName() {
+            return mPackageName;
+        }
+
+        @Override
+        public ClassLoader getClassLoader() {
+            return getClass().getClassLoader();
+        }
+    }
+
+    private static class StubAndroidTestRunner extends AndroidTestRunner {
+        private Test mTest;
+        private boolean mRun;
+
+        public boolean isRun() {
+            return mRun;
+        }
+
+        public void setTest(Test test) {
+            super.setTest(test);
+            mTest = test;
+        }
+
+        public Test getTest() {
+            return mTest;
+        }
+
+        public void runTest() {
+            super.runTest();
+            mRun = true;
+        }
+    }
+
+    /**
+     * Empty test used for validation
+     */
+    public static class PlaceHolderTest extends TestCase {
+
+        public PlaceHolderTest() {
+            super("testPlaceHolder");
+        }
+
+        public void testPlaceHolder() throws Exception {
+
+        }
+    }
+    
+    /**
+     * Empty test used for validation
+     */
+    public static class PlaceHolderTest2 extends TestCase {
+
+        public PlaceHolderTest2() {
+            super("testPlaceHolder2");
+        }
+
+        public void testPlaceHolder2() throws Exception {
+
+        }
+    }
+
+    /**
+     * Annotated test used for validation.
+     */
+    public static class AnnotationTest extends TestCase {
+
+        public void testNotAnnotated() throws Exception {
+        }
+
+        @FlakyTest
+        public void testAnnotated() throws Exception {
+        }
+    }
+}

base/test-runner/tests/src/android/test/StubTestBrowserActivity.java

@@ -0,0 +1,33 @@
+/*
+ * Copyright (C) 2007 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.test;
+
+import junit.framework.TestSuite;
+
+public class StubTestBrowserActivity extends TestBrowserActivity {
+
+    private static TestSuite mTestSuite;
+
+    static void setTopTestSuite(TestSuite testSuite) {
+        mTestSuite = testSuite;
+    }
+
+    @Override
+    public TestSuite getTopTestSuite() {
+        return mTestSuite;
+    }
+}

base/test-runner/tests/src/android/test/TestBrowserActivityTest.java

@@ -0,0 +1,275 @@
+/*
+ * Copyright (C) 2007 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.test;
+
+import android.app.Activity;
+import android.app.Instrumentation;
+import android.content.Intent;
+import android.net.Uri;
+import android.os.RemoteException;
+import android.os.ServiceManager;
+import android.view.IWindowManager;
+import android.widget.ListView;
+
+import com.google.android.collect.Lists;
+
+import junit.framework.Test;
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
+
+import java.util.List;
+
+public class TestBrowserActivityTest extends InstrumentationTestCase {
+
+    private TestBrowserActivity mTestBrowserActivity;
+    private StubTestBrowserController mTestBrowserController;
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+        StubTestBrowserActivity.setTopTestSuite(null);
+        mTestBrowserController = new StubTestBrowserController();
+        ServiceLocator.setTestBrowserController(mTestBrowserController);
+    }
+
+    @Override
+    protected void tearDown() throws Exception {
+        if (mTestBrowserActivity != null) {
+            mTestBrowserActivity.finish();
+        }
+        mTestBrowserActivity = null;
+        super.tearDown();
+    }
+
+    public void testEmptyListContent() throws Exception {
+        StubTestBrowserActivity.setTopTestSuite(new TestSuite());
+
+        mTestBrowserActivity = createActivity();
+
+        ListView listView = getListView();
+        // There is always an item on the list for running all tests.
+        assertEquals("Unexpected number of items on list view.", 1, listView.getCount());
+
+        assertEquals("Stubbed Test Browser", mTestBrowserActivity.getTitle().toString());
+    }
+
+    public void testOneListContent() throws Exception {
+        List<String> testCaseNames = Lists.newArrayList("AllTests");
+        StubTestBrowserActivity.setTopTestSuite(createTestSuite(testCaseNames));
+
+        mTestBrowserActivity = createActivity();
+
+        ListView listView = getListView();
+        assertListViewContents(testCaseNames, listView);
+    }
+
+    public void testListWithTestCases() throws Exception {
+        List<String> testCaseNames = Lists.newArrayList("AllTests", "Apples", "Bananas", "Oranges");
+        StubTestBrowserActivity.setTopTestSuite(createTestSuite(testCaseNames));
+
+        mTestBrowserActivity = createActivity();
+
+        ListView listView = getListView();
+        assertListViewContents(testCaseNames, listView);
+    }
+
+    public void testListWithTestSuite() throws Exception {
+        List<String> testCaseNames = Lists.newArrayList(OneTestTestCase.class.getSimpleName());
+        StubTestBrowserActivity.setTopTestSuite(new OneTestInTestSuite());
+
+        mTestBrowserActivity = createActivity();
+
+        ListView listView = getListView();
+        assertListViewContents(testCaseNames, listView);
+    }
+
+    public void testSelectATestCase() throws Exception {
+        List<String> testCaseNames = Lists.newArrayList("AllTests");
+        TestSuite testSuite = createTestSuite(testCaseNames);
+        StubTestBrowserActivity.setTopTestSuite(testSuite);
+
+        mTestBrowserController.setTestCase(OneTestTestCase.class);
+        mTestBrowserActivity = createActivity();
+
+        Instrumentation.ActivityMonitor activityMonitor = getInstrumentation().addMonitor(
+                TestBrowserControllerImpl.TEST_RUNNER_ACTIVITY_CLASS_NAME, null, false);
+        try {
+            assertEquals(0, activityMonitor.getHits());
+
+            ListView listView = getListView();
+            int invokedTestCaseIndex = 0;
+            listView.performItemClick(listView, invokedTestCaseIndex, 0);
+
+            Activity activity = activityMonitor.waitForActivityWithTimeout(2000);
+            assertNotNull(activity);
+            try {
+                assertEquals(1, activityMonitor.getHits());
+                assertEquals(invokedTestCaseIndex, mTestBrowserController.getLastPosition());
+            } finally {
+                activity.finish();
+            }
+        } finally {
+            getInstrumentation().removeMonitor(activityMonitor);
+        }
+    }
+
+    public void testCreateFromIntentWithOneTest() throws Exception {
+        List<String> testCaseNames = Lists.newArrayList("testOne");
+
+        mTestBrowserActivity = launchTestBrowserActivity(new TestSuite(OneTestTestCase.class));
+
+        ListView listView = getListView();
+        assertListViewContents(testCaseNames, listView);
+    }
+
+    public void testUpdateListOnStart() throws Exception {
+        StubTestBrowserActivity.setTopTestSuite(new TestSuite());
+
+        mTestBrowserActivity = createActivity();
+
+        ListView listView = getListView();
+        assertEquals("Unexpected number of items on list view.", 1, listView.getCount());
+
+        List<String> testCaseNames = Lists.newArrayList("AllTests");
+        StubTestBrowserActivity.setTopTestSuite(createTestSuite(testCaseNames));
+
+        getInstrumentation().runOnMainSync(new Runnable() {
+            public void run() {
+                ((StubTestBrowserActivity) mTestBrowserActivity).onStart();
+            }
+        });
+
+        listView = getListView();
+        assertListViewContents(testCaseNames, listView);
+    }
+
+    public void testTitleHasTestSuiteName() throws Exception {
+        final String testSuiteName = "com.android.TestSuite";
+        StubTestBrowserActivity.setTopTestSuite(new TestSuite(testSuiteName));
+
+        mTestBrowserActivity = createActivity();
+
+        assertEquals("TestSuite", mTestBrowserActivity.getTitle().toString());
+    }
+    
+    private TestSuite createTestSuite(List<String> testCaseNames) {
+        return createTestSuite(testCaseNames.toArray(new String[testCaseNames.size()]));
+    }
+
+    private TestSuite createTestSuite(String... testCaseNames) {
+        TestSuite testSuite = new TestSuite();
+        for (String testCaseName : testCaseNames) {
+            testSuite.addTest(new FakeTestCase(testCaseName));
+        }
+
+        return testSuite;
+    }
+
+    public static class FakeTestCase extends TestCase {
+        public FakeTestCase(String name) {
+            super(name);
+        }
+    }
+
+    public static class OneTestTestCase extends TestCase {
+        public void testOne() throws Exception {
+        }
+    }
+
+    public static class OneTestInTestSuite extends TestSuite {
+        public static Test suite() {
+            TestSuite suite = new TestSuite(OneTestInTestSuite.class.getName());
+            suite.addTestSuite(OneTestTestCase.class);
+            return suite;
+        }
+    }
+
+    private void assertListViewContents(List<String> expectedTestCaseNames, ListView listView) {
+        assertEquals("Run All", listView.getItemAtPosition(0).toString());
+        assertEquals("Unexpected number of items on list view.",
+                expectedTestCaseNames.size() + 1, listView.getCount());
+        for (int i = 0; i < expectedTestCaseNames.size(); i++) {
+            String expectedTestCaseName = expectedTestCaseNames.get(i);
+            String actualTestCaseName = listView.getItemAtPosition(i + 1).toString();
+            assertEquals("Unexpected test case name. Index: " + i,
+                    expectedTestCaseName, actualTestCaseName);
+        }
+    }
+
+    private ListView getListView() {
+        return mTestBrowserActivity.getListView();
+    }
+
+    private TestBrowserActivity createActivity() throws RemoteException {
+        return launchActivity(getAndroidPackageName(), StubTestBrowserActivity.class, null);
+    }
+
+    private Intent createIntent(TestSuite testSuite) {
+        Intent intent = new Intent(Intent.ACTION_RUN);
+        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+        String className = StubTestBrowserActivity.class.getName();
+        String packageName = getAndroidPackageName();
+        intent.setClassName(packageName, className);
+        intent.setData(Uri.parse(testSuite.getName()));
+        return intent;
+    }
+
+    private String getAndroidPackageName() {
+        String packageName = getInstrumentation().getTargetContext().getPackageName();
+        return packageName;
+    }
+
+    private TestBrowserActivity launchTestBrowserActivity(TestSuite testSuite)
+            throws RemoteException {
+        getInstrumentation().setInTouchMode(false);
+
+        TestBrowserActivity activity =
+                (TestBrowserActivity) getInstrumentation().startActivitySync(
+                        createIntent(testSuite));
+        getInstrumentation().waitForIdleSync();
+        return activity;
+    }
+
+    private static class StubTestBrowserController extends TestBrowserControllerImpl {
+        private int mPosition;
+        private Class<? extends TestCase> mTestCaseClass;
+
+        public Intent getIntentForTestAt(int position) {
+            mPosition = position;
+
+            Intent intent = new Intent();
+            intent.setAction(Intent.ACTION_RUN);
+
+            String className = TestBrowserControllerImpl.TEST_RUNNER_ACTIVITY_CLASS_NAME;
+            String testName = mTestCaseClass.getClass().getName();
+
+            String packageName = className.substring(0, className.lastIndexOf("."));
+            intent.setClassName(packageName, className);
+            intent.setData(Uri.parse(testName));
+
+            return intent;
+        }
+
+        public void setTestCase(Class<? extends TestCase> testCaseClass) {
+            mTestCaseClass = testCaseClass;
+        }
+
+        public int getLastPosition() {
+            return mPosition;
+        }
+    }
+}

base/test-runner/tests/src/android/test/TestBrowserControllerImplTest.java

@@ -0,0 +1,134 @@
+/*
+ * Copyright (C) 2007 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.test;
+
+import android.content.Intent;
+
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
+
+import java.util.Arrays;
+import java.util.List;
+
+public class TestBrowserControllerImplTest extends TestCase {
+    private TestBrowserControllerImpl mTestBrowserController;
+    private TestBrowserViewStub mTestBrowserView;
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+        mTestBrowserController = new TestBrowserControllerImpl();
+        mTestBrowserView = new TestBrowserViewStub();
+        mTestBrowserController.registerView(mTestBrowserView);
+    }
+
+    public void testSetTestSuite() throws Exception {
+        TestSuite testSuite = new TestSuite();
+        testSuite.addTestSuite(DummyTestCase.class);
+
+        mTestBrowserController.setTestSuite(testSuite);
+
+        verifyTestNames(Arrays.asList("Run All", DummyTestCase.class.getSimpleName()),
+                mTestBrowserView.getTestNames());
+    }
+
+    private static void verifyTestNames(List<String> expectedTestNames,
+            List<String> actualTestNames) {
+        assertEquals(expectedTestNames.size(), actualTestNames.size());
+
+        // We use endsWith instead of equals because the return value of
+        // class.getSimpleName(), when called on an inner class, varies
+        // from one vm to another.
+        // This allows the test to pass in multiple environments.
+        for (int i = 0; i < expectedTestNames.size(); i++) {
+            assertTrue(actualTestNames.get(i).endsWith(expectedTestNames.get(i)));
+        }
+    }
+
+    public void testGetIntentForTestSuite() throws Exception {
+        TestSuite testSuite = new TestSuite();
+        testSuite.addTestSuite(DummyTestCase.class);
+
+        String targetBrowserActvityClassName = "com.android.bogus.DummyActivity";
+        String expectedTargetPackageName = "com.android.bogus";
+        mTestBrowserController.setTargetBrowserActivityClassName(targetBrowserActvityClassName);
+        mTestBrowserController.setTestSuite(testSuite);
+        mTestBrowserController.setTargetPackageName(expectedTargetPackageName);
+        Intent intent = mTestBrowserController.getIntentForTestAt(1);
+        verifyIntent(intent, DummyTestCase.class, expectedTargetPackageName);
+        assertEquals(targetBrowserActvityClassName, intent.getComponent().getClassName());
+    }
+
+    public void testGetIntentForTestCase() throws Exception {
+        TestSuite testSuite = new TestSuite();
+        testSuite.addTest(new DummyTestCase());
+
+        mTestBrowserController.setTestSuite(testSuite);
+        Intent intent = mTestBrowserController.getIntentForTestAt(1);
+        verifyIntent(intent, DummyTestCase.class, "com.android.testharness");
+        assertEquals(TestBrowserControllerImpl.TEST_RUNNER_ACTIVITY_CLASS_NAME,
+                intent.getComponent().getClassName());
+        assertEquals("testDummyTest",
+                intent.getStringExtra(TestBrowserController.BUNDLE_EXTRA_TEST_METHOD_NAME));
+    }
+
+    public void testGetIntentForRunAll() throws Exception {
+        TestSuite testSuite = new DummyTestSuite();
+        testSuite.addTestSuite(DummyTestCase.class);
+
+        mTestBrowserController.setTestSuite(testSuite);
+        Intent intent = mTestBrowserController.getIntentForTestAt(0);
+        verifyIntent(intent, DummyTestSuite.class, "com.android.testharness");
+    }
+
+    private static void verifyIntent(Intent intent, Class testClass, String expectedPackageName) {
+        assertEquals(Intent.ACTION_RUN, intent.getAction());
+        assertEquals(Intent.FLAG_ACTIVITY_NEW_TASK,
+                intent.getFlags() & Intent.FLAG_ACTIVITY_NEW_TASK);
+        assertEquals(Intent.FLAG_ACTIVITY_MULTIPLE_TASK,
+                intent.getFlags() & Intent.FLAG_ACTIVITY_MULTIPLE_TASK);
+        assertEquals(testClass.getName(), intent.getData().toString());
+        assertEquals(expectedPackageName, intent.getComponent().getPackageName());
+    }
+
+    private static class DummyTestSuite extends TestSuite {
+        private DummyTestSuite() {
+            super(DummyTestSuite.class.getName());
+        }
+    }
+
+    private static class DummyTestCase extends TestCase {
+        private DummyTestCase() {
+            super("testDummyTest");
+        }
+
+        public void testDummyTest() throws Exception {
+        }
+    }
+
+    private class TestBrowserViewStub implements TestBrowserView {
+        private List<String> mTestNames;
+
+        public void setTestNames(List<String> testNames) {
+            mTestNames = testNames;
+        }
+
+        public List<String> getTestNames() {
+            return mTestNames;
+        }
+    }
+}

base/test-runner/tests/src/android/test/TestBrowserTests.java

@@ -0,0 +1,22 @@
+// Copyright 2007 The Android Open Source Project
+
+
+package android.test;
+
+import junit.framework.TestSuite;
+
+public class TestBrowserTests extends TestBrowserActivity {
+
+    @Override
+    public TestSuite getTopTestSuite() {
+        return suite();
+    }
+
+    public static TestSuite suite() {
+        TestSuite testSuite = new TestSuite(TestBrowserTests.class.getName());
+        testSuite.addTestSuite(TestBrowserControllerImplTest.class);
+        testSuite.addTestSuite(TestCaseUtilTest.class);
+
+        return testSuite;
+    }
+}

base/test-runner/tests/src/android/test/TestCaseUtilTest.java

@@ -0,0 +1,100 @@
+/*
+ * Copyright (C) 2007 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.test;
+
+import junit.framework.Test;
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
+
+import java.util.List;
+
+public class TestCaseUtilTest extends TestCase {
+
+    public void testGetTestCaseNamesForTestSuiteWithSuiteMethod() throws Exception {
+        TestSuite testSuite = new TwoTestsInTestSuite();
+
+        List<String> testCaseNames = TestCaseUtil.getTestCaseNames(testSuite, false);
+
+        assertEquals(2, testCaseNames.size());
+        assertTrue(testCaseNames.get(0).endsWith("OneTestTestCase"));
+        assertTrue(testCaseNames.get(1).endsWith("OneTestTestSuite"));
+    }
+    
+    public void testGetTestCaseNamesForTestCaseWithSuiteMethod() throws Exception {
+        TestCase testCase = new OneTestTestCaseWithSuite();
+
+        List<String> testCaseNames = TestCaseUtil.getTestCaseNames(testCase, false);
+
+        assertEquals(1, testCaseNames.size());
+        assertTrue(testCaseNames.get(0).endsWith("testOne"));
+    }
+
+    public void testCreateTestForTestCase() throws Exception {
+        Test test = TestCaseUtil.createTestSuite(OneTestTestCase.class);
+        assertEquals(1, test.countTestCases());
+    }
+    
+    public void testCreateTestForTestSuiteWithSuiteMethod() throws Exception {
+        Test test = TestCaseUtil.createTestSuite(TwoTestsInTestSuite.class);
+        assertEquals(2, test.countTestCases());
+    }
+
+    public void testCreateTestForTestCaseWithSuiteMethod() throws Exception {
+        Test test = TestCaseUtil.createTestSuite(OneTestTestCaseWithSuite.class);
+        assertEquals(1, test.countTestCases());
+    }
+    
+    public void testReturnEmptyStringForTestSuiteWithNoName() throws Exception {
+        assertEquals("", TestCaseUtil.getTestName(new TestSuite()));
+    }
+
+    public static class OneTestTestCase extends TestCase {
+        public void testOne() throws Exception {
+        }
+    }
+
+    public static class OneTestTestCaseWithSuite extends TestCase {
+        public static Test suite()  {
+            TestCase testCase = new OneTestTestCase();
+            testCase.setName("testOne");
+            return testCase;
+        }
+
+        public void testOne() throws Exception {
+        }
+
+        public void testTwo() throws Exception {
+        }
+    }
+
+    public static class OneTestTestSuite {
+        public static Test suite() {
+            TestSuite suite = new TestSuite(OneTestTestSuite.class.getName());
+            suite.addTestSuite(OneTestTestCase.class);
+            return suite;
+        }
+    }
+
+    public static class TwoTestsInTestSuite extends TestSuite {
+        public static Test suite() {
+            TestSuite suite = new TestSuite(TwoTestsInTestSuite.class.getName());
+            suite.addTestSuite(OneTestTestCase.class);
+            suite.addTest(OneTestTestSuite.suite());
+            return suite;
+        }
+    }
+}

base/test-runner/tests/src/android/test/suitebuilder/AssignableFromTest.java

@@ -0,0 +1,85 @@
+/*
+ * Copyright (C) 2008 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.test.suitebuilder;
+
+import junit.framework.TestCase;
+
+import java.lang.reflect.Method;
+
+public class AssignableFromTest extends TestCase {
+    private AssignableFrom assignableFrom;
+
+
+    protected void setUp() throws Exception {
+        super.setUp();
+        assignableFrom = new AssignableFrom(Animal.class);
+    }
+
+    public void testSelfIsAssignable() throws Exception {
+        assertTrue(assignableFrom.apply(testMethodFor(Animal.class)));
+    }
+
+    public void testSubclassesAreAssignable() throws Exception {
+        assertTrue(assignableFrom.apply(testMethodFor(Mammal.class)));
+        assertTrue(assignableFrom.apply(testMethodFor(Human.class)));
+    }
+
+    public void testNotAssignable() throws Exception {
+        assertFalse(assignableFrom.apply(testMethodFor(Pencil.class)));
+    }
+
+    public void testImplementorsAreAssignable() throws Exception {
+        assignableFrom = new AssignableFrom(WritingInstrument.class);
+
+        assertTrue(assignableFrom.apply(testMethodFor(Pencil.class)));
+        assertTrue(assignableFrom.apply(testMethodFor(Pen.class)));
+    }
+
+    private TestMethod testMethodFor(Class<? extends TestCase> aClass)
+            throws NoSuchMethodException {
+        Method method = aClass.getMethod("testX");
+        return new TestMethod(method, aClass);
+    }
+
+    private class Animal extends TestCase {
+        public void testX() {
+        }
+    }
+
+    private class Mammal extends Animal {
+        public void testX() {
+        }
+    }
+
+    private class Human extends Mammal {
+        public void testX() {
+        }
+    }
+
+    private interface WritingInstrument {
+    }
+
+    private class Pencil extends TestCase implements WritingInstrument {
+        public void testX() {
+        }
+    }
+
+    private class Pen extends TestCase implements WritingInstrument {
+        public void testX() {
+        }
+    }
+}

base/test-runner/tests/src/android/test/suitebuilder/InstrumentationTestSuiteBuilderTest.java

@@ -0,0 +1,116 @@
+/*
+ * Copyright (C) 2008 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.test.suitebuilder;
+
+import static android.test.suitebuilder.ListTestCaseNames.getTestCaseNames;
+import android.test.suitebuilder.examples.OuterTest;
+import android.test.suitebuilder.examples.instrumentation.InstrumentationTest;
+
+import junit.framework.AssertionFailedError;
+import junit.framework.Test;
+import junit.framework.TestCase;
+import junit.framework.TestListener;
+import junit.framework.TestResult;
+import junit.framework.TestSuite;
+
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+public class InstrumentationTestSuiteBuilderTest extends TestCase {
+
+    private InstrumentationTestSuiteBuilder instrumentationTestSuiteBuilder;
+
+    protected void setUp() throws Exception {
+        super.setUp();
+        instrumentationTestSuiteBuilder = new InstrumentationTestSuiteBuilder(getClass());
+    }
+
+    public void testShouldIncludeIntrumentationTests() throws Exception {
+        instrumentationTestSuiteBuilder.includePackages(packageFor(InstrumentationTest.class));
+
+        SuiteExecutionRecorder recorder = runSuite(instrumentationTestSuiteBuilder);
+
+        assertEquals(1, recorder.testsSeen.size());
+        assertTrue(recorder.saw("InstrumentationTest.testInstrumentation"));
+    }
+
+    public void testShouldOnlyIncludeIntrumentationTests() throws Exception {
+        TestSuite testSuite = new OuterTest()
+                .buildTestsUnderHereWith(instrumentationTestSuiteBuilder);
+        List<String> testCaseNames = getTestCaseNames(testSuite);
+        assertEquals(1, testCaseNames.size());
+        assertEquals("testInstrumentation", testCaseNames.get(0));
+    }
+
+    private static String packageFor(Class clazz) {
+        String className = clazz.getName();
+        return className.substring(0, className.lastIndexOf('.'));
+    }
+
+    private SuiteExecutionRecorder runSuite(TestSuiteBuilder builder) {
+        TestSuite suite = builder.build();
+        SuiteExecutionRecorder recorder = new SuiteExecutionRecorder();
+        TestResult result = new TestResult();
+        result.addListener(recorder);
+        suite.run(result);
+        return recorder;
+    }
+
+    private class SuiteExecutionRecorder implements TestListener {
+
+        private Set<String> failures = new HashSet<String>();
+        private Set<String> errors = new HashSet<String>();
+        private Set<String> testsSeen = new HashSet<String>();
+
+        public void addError(Test test, Throwable t) {
+            errors.add(testName(test));
+        }
+
+        public void addFailure(Test test, AssertionFailedError t) {
+            failures.add(testName(test));
+        }
+
+        public void endTest(Test test) {
+        }
+
+        public void startTest(Test test) {
+            testsSeen.add(testName(test));
+        }
+
+        public boolean saw(String testName) {
+            return testsSeen.contains(testName);
+        }
+
+        public boolean failed(String testName) {
+            return failures.contains(testName);
+        }
+
+        public boolean errored(String testName) {
+            return errors.contains(testName);
+        }
+
+        public boolean passed(String testName) {
+            return saw(testName) && !failed(testName) && !errored(testName);
+        }
+
+        private String testName(Test test) {
+            TestCase testCase = (TestCase) test;
+            return testCase.getClass().getSimpleName() + "." + testCase.getName();
+        }
+    }
+}

base/test-runner/tests/src/android/test/suitebuilder/ListTestCaseNames.java

@@ -0,0 +1,102 @@
+/*
+ * Copyright (C) 2008 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.test.suitebuilder;
+
+import junit.framework.Test;
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class ListTestCaseNames {
+    public static List<String> getTestCaseNames(TestSuite suite) {
+        // TODO: deprecate this method and move all callers to use getTestNames
+        List<Test> tests = Collections.<Test>list(suite.tests());
+        ArrayList<String> testCaseNames = new ArrayList<String>();
+        for (Test test : tests) {
+            if (test instanceof TestCase) {
+                testCaseNames.add(((TestCase) test).getName());
+            } else if (test instanceof TestSuite) {
+                testCaseNames.addAll(getTestCaseNames((TestSuite) test));
+            }
+        }
+        return testCaseNames;
+    }
+    
+    /** 
+     * Returns a list of test class and method names for each TestCase in suite.  
+     */
+    public static List<TestDescriptor> getTestNames(TestSuite suite) {
+        List<Test> tests = Collections.<Test>list(suite.tests());
+        ArrayList<TestDescriptor> testNames = new ArrayList<TestDescriptor>();
+        for (Test test : tests) {
+            if (test instanceof TestCase) {
+                String className = test.getClass().getName();
+                String testName = ((TestCase) test).getName();
+                testNames.add(new TestDescriptor(className, testName));
+            } else if (test instanceof TestSuite) {
+                testNames.addAll(getTestNames((TestSuite) test));
+            }
+        }
+        return testNames;
+    }
+    
+    /**
+     * Data holder for test case info
+     */
+    public static class TestDescriptor {
+       private String mClassName;
+       private String mTestName;
+      
+       public TestDescriptor(String className, String testName) {
+           mClassName = className;
+           mTestName = testName;
+       }
+       
+       public String getClassName() {
+           return mClassName;
+       }
+       
+       public String getTestName() {
+           return mTestName;
+       }
+       
+       /**
+        * Override parent to do string-based class and test name comparison
+        */
+       @Override
+       public boolean equals(Object otherObj) {
+           if (otherObj instanceof TestDescriptor) {
+               TestDescriptor otherDesc = (TestDescriptor)otherObj;
+               return otherDesc.getClassName().equals(this.getClassName()) && 
+                      otherDesc.getTestName().equals(this.getTestName());
+               
+           }
+           return false;
+       }
+       
+       /**
+        * Override parent to return a more user-friendly display string
+        */
+       @Override
+       public String toString() {
+           return getClassName() + "#" + getTestName();
+       }
+    }
+}

base/test-runner/tests/src/android/test/suitebuilder/SmokeTestSuiteBuilderTest.java

@@ -0,0 +1,34 @@
+/*
+ * Copyright (C) 2008 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.test.suitebuilder;
+
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
+
+import java.util.List;
+
+public class SmokeTestSuiteBuilderTest extends TestCase {
+
+    public void testShouldOnlyIncludeSmokeTests() throws Exception {
+        TestSuite testSuite = new SmokeTestSuiteBuilder(getClass())
+                .includeAllPackagesUnderHere().build();
+
+        List<String> testCaseNames = ListTestCaseNames.getTestCaseNames(testSuite);
+        assertEquals("Unexpected number of smoke tests.", 1, testCaseNames.size());
+        assertEquals("Unexpected test name", "testSmoke", testCaseNames.get(0));
+    }
+}

base/test-runner/tests/src/android/test/suitebuilder/TestSuiteBuilderTest.java

@@ -0,0 +1,218 @@
+/*
+ * Copyright (C) 2008 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.test.suitebuilder;
+
+import com.android.internal.util.Predicate;
+import static android.test.suitebuilder.ListTestCaseNames.getTestCaseNames;
+import android.test.suitebuilder.examples.OuterTest;
+import android.test.suitebuilder.examples.suppress.SuppressedTest;
+import android.test.suitebuilder.examples.error.ErrorTest;
+import android.test.suitebuilder.examples.error.FailingTest;
+import android.test.suitebuilder.examples.nested.Level1Test;
+import android.test.suitebuilder.examples.nested.nested.Level2Test;
+import android.test.suitebuilder.examples.simple.SimpleTest;
+import android.test.suitebuilder.examples.subclass.SubclassTest;
+import junit.framework.AssertionFailedError;
+import junit.framework.Test;
+import junit.framework.TestCase;
+import junit.framework.TestListener;
+import junit.framework.TestResult;
+import junit.framework.TestSuite;
+
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+
+public class TestSuiteBuilderTest extends TestCase {
+
+    private TestSuiteBuilder testSuiteBuilder;
+
+    protected void setUp() throws Exception {
+        super.setUp();
+        testSuiteBuilder = new TestSuiteBuilder(getClass());
+    }
+
+    public void testShouldRunSimpleTests() throws Exception {
+        testSuiteBuilder.includePackages(packageFor(SimpleTest.class));
+
+        SuiteExecutionRecorder recorder = runSuite(testSuiteBuilder);
+
+        assertTrue(recorder.passed("SimpleTest.testSimpleOne"));
+        assertTrue(recorder.passed("SimpleTest.testSimpleTwo"));
+        assertTrue(recorder.passed("AnotherSimpleTest.testAnotherOne"));
+    }
+
+    public void testShouldOnlyIncludeTestsThatSatisfyAllPredicates() throws Exception {
+        testSuiteBuilder.includePackages(packageFor(SimpleTest.class))
+                .addRequirements(testsWhoseNameContains("test"))
+                .addRequirements(testsWhoseNameContains("Simple"))
+                .addRequirements(testsWhoseNameContains("Two"));
+
+        SuiteExecutionRecorder recorder = runSuite(testSuiteBuilder);
+
+        assertTrue(recorder.passed("SimpleTest.testSimpleTwo"));
+    }
+
+    public void testShouldAddFailingTestsToSuite() throws Exception {
+        testSuiteBuilder.includePackages(packageFor(FailingTest.class));
+
+        SuiteExecutionRecorder recorder = runSuite(testSuiteBuilder);
+
+        assertTrue(recorder.failed("FailingTest.testFailOne"));
+        assertTrue(recorder.failed("FailingTest.testFailTwo"));
+    }
+
+    public void testShouldAddTestsWithErrorsToSuite() throws Exception {
+        testSuiteBuilder.includePackages(packageFor(ErrorTest.class));
+
+        SuiteExecutionRecorder recorder = runSuite(testSuiteBuilder);
+
+        assertTrue(recorder.errored("ErrorTest.testErrorOne"));
+        assertTrue(recorder.errored("ErrorTest.testErrorTwo"));
+    }
+
+    public void testShouldRunTestsInheritedFromSuperclass() throws Exception {
+        testSuiteBuilder.includePackages(packageFor(SubclassTest.class));
+
+        SuiteExecutionRecorder recorder = runSuite(testSuiteBuilder);
+
+        assertEquals(2, getTestCaseNames(testSuiteBuilder.build()).size());
+
+        assertTrue(recorder.passed("SubclassTest.testSubclass"));
+        assertTrue(recorder.passed("SubclassTest.testSuperclass"));
+        assertFalse(recorder.saw("SuperclassTest.testSuperclass"));
+    }
+
+    public void testShouldIncludeTestsInSubPackagesRecursively() throws Exception {
+        testSuiteBuilder.includePackages(packageFor(Level1Test.class));
+
+        SuiteExecutionRecorder recorder = runSuite(testSuiteBuilder);
+
+        assertTrue(recorder.passed("Level1Test.testLevel1"));
+        assertTrue(recorder.passed("Level2Test.testLevel2"));
+    }
+
+    public void testExcludePackage() throws Exception {
+        testSuiteBuilder.includePackages(packageFor(SimpleTest.class),
+                packageFor(Level1Test.class)).excludePackages(packageFor(Level2Test.class));
+
+        TestSuite testSuite = testSuiteBuilder.build();
+        assertContentsInOrder(getTestCaseNames(testSuite),
+                "testLevel1", "testAnotherOne", "testSimpleOne", "testSimpleTwo");
+    }
+
+    public void testShouldExcludeSuppressedTests() throws Exception {
+        testSuiteBuilder.includePackages(packageFor(SuppressedTest.class));
+        testSuiteBuilder.build();
+
+        SuiteExecutionRecorder recorder = runSuite(testSuiteBuilder);
+
+        assertEquals(1, recorder.testsSeen.size());
+        assertTrue(recorder.passed("PartiallySuppressedTest.testUnSuppressedMethod"));
+    }
+
+    /**
+     * This test calls {@link OuterTest#buildTestsUnderHereRecursively()} to control
+     * the packages under test. The call to {@link TestSuiteBuilder#includeAllPackagesUnderHere()}
+     * is made from there so that only return the example tests.
+     */
+    public void testIncludeAllPackagesUnderHere() throws Exception {
+
+        TestSuite testSuite = new OuterTest().buildTestsUnderHereRecursively();
+        assertContentsInOrder(getTestCaseNames(testSuite),
+                "testOuter", "testErrorOne", "testErrorTwo", "testFailOne", "testFailTwo",
+                "testInstrumentation", "testLevel1", "testLevel2", "testAnotherOne",
+                "testSimpleOne", "testSimpleTwo", "testNonSmoke", "testSmoke", "testSubclass",
+                "testSuperclass", "testUnSuppressedMethod");
+    }
+
+    private void assertContentsInOrder(List<String> actual, String... source) {
+        String[] clonedSource = source.clone();
+        assertEquals("Unexpected number of items.", clonedSource.length, actual.size());
+        for (int i = 0; i < actual.size(); i++) {
+            String actualItem = actual.get(i);
+            String sourceItem = clonedSource[i];
+            assertEquals("Unexpected item. Index: " + i, sourceItem, actualItem);
+        }
+    }
+
+    private static String packageFor(Class clazz) {
+        String className = clazz.getName();
+        return className.substring(0, className.lastIndexOf('.'));
+    }
+
+    private Predicate<TestMethod> testsWhoseNameContains(final String string) {
+        return new Predicate<TestMethod>() {
+            public boolean apply(TestMethod testMethod) {
+                return testMethod.getName().contains(string);
+            }
+        };
+    }
+
+    private SuiteExecutionRecorder runSuite(TestSuiteBuilder builder) {
+        TestSuite suite = builder.build();
+        SuiteExecutionRecorder recorder = new SuiteExecutionRecorder();
+        TestResult result = new TestResult();
+        result.addListener(recorder);
+        suite.run(result);
+        return recorder;
+    }
+
+    private class SuiteExecutionRecorder implements TestListener {
+
+        private Set<String> failures = new HashSet<String>();
+        private Set<String> errors = new HashSet<String>();
+        private Set<String> testsSeen = new HashSet<String>();
+
+        public void addError(Test test, Throwable t) {
+            errors.add(testName(test));
+        }
+
+        public void addFailure(Test test, AssertionFailedError t) {
+            failures.add(testName(test));
+        }
+
+        public void endTest(Test test) {
+        }
+
+        public void startTest(Test test) {
+            testsSeen.add(testName(test));
+        }
+
+        public boolean saw(String testName) {
+            return testsSeen.contains(testName);
+        }
+
+        public boolean failed(String testName) {
+            return failures.contains(testName);
+        }
+
+        public boolean errored(String testName) {
+            return errors.contains(testName);
+        }
+
+        public boolean passed(String testName) {
+            return saw(testName) && !failed(testName) && !errored(testName);
+        }
+
+        private String testName(Test test) {
+            TestCase testCase = (TestCase) test;
+            return testCase.getClass().getSimpleName() + "." + testCase.getName();
+        }
+    }
+}

base/test-runner/tests/src/android/test/suitebuilder/UnitTestSuiteBuilderTest.java

@@ -0,0 +1,109 @@
+/*
+ * Copyright (C) 2008 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.test.suitebuilder;
+
+import android.test.suitebuilder.examples.instrumentation.InstrumentationTest;
+
+import junit.framework.Assert;
+import junit.framework.AssertionFailedError;
+import junit.framework.Test;
+import junit.framework.TestCase;
+import junit.framework.TestListener;
+import junit.framework.TestResult;
+import junit.framework.TestSuite;
+
+import java.util.HashSet;
+import java.util.Set;
+
+public class UnitTestSuiteBuilderTest extends TestCase {
+
+    private UnitTestSuiteBuilder unitTestSuiteBuilder;
+
+    protected void setUp() throws Exception {
+        super.setUp();
+        unitTestSuiteBuilder = new UnitTestSuiteBuilder(getClass());
+    }
+
+    public void testShouldExcludeIntrumentationTests() throws Exception {
+        unitTestSuiteBuilder.includePackages(packageFor(InstrumentationTest.class));
+
+        TestSuite testSuite = unitTestSuiteBuilder.build();
+        Assert.assertEquals(0, ListTestCaseNames.getTestCaseNames(testSuite).size());
+
+        SuiteExecutionRecorder recorder = runSuite(unitTestSuiteBuilder);
+
+        assertFalse(recorder.saw("InstrumentationTest.testInstrumentation"));
+        assertTrue(recorder.testsSeen.isEmpty());
+    }
+
+    private static String packageFor(Class clazz) {
+        String className = clazz.getName();
+        return className.substring(0, className.lastIndexOf('.'));
+    }
+
+    private SuiteExecutionRecorder runSuite(TestSuiteBuilder builder) {
+        TestSuite suite = builder.build();
+        SuiteExecutionRecorder recorder = new SuiteExecutionRecorder();
+        TestResult result = new TestResult();
+        result.addListener(recorder);
+        suite.run(result);
+        return recorder;
+    }
+
+    private class SuiteExecutionRecorder implements TestListener {
+
+        private Set<String> failures = new HashSet<String>();
+        private Set<String> errors = new HashSet<String>();
+        private Set<String> testsSeen = new HashSet<String>();
+
+        public void addError(Test test, Throwable t) {
+            errors.add(testName(test));
+        }
+
+        public void addFailure(Test test, AssertionFailedError t) {
+            failures.add(testName(test));
+        }
+
+        public void endTest(Test test) {
+        }
+
+        public void startTest(Test test) {
+            testsSeen.add(testName(test));
+        }
+
+        public boolean saw(String testName) {
+            return testsSeen.contains(testName);
+        }
+
+        public boolean failed(String testName) {
+            return failures.contains(testName);
+        }
+
+        public boolean errored(String testName) {
+            return errors.contains(testName);
+        }
+
+        public boolean passed(String testName) {
+            return saw(testName) && !failed(testName) && !errored(testName);
+        }
+
+        private String testName(Test test) {
+            TestCase testCase = (TestCase) test;
+            return testCase.getClass().getSimpleName() + "." + testCase.getName();
+        }
+    }
+}

base/test-runner/tests/src/android/test/suitebuilder/annotation/HasAnnotationTest.java

@@ -0,0 +1,76 @@
+/*
+ * Copyright (C) 2008 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.test.suitebuilder.annotation;
+
+import android.test.suitebuilder.TestMethod;
+import junit.framework.TestCase;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.lang.reflect.Method;
+
+public class HasAnnotationTest extends TestCase {
+
+    public void testThatMethodWithAnnotationIsReportedAsBeingAnnotated() throws Exception {
+        assertTrue(hasExampleAnnotation(ClassWithAnnotation.class, "testWithAnnotation"));
+        assertTrue(hasExampleAnnotation(ClassWithoutAnnotation.class, "testWithAnnotation"));
+    }
+
+    public void testThatMethodWithOutAnnotationIsNotReportedAsBeingAnnotated() throws Exception {
+        assertFalse(hasExampleAnnotation(ClassWithoutAnnotation.class, "testWithoutAnnotation"));
+    }
+
+    public void testThatClassAnnotatioCausesAllMethodsToBeReportedAsBeingAnnotated()
+            throws Exception {
+        assertTrue(hasExampleAnnotation(ClassWithAnnotation.class, "testWithoutAnnotation"));
+    }
+
+    private boolean hasExampleAnnotation(Class<? extends TestCase> aClass, String methodName)
+            throws NoSuchMethodException {
+        Method method = aClass.getMethod(methodName);
+        TestMethod testMethod = new TestMethod(method, aClass);
+        return new HasAnnotation(Example.class).apply(testMethod);
+    }
+
+    @Retention(RetentionPolicy.RUNTIME)
+    @Target({ElementType.TYPE, ElementType.METHOD})
+    public @interface Example {
+    }
+
+    @Example
+    static class ClassWithAnnotation extends TestCase {
+
+        @Example
+        public void testWithAnnotation() {
+        }
+
+        public void testWithoutAnnotation() {
+        }
+    }
+
+    static class ClassWithoutAnnotation extends TestCase {
+
+        @Example
+        public void testWithAnnotation() {
+        }
+
+        public void testWithoutAnnotation() {
+        }
+    }
+}

base/test-runner/tests/src/android/test/suitebuilder/annotation/HasClassAnnotationTest.java

@@ -0,0 +1,57 @@
+/*
+ * Copyright (C) 2008 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.test.suitebuilder.annotation;
+
+import android.test.suitebuilder.TestMethod;
+import junit.framework.TestCase;
+
+import java.lang.reflect.Method;
+
+public class HasClassAnnotationTest extends TestCase {
+
+    public void testShouldTellIfParentClassHasSpecifiedClassification()
+            throws NoSuchMethodException {
+        assertTrue(classHasAnnotation(SmokeTestExample.class, Smoke.class));
+    }
+
+    public void testShouldTellIfParentClassDoesNotHaveSpecifiedClassification()
+            throws NoSuchMethodException {
+        assertFalse(classHasAnnotation(NonSmokeTestExample.class, Smoke.class));
+    }
+
+    private boolean classHasAnnotation(
+            Class<? extends TestCase> aClass,
+            Class<Smoke> expectedClassification) throws NoSuchMethodException {
+        Method method = aClass.getMethod("testSomeTest");
+
+        TestMethod testMethod = new TestMethod(method, aClass);
+        return new HasClassAnnotation(expectedClassification).apply(testMethod);
+    }
+
+    @Smoke
+    static class SmokeTestExample extends TestCase {
+
+        public void testSomeTest() {
+        }
+    }
+
+    static class NonSmokeTestExample extends TestCase {
+
+        public void testSomeTest() {
+        }
+    }
+}

base/test-runner/tests/src/android/test/suitebuilder/annotation/HasMethodAnnotationTest.java

@@ -0,0 +1,56 @@
+/*
+ * Copyright (C) 2008 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.test.suitebuilder.annotation;
+
+import android.test.suitebuilder.TestMethod;
+import junit.framework.TestCase;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Method;
+
+
+public class HasMethodAnnotationTest extends TestCase {
+
+    public void testMethodWithSpecifiedAttribute() throws Exception {
+        assertTrue(methodHasAnnotation(AnnotatedMethodExample.class,
+                "testThatIsAnnotated", Smoke.class));
+    }
+
+    public void testMethodWithoutSpecifiedAttribute() throws Exception {
+        assertFalse(methodHasAnnotation(AnnotatedMethodExample.class,
+                "testThatIsNotAnnotated", Smoke.class));
+    }
+
+    private boolean methodHasAnnotation(Class<? extends TestCase> aClass,
+            String methodName,
+            Class<? extends Annotation> expectedClassification
+    ) throws NoSuchMethodException {
+        Method method = aClass.getMethod(methodName);
+        TestMethod testMethod = new TestMethod(method, aClass);
+        return new HasMethodAnnotation(expectedClassification).apply(testMethod);
+    }
+
+    static class AnnotatedMethodExample extends TestCase {
+
+        @Smoke
+        public void testThatIsAnnotated() {
+        }
+
+        public void testThatIsNotAnnotated() {
+        }
+    }
+}

base/test-runner/tests/src/android/test/suitebuilder/examples/OuterTest.java

@@ -0,0 +1,37 @@
+/*
+ * Copyright (C) 2008 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.test.suitebuilder.examples;
+
+import android.test.suitebuilder.TestSuiteBuilder;
+
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
+
+public class OuterTest extends TestCase {
+
+    public void testOuter() {
+        assertTrue(true);
+    }
+
+    public TestSuite buildTestsUnderHereRecursively() {
+        return buildTestsUnderHereWith(new TestSuiteBuilder(getClass()));
+    }
+
+    public TestSuite buildTestsUnderHereWith(TestSuiteBuilder testSuiteBuilder) {
+        return testSuiteBuilder.includeAllPackagesUnderHere().build();
+    }
+}

base/test-runner/tests/src/android/test/suitebuilder/examples/error/ErrorTest.java

@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2008 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.test.suitebuilder.examples.error;
+
+import junit.framework.TestCase;
+
+public class ErrorTest extends TestCase {
+
+    public void testErrorOne() throws Exception {
+        throw new RuntimeException("Expected");
+    }
+
+    public void testErrorTwo() throws Exception {
+        throw new RuntimeException("Expected");
+    }
+}

base/test-runner/tests/src/android/test/suitebuilder/examples/error/FailingTest.java

@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2008 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.test.suitebuilder.examples.error;
+
+import junit.framework.TestCase;
+
+public class FailingTest extends TestCase {
+
+    public void testFailOne() throws Exception {
+        fail("Expected");
+    }
+
+    public void testFailTwo() throws Exception {
+        fail("Expected");
+    }
+}

base/test-runner/tests/src/android/test/suitebuilder/examples/instrumentation/InstrumentationTest.java

@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 2008 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.test.suitebuilder.examples.instrumentation;
+
+import android.test.InstrumentationTestCase;
+
+public class InstrumentationTest extends InstrumentationTestCase {
+
+    public void testInstrumentation() throws Exception {
+        assertTrue(true);
+    }
+}

base/test-runner/tests/src/android/test/suitebuilder/examples/nested/Level1Test.java

@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 2008 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.test.suitebuilder.examples.nested;
+
+import junit.framework.TestCase;
+
+public class Level1Test extends TestCase {
+
+    public void testLevel1() throws Exception {
+        assertTrue(true);
+    }
+}

base/test-runner/tests/src/android/test/suitebuilder/examples/nested/nested/Level2Test.java

@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 2008 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.test.suitebuilder.examples.nested.nested;
+
+import junit.framework.TestCase;
+
+public class Level2Test extends TestCase {
+
+    public void testLevel2() throws Exception {
+        assertTrue(true);
+    }
+}

base/test-runner/tests/src/android/test/suitebuilder/examples/simple/AnotherSimpleTest.java

@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 2008 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.test.suitebuilder.examples.simple;
+
+import junit.framework.TestCase;
+
+public class AnotherSimpleTest extends TestCase {
+
+    public void testAnotherOne() throws Exception {
+        assertTrue(true);
+    }
+}

base/test-runner/tests/src/android/test/suitebuilder/examples/simple/SimpleTest.java

@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2008 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.test.suitebuilder.examples.simple;
+
+import junit.framework.TestCase;
+
+public class SimpleTest extends TestCase {
+
+    public void testSimpleOne() throws Exception {
+        assertTrue(true);
+    }
+
+    public void testSimpleTwo() throws Exception {
+        assertTrue(true);
+    }
+}

base/test-runner/tests/src/android/test/suitebuilder/examples/smoke/NonSmokeTest.java

@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 2008 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.test.suitebuilder.examples.smoke;
+
+import junit.framework.TestCase;
+
+public class NonSmokeTest extends TestCase {
+
+    public void testNonSmoke() throws Exception {
+        assertTrue(true);
+    }
+}

base/test-runner/tests/src/android/test/suitebuilder/examples/smoke/SmokeTest.java

@@ -0,0 +1,28 @@
+/*
+ * Copyright (C) 2008 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.test.suitebuilder.examples.smoke;
+
+import android.test.suitebuilder.annotation.Smoke;
+import junit.framework.TestCase;
+
+@Smoke
+public class SmokeTest extends TestCase {
+
+    public void testSmoke() throws Exception {
+        assertTrue(true);
+    }
+}

base/test-runner/tests/src/android/test/suitebuilder/examples/subclass/SubclassTest.java

@@ -0,0 +1,24 @@
+/*
+ * Copyright (C) 2008 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.test.suitebuilder.examples.subclass;
+
+public class SubclassTest extends SuperclassTest {
+
+    public void testSubclass() throws Exception {
+        assertTrue(true);
+    }
+}

base/test-runner/tests/src/android/test/suitebuilder/examples/subclass/SuperclassTest.java

@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 2008 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.test.suitebuilder.examples.subclass;
+
+import junit.framework.TestCase;
+
+public abstract class SuperclassTest extends TestCase {
+
+    public void testSuperclass() throws Exception {
+        assertTrue(true);
+    }
+}

base/test-runner/tests/src/android/test/suitebuilder/examples/suppress/PartiallySuppressedTest.java

@@ -0,0 +1,33 @@
+/*
+ * Copyright (C) 2008 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.test.suitebuilder.examples.suppress;
+
+import android.test.suitebuilder.annotation.Suppress;
+
+import junit.framework.TestCase;
+
+public class PartiallySuppressedTest extends TestCase {
+
+    @Suppress
+    public void testSuppressedMethod() throws Exception {
+        assertTrue(true);
+    }
+
+    public void testUnSuppressedMethod() throws Exception {
+        assertTrue(true);
+    }
+}

base/test-runner/tests/src/android/test/suitebuilder/examples/suppress/SuppressedTest.java

@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2008 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.test.suitebuilder.examples.suppress;
+
+import android.test.suitebuilder.annotation.Suppress;
+
+import junit.framework.TestCase;
+
+@Suppress
+public class SuppressedTest extends TestCase {
+
+    public void testSuppressedClass() throws Exception {
+        assertTrue(true);
+    }
+}