1 /* 2 * Copyright (C) 2006 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.content.ContentValues; 20 import android.content.Context; 21 import android.content.Intent; 22 import android.net.Uri; 23 import android.test.suitebuilder.annotation.Suppress; 24 25 import junit.framework.TestCase; 26 27 import java.lang.reflect.Field; 28 import java.lang.reflect.Modifier; 29 30 /** 31 * Extend this if you need to access Resources or other things that depend on Activity Context. 32 * 33 * @deprecated Use 34 * <a href="{@docRoot}reference/android/support/test/InstrumentationRegistry.html"> 35 * InstrumentationRegistry</a> instead. New tests should be written using the 36 * <a href="{@docRoot}tools/testing-support-library/index.html">Android Testing Support Library</a>. 37 */ 38 @Deprecated 39 public class AndroidTestCase extends TestCase { 40 41 protected Context mContext; 42 private Context mTestContext; 43 44 @Override setUp()45 protected void setUp() throws Exception { 46 super.setUp(); 47 } 48 49 @Override tearDown()50 protected void tearDown() throws Exception { 51 super.tearDown(); 52 } 53 54 @Suppress testAndroidTestCaseSetupProperly()55 public void testAndroidTestCaseSetupProperly() { 56 assertNotNull("Context is null. setContext should be called before tests are run", 57 mContext); 58 } 59 setContext(Context context)60 public void setContext(Context context) { 61 mContext = context; 62 } 63 getContext()64 public Context getContext() { 65 return mContext; 66 } 67 68 /** 69 * Test context can be used to access resources from the test's own package 70 * as opposed to the resources from the test target package. Access to the 71 * latter is provided by the context set with the {@link #setContext} 72 * method. 73 * 74 * @hide 75 */ setTestContext(Context context)76 public void setTestContext(Context context) { 77 mTestContext = context; 78 } 79 80 /** 81 * @hide 82 */ getTestContext()83 public Context getTestContext() { 84 return mTestContext; 85 } 86 87 /** 88 * Asserts that launching a given activity is protected by a particular permission by 89 * attempting to start the activity and validating that a {@link SecurityException} 90 * is thrown that mentions the permission in its error message. 91 * 92 * Note that an instrumentation isn't needed because all we are looking for is a security error 93 * and we don't need to wait for the activity to launch and get a handle to the activity. 94 * 95 * @param packageName The package name of the activity to launch. 96 * @param className The class of the activity to launch. 97 * @param permission The name of the permission. 98 */ assertActivityRequiresPermission( String packageName, String className, String permission)99 public void assertActivityRequiresPermission( 100 String packageName, String className, String permission) { 101 final Intent intent = new Intent(); 102 intent.setClassName(packageName, className); 103 intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK); 104 105 try { 106 getContext().startActivity(intent); 107 fail("expected security exception for " + permission); 108 } catch (SecurityException expected) { 109 assertNotNull("security exception's error message.", expected.getMessage()); 110 assertTrue("error message should contain " + permission + ".", 111 expected.getMessage().contains(permission)); 112 } 113 } 114 115 116 /** 117 * Asserts that reading from the content uri requires a particular permission by querying the 118 * uri and ensuring a {@link SecurityException} is thrown mentioning the particular permission. 119 * 120 * @param uri The uri that requires a permission to query. 121 * @param permission The permission that should be required. 122 */ assertReadingContentUriRequiresPermission(Uri uri, String permission)123 public void assertReadingContentUriRequiresPermission(Uri uri, String permission) { 124 try { 125 getContext().getContentResolver().query(uri, null, null, null, null); 126 fail("expected SecurityException requiring " + permission); 127 } catch (SecurityException expected) { 128 assertNotNull("security exception's error message.", expected.getMessage()); 129 assertTrue("error message should contain " + permission + ".", 130 expected.getMessage().contains(permission)); 131 } 132 } 133 134 /** 135 * Asserts that writing to the content uri requires a particular permission by inserting into 136 * the uri and ensuring a {@link SecurityException} is thrown mentioning the particular 137 * permission. 138 * 139 * @param uri The uri that requires a permission to query. 140 * @param permission The permission that should be required. 141 */ assertWritingContentUriRequiresPermission(Uri uri, String permission)142 public void assertWritingContentUriRequiresPermission(Uri uri, String permission) { 143 try { 144 getContext().getContentResolver().insert(uri, new ContentValues()); 145 fail("expected SecurityException requiring " + permission); 146 } catch (SecurityException expected) { 147 assertNotNull("security exception's error message.", expected.getMessage()); 148 assertTrue("error message should contain \"" + permission + "\". Got: \"" 149 + expected.getMessage() + "\".", 150 expected.getMessage().contains(permission)); 151 } 152 } 153 154 /** 155 * This function is called by various TestCase implementations, at tearDown() time, in order 156 * to scrub out any class variables. This protects against memory leaks in the case where a 157 * test case creates a non-static inner class (thus referencing the test case) and gives it to 158 * someone else to hold onto. 159 * 160 * @param testCaseClass The class of the derived TestCase implementation. 161 * 162 * @throws IllegalAccessException 163 */ scrubClass(final Class<?> testCaseClass)164 protected void scrubClass(final Class<?> testCaseClass) 165 throws IllegalAccessException { 166 final Field[] fields = getClass().getDeclaredFields(); 167 for (Field field : fields) { 168 if (!field.getType().isPrimitive() && 169 !Modifier.isStatic(field.getModifiers())) { 170 try { 171 field.setAccessible(true); 172 field.set(this, null); 173 } catch (Exception e) { 174 android.util.Log.d("TestCase", "Error: Could not nullify field!"); 175 } 176 177 if (field.get(this) != null) { 178 android.util.Log.d("TestCase", "Error: Could not nullify field!"); 179 } 180 } 181 } 182 } 183 } 184