1 /* 2 * Copyright (C) 2008 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package android.test; 18 19 import android.app.Activity; 20 import android.content.Intent; 21 22 import java.lang.reflect.Method; 23 24 /** 25 * This class provides functional testing of a single activity. The activity under test will 26 * be created using the system infrastructure (by calling InstrumentationTestCase.launchActivity()) 27 * and you will then be able to manipulate your Activity directly. 28 * 29 * <p>Other options supported by this test case include: 30 * <ul> 31 * <li>You can run any test method on the UI thread (see {@link android.test.UiThreadTest}).</li> 32 * <li>You can inject custom Intents into your Activity (see 33 * {@link #setActivityIntent(Intent)}).</li> 34 * </ul> 35 * 36 * <p>This class replaces {@link android.test.ActivityInstrumentationTestCase}, which is deprecated. 37 * New tests should be written using this base class. 38 * 39 * <p>If you prefer an isolated unit test, see {@link android.test.ActivityUnitTestCase}. 40 * 41 * @deprecated Use 42 * <a href="{@docRoot}reference/android/support/test/rule/ActivityTestRule.html"> 43 * ActivityTestRule</a> instead. New tests should be written using the 44 * <a href="{@docRoot}tools/testing-support-library/index.html">Android Testing Support Library</a>. 45 */ 46 @Deprecated 47 public abstract class ActivityInstrumentationTestCase2<T extends Activity> 48 extends ActivityTestCase { 49 Class<T> mActivityClass; 50 boolean mInitialTouchMode = false; 51 Intent mActivityIntent = null; 52 53 /** 54 * Creates an {@link ActivityInstrumentationTestCase2}. 55 * 56 * @param pkg ignored - no longer in use. 57 * @param activityClass The activity to test. This must be a class in the instrumentation 58 * targetPackage specified in the AndroidManifest.xml 59 * 60 * @deprecated use {@link #ActivityInstrumentationTestCase2(Class)} instead 61 */ 62 @Deprecated ActivityInstrumentationTestCase2(String pkg, Class<T> activityClass)63 public ActivityInstrumentationTestCase2(String pkg, Class<T> activityClass) { 64 this(activityClass); 65 } 66 67 /** 68 * Creates an {@link ActivityInstrumentationTestCase2}. 69 * 70 * @param activityClass The activity to test. This must be a class in the instrumentation 71 * targetPackage specified in the AndroidManifest.xml 72 */ ActivityInstrumentationTestCase2(Class<T> activityClass)73 public ActivityInstrumentationTestCase2(Class<T> activityClass) { 74 mActivityClass = activityClass; 75 } 76 77 /** 78 * Get the Activity under test, starting it if necessary. 79 * 80 * For each test method invocation, the Activity will not actually be created until the first 81 * time this method is called. 82 * 83 * <p>If you wish to provide custom setup values to your Activity, you may call 84 * {@link #setActivityIntent(Intent)} and/or {@link #setActivityInitialTouchMode(boolean)} 85 * before your first call to getActivity(). Calling them after your Activity has 86 * started will have no effect. 87 * 88 * <p><b>NOTE:</b> Activities under test may not be started from within the UI thread. 89 * If your test method is annotated with {@link android.test.UiThreadTest}, then your Activity 90 * will be started automatically just before your test method is run. You still call this 91 * method in order to get the Activity under test. 92 * 93 * @return the Activity under test 94 */ 95 @Override getActivity()96 public T getActivity() { 97 Activity a = super.getActivity(); 98 if (a == null) { 99 // set initial touch mode 100 getInstrumentation().setInTouchMode(mInitialTouchMode); 101 final String targetPackage = getInstrumentation().getTargetContext().getPackageName(); 102 // inject custom intent, if provided 103 if (mActivityIntent == null) { 104 a = launchActivity(targetPackage, mActivityClass, null); 105 } else { 106 a = launchActivityWithIntent(targetPackage, mActivityClass, mActivityIntent); 107 } 108 setActivity(a); 109 } 110 return (T) a; 111 } 112 113 /** 114 * Call this method before the first call to {@link #getActivity} to inject a customized Intent 115 * into the Activity under test. 116 * 117 * <p>If you do not call this, the default intent will be provided. If you call this after 118 * your Activity has been started, it will have no effect. 119 * 120 * <p><b>NOTE:</b> Activities under test may not be started from within the UI thread. 121 * If your test method is annotated with {@link android.test.UiThreadTest}, then you must call 122 * {@link #setActivityIntent(Intent)} from {@link #setUp()}. 123 * 124 * <p>The default Intent (if this method is not called) is: 125 * action = {@link Intent#ACTION_MAIN} 126 * flags = {@link Intent#FLAG_ACTIVITY_NEW_TASK} 127 * All other fields are null or empty. 128 * 129 * @param i The Intent to start the Activity with, or null to reset to the default Intent. 130 */ setActivityIntent(Intent i)131 public void setActivityIntent(Intent i) { 132 mActivityIntent = i; 133 } 134 135 /** 136 * Call this method before the first call to {@link #getActivity} to set the initial touch 137 * mode for the Activity under test. 138 * 139 * <p>If you do not call this, the touch mode will be false. If you call this after 140 * your Activity has been started, it will have no effect. 141 * 142 * <p><b>NOTE:</b> Activities under test may not be started from within the UI thread. 143 * If your test method is annotated with {@link android.test.UiThreadTest}, then you must call 144 * {@link #setActivityInitialTouchMode(boolean)} from {@link #setUp()}. 145 * 146 * @param initialTouchMode true if the Activity should be placed into "touch mode" when started 147 */ setActivityInitialTouchMode(boolean initialTouchMode)148 public void setActivityInitialTouchMode(boolean initialTouchMode) { 149 mInitialTouchMode = initialTouchMode; 150 } 151 152 @Override setUp()153 protected void setUp() throws Exception { 154 super.setUp(); 155 156 mInitialTouchMode = false; 157 mActivityIntent = null; 158 } 159 160 @Override tearDown()161 protected void tearDown() throws Exception { 162 // Finish the Activity off (unless was never launched anyway) 163 Activity a = super.getActivity(); 164 if (a != null) { 165 a.finish(); 166 setActivity(null); 167 } 168 169 // Scrub out members - protects against memory leaks in the case where someone 170 // creates a non-static inner class (thus referencing the test case) and gives it to 171 // someone else to hold onto 172 scrubClass(ActivityInstrumentationTestCase2.class); 173 174 super.tearDown(); 175 } 176 177 /** 178 * Runs the current unit test. If the unit test is annotated with 179 * {@link android.test.UiThreadTest}, force the Activity to be created before switching to 180 * the UI thread. 181 */ 182 @Override runTest()183 protected void runTest() throws Throwable { 184 try { 185 Method method = getClass().getMethod(getName(), (Class[]) null); 186 if (method.isAnnotationPresent(UiThreadTest.class)) { 187 getActivity(); 188 } 189 } catch (Exception e) { 190 // eat the exception here; super.runTest() will catch it again and handle it properly 191 } 192 super.runTest(); 193 } 194 195 } 196