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