The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 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.content.cts; |
| 18 | |
Chenjie Luo | 045a6fa | 2014-09-12 11:54:47 -0700 | [diff] [blame] | 19 | import com.android.cts.content.R; |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 20 | |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 21 | import android.content.ActivityNotFoundException; |
| 22 | import android.content.BroadcastReceiver; |
| 23 | import android.content.ComponentName; |
| 24 | import android.content.Context; |
| 25 | import android.content.ContextWrapper; |
| 26 | import android.content.Intent; |
| 27 | import android.content.IntentFilter; |
| 28 | import android.content.ServiceConnection; |
| 29 | import android.content.SharedPreferences; |
Brett Chabot | 621b1bf | 2009-08-24 17:45:54 -0700 | [diff] [blame] | 30 | import android.content.pm.PackageInfo; |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 31 | import android.content.pm.PackageManager; |
Kristian Monsen | 0162547 | 2011-11-02 11:38:23 +0000 | [diff] [blame] | 32 | import android.cts.util.PollingCheck; |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 33 | import android.database.Cursor; |
| 34 | import android.database.sqlite.SQLiteCursorDriver; |
| 35 | import android.database.sqlite.SQLiteDatabase; |
| 36 | import android.database.sqlite.SQLiteQuery; |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 37 | import android.graphics.Bitmap; |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 38 | import android.graphics.drawable.BitmapDrawable; |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 39 | import android.graphics.drawable.Drawable; |
| 40 | import android.net.Uri; |
| 41 | import android.os.Binder; |
| 42 | import android.os.Bundle; |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 43 | import android.os.IBinder; |
| 44 | import android.preference.PreferenceManager; |
| 45 | import android.test.AndroidTestCase; |
Jeff Brown | 7aea52d | 2015-02-25 14:04:26 -0800 | [diff] [blame] | 46 | import android.view.WindowManager; |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 47 | |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 48 | import java.io.File; |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 49 | import java.io.IOException; |
| 50 | import java.io.InputStream; |
| 51 | import java.util.ArrayList; |
Brian Muramatsu | d4c3a6d | 2012-05-08 12:38:01 -0700 | [diff] [blame] | 52 | import java.util.Arrays; |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 53 | import java.util.List; |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 54 | |
| 55 | /** |
| 56 | * Test {@link ContextWrapper}. |
| 57 | */ |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 58 | public class ContextWrapperTest extends AndroidTestCase { |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 59 | private static final String PERMISSION_HARDWARE_TEST = "android.permission.HARDWARE_TEST"; |
| 60 | |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 61 | private static final String ACTUAL_RESULT = "ResultSetByReceiver"; |
| 62 | |
| 63 | private static final String INTIAL_RESULT = "IntialResult"; |
| 64 | |
| 65 | private static final String VALUE_ADDED = "ValueAdded"; |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 66 | private static final String KEY_ADDED = "AddedByReceiver"; |
| 67 | |
| 68 | private static final String VALUE_REMOVED = "ValueWillBeRemove"; |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 69 | private static final String KEY_REMOVED = "ToBeRemoved"; |
| 70 | |
| 71 | private static final String VALUE_KEPT = "ValueKept"; |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 72 | private static final String KEY_KEPT = "ToBeKept"; |
| 73 | |
| 74 | private static final String MOCK_STICKY_ACTION = "android.content.cts.ContextWrapperTest." |
| 75 | + "STICKY_BROADCAST_RESULT"; |
| 76 | |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 77 | private static final String ACTION_BROADCAST_TESTORDER = |
| 78 | "android.content.cts.ContextWrapperTest.BROADCAST_TESTORDER"; |
| 79 | private final static String MOCK_ACTION1 = ACTION_BROADCAST_TESTORDER + "1"; |
| 80 | private final static String MOCK_ACTION2 = ACTION_BROADCAST_TESTORDER + "2"; |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 81 | |
Chenjie Luo | 045a6fa | 2014-09-12 11:54:47 -0700 | [diff] [blame] | 82 | public static final String PERMISSION_GRANTED = "android.content.cts.permission.TEST_GRANTED"; |
| 83 | public static final String PERMISSION_DENIED = "android.content.cts.permission.TEST_DENIED"; |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 84 | |
Fyodor Kupolov | d476b03 | 2015-10-26 12:40:24 -0700 | [diff] [blame^] | 85 | private static final int BROADCAST_TIMEOUT = 15000; |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 86 | |
| 87 | private Context mContext; |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 88 | |
| 89 | private ContextWrapper mContextWrapper; |
| 90 | private Object mLockObj; |
| 91 | |
| 92 | private ArrayList<BroadcastReceiver> mRegisteredReceiverList; |
| 93 | |
| 94 | private boolean mWallpaperChanged; |
| 95 | private BitmapDrawable mOriginalWallpaper; |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 96 | |
| 97 | @Override |
| 98 | protected void setUp() throws Exception { |
| 99 | super.setUp(); |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 100 | |
| 101 | mLockObj = new Object(); |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 102 | mContext = getContext(); |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 103 | mContextWrapper = new ContextWrapper(mContext); |
| 104 | |
| 105 | mRegisteredReceiverList = new ArrayList<BroadcastReceiver>(); |
| 106 | |
| 107 | mOriginalWallpaper = (BitmapDrawable) mContextWrapper.getWallpaper(); |
| 108 | } |
| 109 | |
| 110 | @Override |
| 111 | protected void tearDown() throws Exception { |
| 112 | if (mWallpaperChanged) { |
| 113 | mContextWrapper.setWallpaper(mOriginalWallpaper.getBitmap()); |
| 114 | } |
| 115 | |
| 116 | for (BroadcastReceiver receiver : mRegisteredReceiverList) { |
| 117 | mContextWrapper.unregisterReceiver(receiver); |
| 118 | } |
| 119 | |
| 120 | super.tearDown(); |
| 121 | } |
| 122 | |
| 123 | private void registerBroadcastReceiver(BroadcastReceiver receiver, IntentFilter filter) { |
| 124 | mContextWrapper.registerReceiver(receiver, filter); |
| 125 | |
| 126 | mRegisteredReceiverList.add(receiver); |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 127 | } |
| 128 | |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 129 | public void testConstructor() { |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 130 | new ContextWrapper(mContext); |
| 131 | |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 132 | // null param is allowed |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 133 | new ContextWrapper(null); |
| 134 | } |
| 135 | |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 136 | public void testEnforceCallingPermission() { |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 137 | try { |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 138 | mContextWrapper.enforceCallingPermission( |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 139 | PERMISSION_HARDWARE_TEST, |
| 140 | "enforceCallingPermission is not working without possessing an IPC."); |
| 141 | fail("enforceCallingPermission is not working without possessing an IPC."); |
| 142 | } catch (SecurityException e) { |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 143 | // Currently no IPC is handled by this process, this exception is expected |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 144 | } |
| 145 | } |
| 146 | |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 147 | public void testSendOrderedBroadcast1() throws InterruptedException { |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 148 | final HighPriorityBroadcastReceiver highPriorityReceiver = |
| 149 | new HighPriorityBroadcastReceiver(); |
| 150 | final LowPriorityBroadcastReceiver lowPriorityReceiver = |
| 151 | new LowPriorityBroadcastReceiver(); |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 152 | |
Keun young Park | 9085d9c | 2012-07-02 21:15:14 -0700 | [diff] [blame] | 153 | final IntentFilter filterHighPriority = new IntentFilter(ResultReceiver.MOCK_ACTION); |
| 154 | filterHighPriority.setPriority(1); |
| 155 | final IntentFilter filterLowPriority = new IntentFilter(ResultReceiver.MOCK_ACTION); |
| 156 | registerBroadcastReceiver(highPriorityReceiver, filterHighPriority); |
| 157 | registerBroadcastReceiver(lowPriorityReceiver, filterLowPriority); |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 158 | |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 159 | final Intent broadcastIntent = new Intent(ResultReceiver.MOCK_ACTION); |
| 160 | mContextWrapper.sendOrderedBroadcast(broadcastIntent, null); |
Kristian Monsen | 0162547 | 2011-11-02 11:38:23 +0000 | [diff] [blame] | 161 | new PollingCheck(BROADCAST_TIMEOUT) { |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 162 | @Override |
| 163 | protected boolean check() { |
| 164 | return highPriorityReceiver.hasReceivedBroadCast() |
| 165 | && !lowPriorityReceiver.hasReceivedBroadCast(); |
| 166 | } |
| 167 | }.run(); |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 168 | |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 169 | synchronized (highPriorityReceiver) { |
| 170 | highPriorityReceiver.notify(); |
| 171 | } |
| 172 | |
Kristian Monsen | 0162547 | 2011-11-02 11:38:23 +0000 | [diff] [blame] | 173 | new PollingCheck(BROADCAST_TIMEOUT) { |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 174 | @Override |
| 175 | protected boolean check() { |
| 176 | return highPriorityReceiver.hasReceivedBroadCast() |
| 177 | && lowPriorityReceiver.hasReceivedBroadCast(); |
| 178 | } |
| 179 | }.run(); |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 180 | } |
| 181 | |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 182 | public void testSendOrderedBroadcast2() throws InterruptedException { |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 183 | final TestBroadcastReceiver broadcastReceiver = new TestBroadcastReceiver(); |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 184 | broadcastReceiver.mIsOrderedBroadcasts = true; |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 185 | |
| 186 | Bundle bundle = new Bundle(); |
| 187 | bundle.putString(KEY_KEPT, VALUE_KEPT); |
| 188 | bundle.putString(KEY_REMOVED, VALUE_REMOVED); |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 189 | mContextWrapper.sendOrderedBroadcast(new Intent(ResultReceiver.MOCK_ACTION), |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 190 | null, broadcastReceiver, null, 1, INTIAL_RESULT, bundle); |
| 191 | |
| 192 | synchronized (mLockObj) { |
| 193 | try { |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 194 | mLockObj.wait(BROADCAST_TIMEOUT); |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 195 | } catch (InterruptedException e) { |
| 196 | fail("unexpected InterruptedException."); |
| 197 | } |
| 198 | } |
| 199 | |
| 200 | assertTrue("Receiver didn't make any response.", broadcastReceiver.hadReceivedBroadCast()); |
| 201 | assertEquals("Incorrect code: " + broadcastReceiver.getResultCode(), 3, |
| 202 | broadcastReceiver.getResultCode()); |
| 203 | assertEquals(ACTUAL_RESULT, broadcastReceiver.getResultData()); |
| 204 | Bundle resultExtras = broadcastReceiver.getResultExtras(false); |
| 205 | assertEquals(VALUE_ADDED, resultExtras.getString(KEY_ADDED)); |
| 206 | assertEquals(VALUE_KEPT, resultExtras.getString(KEY_KEPT)); |
| 207 | assertNull(resultExtras.getString(KEY_REMOVED)); |
| 208 | } |
| 209 | |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 210 | public void testRegisterReceiver1() throws InterruptedException { |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 211 | final FilteredReceiver broadcastReceiver = new FilteredReceiver(); |
| 212 | final IntentFilter filter = new IntentFilter(MOCK_ACTION1); |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 213 | |
| 214 | // Test registerReceiver |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 215 | mContextWrapper.registerReceiver(broadcastReceiver, filter); |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 216 | |
| 217 | // Test unwanted intent(action = MOCK_ACTION2) |
| 218 | broadcastReceiver.reset(); |
Fyodor Kupolov | d476b03 | 2015-10-26 12:40:24 -0700 | [diff] [blame^] | 219 | waitForFilteredIntent(mContextWrapper, MOCK_ACTION2); |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 220 | assertFalse(broadcastReceiver.hadReceivedBroadCast1()); |
| 221 | assertFalse(broadcastReceiver.hadReceivedBroadCast2()); |
| 222 | |
| 223 | // Send wanted intent(action = MOCK_ACTION1) |
| 224 | broadcastReceiver.reset(); |
Fyodor Kupolov | d476b03 | 2015-10-26 12:40:24 -0700 | [diff] [blame^] | 225 | waitForFilteredIntent(mContextWrapper, MOCK_ACTION1); |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 226 | assertTrue(broadcastReceiver.hadReceivedBroadCast1()); |
| 227 | assertFalse(broadcastReceiver.hadReceivedBroadCast2()); |
| 228 | |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 229 | mContextWrapper.unregisterReceiver(broadcastReceiver); |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 230 | |
| 231 | // Test unregisterReceiver |
| 232 | FilteredReceiver broadcastReceiver2 = new FilteredReceiver(); |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 233 | mContextWrapper.registerReceiver(broadcastReceiver2, filter); |
| 234 | mContextWrapper.unregisterReceiver(broadcastReceiver2); |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 235 | |
| 236 | // Test unwanted intent(action = MOCK_ACTION2) |
| 237 | broadcastReceiver2.reset(); |
Fyodor Kupolov | d476b03 | 2015-10-26 12:40:24 -0700 | [diff] [blame^] | 238 | waitForFilteredIntent(mContextWrapper, MOCK_ACTION2); |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 239 | assertFalse(broadcastReceiver2.hadReceivedBroadCast1()); |
| 240 | assertFalse(broadcastReceiver2.hadReceivedBroadCast2()); |
| 241 | |
| 242 | // Send wanted intent(action = MOCK_ACTION1), but the receiver is unregistered. |
| 243 | broadcastReceiver2.reset(); |
Fyodor Kupolov | d476b03 | 2015-10-26 12:40:24 -0700 | [diff] [blame^] | 244 | waitForFilteredIntent(mContextWrapper, MOCK_ACTION1); |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 245 | assertFalse(broadcastReceiver2.hadReceivedBroadCast1()); |
| 246 | assertFalse(broadcastReceiver2.hadReceivedBroadCast2()); |
| 247 | } |
| 248 | |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 249 | public void testRegisterReceiver2() throws InterruptedException { |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 250 | FilteredReceiver broadcastReceiver = new FilteredReceiver(); |
| 251 | IntentFilter filter = new IntentFilter(); |
| 252 | filter.addAction(MOCK_ACTION1); |
| 253 | |
| 254 | // Test registerReceiver |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 255 | mContextWrapper.registerReceiver(broadcastReceiver, filter, null, null); |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 256 | |
| 257 | // Test unwanted intent(action = MOCK_ACTION2) |
| 258 | broadcastReceiver.reset(); |
Fyodor Kupolov | d476b03 | 2015-10-26 12:40:24 -0700 | [diff] [blame^] | 259 | waitForFilteredIntent(mContextWrapper, MOCK_ACTION2); |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 260 | assertFalse(broadcastReceiver.hadReceivedBroadCast1()); |
| 261 | assertFalse(broadcastReceiver.hadReceivedBroadCast2()); |
| 262 | |
| 263 | // Send wanted intent(action = MOCK_ACTION1) |
| 264 | broadcastReceiver.reset(); |
Fyodor Kupolov | d476b03 | 2015-10-26 12:40:24 -0700 | [diff] [blame^] | 265 | waitForFilteredIntent(mContextWrapper, MOCK_ACTION1); |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 266 | assertTrue(broadcastReceiver.hadReceivedBroadCast1()); |
| 267 | assertFalse(broadcastReceiver.hadReceivedBroadCast2()); |
| 268 | |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 269 | mContextWrapper.unregisterReceiver(broadcastReceiver); |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 270 | } |
| 271 | |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 272 | public void testEnforceCallingOrSelfPermission() { |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 273 | try { |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 274 | mContextWrapper.enforceCallingOrSelfPermission(PERMISSION_HARDWARE_TEST, |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 275 | "enforceCallingOrSelfPermission is not working without possessing an IPC."); |
| 276 | fail("enforceCallingOrSelfPermission is not working without possessing an IPC."); |
| 277 | } catch (SecurityException e) { |
| 278 | // If the function is OK, it should throw a SecurityException here because currently no |
| 279 | // IPC is handled by this process. |
| 280 | } |
| 281 | } |
| 282 | |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 283 | public void testAccessWallpaper() throws IOException, InterruptedException { |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 284 | // set Wallpaper by contextWrapper#setWallpaper(Bitmap) |
| 285 | Bitmap bitmap = Bitmap.createBitmap(20, 30, Bitmap.Config.RGB_565); |
| 286 | // Test getWallpaper |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 287 | Drawable testDrawable = mContextWrapper.getWallpaper(); |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 288 | // Test peekWallpaper |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 289 | Drawable testDrawable2 = mContextWrapper.peekWallpaper(); |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 290 | |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 291 | mContextWrapper.setWallpaper(bitmap); |
| 292 | mWallpaperChanged = true; |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 293 | synchronized(this) { |
| 294 | wait(500); |
| 295 | } |
| 296 | |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 297 | assertNotSame(testDrawable, mContextWrapper.peekWallpaper()); |
| 298 | assertNotNull(mContextWrapper.getWallpaper()); |
| 299 | assertNotSame(testDrawable2, mContextWrapper.peekWallpaper()); |
| 300 | assertNotNull(mContextWrapper.peekWallpaper()); |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 301 | |
| 302 | // set Wallpaper by contextWrapper#setWallpaper(InputStream) |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 303 | mContextWrapper.clearWallpaper(); |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 304 | |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 305 | testDrawable = mContextWrapper.getWallpaper(); |
| 306 | InputStream stream = mContextWrapper.getResources().openRawResource(R.drawable.scenery); |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 307 | |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 308 | mContextWrapper.setWallpaper(stream); |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 309 | synchronized (this) { |
| 310 | wait(1000); |
| 311 | } |
| 312 | |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 313 | assertNotSame(testDrawable, mContextWrapper.peekWallpaper()); |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 314 | } |
| 315 | |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 316 | public void testAccessDatabase() { |
| 317 | String DATABASE_NAME = "databasetest"; |
| 318 | String DATABASE_NAME1 = DATABASE_NAME + "1"; |
| 319 | String DATABASE_NAME2 = DATABASE_NAME + "2"; |
| 320 | SQLiteDatabase mDatabase; |
| 321 | File mDatabaseFile; |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 322 | |
| 323 | SQLiteDatabase.CursorFactory factory = new SQLiteDatabase.CursorFactory() { |
| 324 | public Cursor newCursor(SQLiteDatabase db, SQLiteCursorDriver masterQuery, |
| 325 | String editTable, SQLiteQuery query) { |
| 326 | return new android.database.sqlite.SQLiteCursor(db, masterQuery, editTable, query) { |
| 327 | @Override |
| 328 | public boolean requery() { |
| 329 | setSelectionArguments(new String[] { "2" }); |
| 330 | return super.requery(); |
| 331 | } |
| 332 | }; |
| 333 | } |
| 334 | }; |
| 335 | |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 336 | // FIXME: Move cleanup into tearDown() |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 337 | for (String db : mContextWrapper.databaseList()) { |
| 338 | File f = mContextWrapper.getDatabasePath(db); |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 339 | if (f.exists()) { |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 340 | mContextWrapper.deleteDatabase(db); |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 341 | } |
| 342 | } |
| 343 | |
| 344 | // Test openOrCreateDatabase with null and actual factory |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 345 | mDatabase = mContextWrapper.openOrCreateDatabase(DATABASE_NAME1, |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 346 | ContextWrapper.MODE_WORLD_READABLE | ContextWrapper.MODE_WORLD_WRITEABLE, factory); |
| 347 | assertNotNull(mDatabase); |
| 348 | mDatabase.close(); |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 349 | mDatabase = mContextWrapper.openOrCreateDatabase(DATABASE_NAME2, |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 350 | ContextWrapper.MODE_WORLD_READABLE | ContextWrapper.MODE_WORLD_WRITEABLE, factory); |
| 351 | assertNotNull(mDatabase); |
| 352 | mDatabase.close(); |
| 353 | |
| 354 | // Test getDatabasePath |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 355 | File actualDBPath = mContextWrapper.getDatabasePath(DATABASE_NAME1); |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 356 | |
| 357 | // Test databaseList() |
Brian Muramatsu | d4c3a6d | 2012-05-08 12:38:01 -0700 | [diff] [blame] | 358 | List<String> list = Arrays.asList(mContextWrapper.databaseList()); |
| 359 | assertEquals(4, list.size()); // Each database has a journal |
| 360 | assertTrue("1) database list: " + list, list.contains(DATABASE_NAME1)); |
| 361 | assertTrue("2) database list: " + list, list.contains(DATABASE_NAME2)); |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 362 | |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 363 | // Test deleteDatabase() |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 364 | for (int i = 1; i < 3; i++) { |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 365 | mDatabaseFile = mContextWrapper.getDatabasePath(DATABASE_NAME + i); |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 366 | assertTrue(mDatabaseFile.exists()); |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 367 | mContextWrapper.deleteDatabase(DATABASE_NAME + i); |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 368 | mDatabaseFile = new File(actualDBPath, DATABASE_NAME + i); |
| 369 | assertFalse(mDatabaseFile.exists()); |
| 370 | } |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 371 | } |
| 372 | |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 373 | public void testEnforceUriPermission1() { |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 374 | try { |
| 375 | Uri uri = Uri.parse("content://ctstest"); |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 376 | mContextWrapper.enforceUriPermission(uri, Binder.getCallingPid(), |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 377 | Binder.getCallingUid(), Intent.FLAG_GRANT_WRITE_URI_PERMISSION, |
| 378 | "enforceUriPermission is not working without possessing an IPC."); |
| 379 | fail("enforceUriPermission is not working without possessing an IPC."); |
| 380 | } catch (SecurityException e) { |
| 381 | // If the function is OK, it should throw a SecurityException here because currently no |
| 382 | // IPC is handled by this process. |
| 383 | } |
| 384 | } |
| 385 | |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 386 | public void testEnforceUriPermission2() { |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 387 | Uri uri = Uri.parse("content://ctstest"); |
| 388 | try { |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 389 | mContextWrapper.enforceUriPermission(uri, PERMISSION_HARDWARE_TEST, |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 390 | PERMISSION_HARDWARE_TEST, Binder.getCallingPid(), Binder.getCallingUid(), |
| 391 | Intent.FLAG_GRANT_WRITE_URI_PERMISSION, |
| 392 | "enforceUriPermission is not working without possessing an IPC."); |
| 393 | fail("enforceUriPermission is not working without possessing an IPC."); |
| 394 | } catch (SecurityException e) { |
| 395 | // If the function is ok, it should throw a SecurityException here because currently no |
| 396 | // IPC is handled by this process. |
| 397 | } |
| 398 | } |
| 399 | |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 400 | public void testGetPackageResourcePath() { |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 401 | assertNotNull(mContextWrapper.getPackageResourcePath()); |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 402 | } |
| 403 | |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 404 | public void testStartActivity() { |
Chenjie Luo | 045a6fa | 2014-09-12 11:54:47 -0700 | [diff] [blame] | 405 | Intent intent = new Intent(mContext, ContextWrapperCtsActivity.class); |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 406 | intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK); |
| 407 | try { |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 408 | mContextWrapper.startActivity(intent); |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 409 | fail("Test startActivity should thow a ActivityNotFoundException here."); |
| 410 | } catch (ActivityNotFoundException e) { |
| 411 | // Because ContextWrapper is a wrapper class, so no need to test |
| 412 | // the details of the function's performance. Getting a result |
| 413 | // from the wrapped class is enough for testing. |
| 414 | } |
| 415 | } |
| 416 | |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 417 | public void testCreatePackageContext() throws PackageManager.NameNotFoundException { |
Brett Chabot | 621b1bf | 2009-08-24 17:45:54 -0700 | [diff] [blame] | 418 | Context actualContext = mContextWrapper.createPackageContext(getValidPackageName(), |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 419 | Context.CONTEXT_IGNORE_SECURITY); |
| 420 | |
| 421 | assertNotNull(actualContext); |
| 422 | } |
| 423 | |
Brett Chabot | 621b1bf | 2009-08-24 17:45:54 -0700 | [diff] [blame] | 424 | /** |
| 425 | * Helper method to retrieve a valid application package name to use for tests. |
| 426 | */ |
| 427 | private String getValidPackageName() { |
| 428 | List<PackageInfo> packages = mContextWrapper.getPackageManager().getInstalledPackages( |
| 429 | PackageManager.GET_ACTIVITIES); |
| 430 | assertTrue(packages.size() >= 1); |
| 431 | return packages.get(0).packageName; |
| 432 | } |
| 433 | |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 434 | public void testGetMainLooper() { |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 435 | assertNotNull(mContextWrapper.getMainLooper()); |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 436 | } |
| 437 | |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 438 | public void testGetApplicationContext() { |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 439 | assertSame(mContext.getApplicationContext(), mContextWrapper.getApplicationContext()); |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 440 | } |
| 441 | |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 442 | public void testGetSharedPreferences() { |
| 443 | SharedPreferences sp; |
| 444 | SharedPreferences localSP; |
| 445 | |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 446 | sp = PreferenceManager.getDefaultSharedPreferences(mContext); |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 447 | String packageName = mContextWrapper.getPackageName(); |
| 448 | localSP = mContextWrapper.getSharedPreferences(packageName + "_preferences", |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 449 | Context.MODE_PRIVATE); |
| 450 | assertSame(sp, localSP); |
| 451 | } |
| 452 | |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 453 | public void testRevokeUriPermission() { |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 454 | Uri uri = Uri.parse("contents://ctstest"); |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 455 | mContextWrapper.revokeUriPermission(uri, Intent.FLAG_GRANT_WRITE_URI_PERMISSION); |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 456 | } |
| 457 | |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 458 | public void testAccessService() throws InterruptedException { |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 459 | MockContextWrapperService.reset(); |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 460 | bindExpectResult(mContextWrapper, new Intent(mContext, MockContextWrapperService.class)); |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 461 | |
| 462 | // Check startService |
| 463 | assertTrue(MockContextWrapperService.hadCalledOnStart()); |
| 464 | // Check bindService |
| 465 | assertTrue(MockContextWrapperService.hadCalledOnBind()); |
| 466 | |
| 467 | assertTrue(MockContextWrapperService.hadCalledOnDestory()); |
| 468 | // Check unbinService |
| 469 | assertTrue(MockContextWrapperService.hadCalledOnUnbind()); |
| 470 | } |
| 471 | |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 472 | public void testGetPackageCodePath() { |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 473 | assertNotNull(mContextWrapper.getPackageCodePath()); |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 474 | } |
| 475 | |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 476 | public void testGetPackageName() { |
Chenjie Luo | 045a6fa | 2014-09-12 11:54:47 -0700 | [diff] [blame] | 477 | assertEquals("com.android.cts.content", mContextWrapper.getPackageName()); |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 478 | } |
| 479 | |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 480 | public void testGetCacheDir() { |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 481 | assertNotNull(mContextWrapper.getCacheDir()); |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 482 | } |
| 483 | |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 484 | public void testGetContentResolver() { |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 485 | assertSame(mContext.getContentResolver(), mContextWrapper.getContentResolver()); |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 486 | } |
| 487 | |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 488 | public void testAccessBaseContext() throws PackageManager.NameNotFoundException { |
| 489 | MockContextWrapper testContextWrapper = new MockContextWrapper(mContext); |
| 490 | |
| 491 | // Test getBaseContext() |
| 492 | assertSame(mContext, testContextWrapper.getBaseContext()); |
| 493 | |
Brett Chabot | 621b1bf | 2009-08-24 17:45:54 -0700 | [diff] [blame] | 494 | Context secondContext = testContextWrapper.createPackageContext(getValidPackageName(), |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 495 | Context.CONTEXT_IGNORE_SECURITY); |
| 496 | assertNotNull(secondContext); |
| 497 | |
| 498 | // Test attachBaseContext |
| 499 | try { |
| 500 | testContextWrapper.attachBaseContext(secondContext); |
| 501 | fail("If base context has already been set, it should throw a IllegalStateException."); |
| 502 | } catch (IllegalStateException e) { |
| 503 | } |
| 504 | } |
| 505 | |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 506 | public void testGetFileStreamPath() { |
| 507 | String TEST_FILENAME = "TestGetFileStreamPath"; |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 508 | |
| 509 | // Test the path including the input filename |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 510 | String fileStreamPath = mContextWrapper.getFileStreamPath(TEST_FILENAME).toString(); |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 511 | assertTrue(fileStreamPath.indexOf(TEST_FILENAME) >= 0); |
| 512 | } |
| 513 | |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 514 | public void testGetClassLoader() { |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 515 | assertSame(mContext.getClassLoader(), mContextWrapper.getClassLoader()); |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 516 | } |
| 517 | |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 518 | public void testGetWallpaperDesiredMinimumHeightAndWidth() { |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 519 | int height = mContextWrapper.getWallpaperDesiredMinimumHeight(); |
| 520 | int width = mContextWrapper.getWallpaperDesiredMinimumWidth(); |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 521 | |
| 522 | // returned value is <= 0, the caller should use the height of the |
| 523 | // default display instead. |
| 524 | // That is to say, the return values of desired minimumHeight and |
| 525 | // minimunWidth are at the same side of 0-dividing line. |
| 526 | assertTrue((height > 0 && width > 0) || (height <= 0 && width <= 0)); |
| 527 | } |
| 528 | |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 529 | public void testAccessStickyBroadcast() throws InterruptedException { |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 530 | ResultReceiver resultReceiver = new ResultReceiver(); |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 531 | |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 532 | Intent intent = new Intent(MOCK_STICKY_ACTION); |
| 533 | TestBroadcastReceiver stickyReceiver = new TestBroadcastReceiver(); |
| 534 | |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 535 | mContextWrapper.sendStickyBroadcast(intent); |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 536 | |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 537 | waitForReceiveBroadCast(resultReceiver); |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 538 | |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 539 | assertEquals(intent.getAction(), mContextWrapper.registerReceiver(stickyReceiver, |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 540 | new IntentFilter(MOCK_STICKY_ACTION)).getAction()); |
| 541 | |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 542 | synchronized (mLockObj) { |
| 543 | mLockObj.wait(BROADCAST_TIMEOUT); |
| 544 | } |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 545 | |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 546 | assertTrue("Receiver didn't make any response.", stickyReceiver.hadReceivedBroadCast()); |
| 547 | |
| 548 | mContextWrapper.unregisterReceiver(stickyReceiver); |
| 549 | mContextWrapper.removeStickyBroadcast(intent); |
| 550 | |
| 551 | assertNull(mContextWrapper.registerReceiver(stickyReceiver, |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 552 | new IntentFilter(MOCK_STICKY_ACTION))); |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 553 | mContextWrapper.unregisterReceiver(stickyReceiver); |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 554 | } |
| 555 | |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 556 | public void testCheckCallingOrSelfUriPermission() { |
| 557 | Uri uri = Uri.parse("content://ctstest"); |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 558 | |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 559 | int retValue = mContextWrapper.checkCallingOrSelfUriPermission(uri, |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 560 | Intent.FLAG_GRANT_WRITE_URI_PERMISSION); |
| 561 | assertEquals(PackageManager.PERMISSION_DENIED, retValue); |
| 562 | } |
| 563 | |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 564 | public void testGrantUriPermission() { |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 565 | mContextWrapper.grantUriPermission("com.android.mms", Uri.parse("contents://ctstest"), |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 566 | Intent.FLAG_GRANT_WRITE_URI_PERMISSION); |
| 567 | } |
| 568 | |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 569 | public void testEnforcePermission() { |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 570 | try { |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 571 | mContextWrapper.enforcePermission( |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 572 | PERMISSION_HARDWARE_TEST, Binder.getCallingPid(), |
| 573 | Binder.getCallingUid(), |
| 574 | "enforcePermission is not working without possessing an IPC."); |
| 575 | fail("enforcePermission is not working without possessing an IPC."); |
| 576 | } catch (SecurityException e) { |
| 577 | // If the function is ok, it should throw a SecurityException here |
| 578 | // because currently no IPC is handled by this process. |
| 579 | } |
| 580 | } |
| 581 | |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 582 | public void testCheckUriPermission1() { |
| 583 | Uri uri = Uri.parse("content://ctstest"); |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 584 | |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 585 | int retValue = mContextWrapper.checkUriPermission(uri, Binder.getCallingPid(), 0, |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 586 | Intent.FLAG_GRANT_WRITE_URI_PERMISSION); |
| 587 | assertEquals(PackageManager.PERMISSION_GRANTED, retValue); |
| 588 | |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 589 | retValue = mContextWrapper.checkUriPermission(uri, Binder.getCallingPid(), |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 590 | Binder.getCallingUid(), Intent.FLAG_GRANT_WRITE_URI_PERMISSION); |
| 591 | assertEquals(PackageManager.PERMISSION_DENIED, retValue); |
| 592 | } |
| 593 | |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 594 | public void testCheckUriPermission2() { |
| 595 | Uri uri = Uri.parse("content://ctstest"); |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 596 | |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 597 | int retValue = mContextWrapper.checkUriPermission(uri, PERMISSION_HARDWARE_TEST, |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 598 | PERMISSION_HARDWARE_TEST, Binder.getCallingPid(), 0, |
| 599 | Intent.FLAG_GRANT_WRITE_URI_PERMISSION); |
| 600 | assertEquals(PackageManager.PERMISSION_GRANTED, retValue); |
| 601 | |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 602 | retValue = mContextWrapper.checkUriPermission(uri, PERMISSION_HARDWARE_TEST, |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 603 | PERMISSION_HARDWARE_TEST, Binder.getCallingPid(), Binder.getCallingUid(), |
| 604 | Intent.FLAG_GRANT_WRITE_URI_PERMISSION); |
| 605 | assertEquals(PackageManager.PERMISSION_DENIED, retValue); |
| 606 | } |
| 607 | |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 608 | public void testCheckCallingPermission() { |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 609 | int retValue = mContextWrapper.checkCallingPermission(PERMISSION_HARDWARE_TEST); |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 610 | assertEquals(PackageManager.PERMISSION_DENIED, retValue); |
| 611 | } |
| 612 | |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 613 | public void testCheckCallingUriPermission() { |
| 614 | Uri uri = Uri.parse("content://ctstest"); |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 615 | |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 616 | int retValue = mContextWrapper.checkCallingUriPermission(uri, |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 617 | Intent.FLAG_GRANT_WRITE_URI_PERMISSION); |
| 618 | assertEquals(PackageManager.PERMISSION_DENIED, retValue); |
| 619 | } |
| 620 | |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 621 | public void testEnforceCallingUriPermission() { |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 622 | try { |
| 623 | Uri uri = Uri.parse("content://ctstest"); |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 624 | mContextWrapper.enforceCallingUriPermission(uri, Intent.FLAG_GRANT_WRITE_URI_PERMISSION, |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 625 | "enforceCallingUriPermission is not working without possessing an IPC."); |
| 626 | fail("enforceCallingUriPermission is not working without possessing an IPC."); |
| 627 | } catch (SecurityException e) { |
| 628 | // If the function is OK, it should throw a SecurityException here because currently no |
| 629 | // IPC is handled by this process. |
| 630 | } |
| 631 | } |
| 632 | |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 633 | public void testGetDir() { |
Brett Chabot | c9728b3 | 2009-12-17 12:26:56 -0800 | [diff] [blame] | 634 | File dir = mContextWrapper.getDir("testpath", Context.MODE_WORLD_WRITEABLE); |
| 635 | assertNotNull(dir); |
| 636 | dir.delete(); |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 637 | } |
| 638 | |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 639 | public void testGetPackageManager() { |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 640 | assertSame(mContext.getPackageManager(), mContextWrapper.getPackageManager()); |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 641 | } |
| 642 | |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 643 | public void testCheckCallingOrSelfPermission() { |
Amith Yamasani | 83d9010 | 2014-10-01 17:12:43 -0700 | [diff] [blame] | 644 | int retValue = mContextWrapper.checkCallingOrSelfPermission( |
| 645 | "android.permission.SET_WALLPAPER"); |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 646 | assertEquals(PackageManager.PERMISSION_GRANTED, retValue); |
| 647 | } |
| 648 | |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 649 | public void testSendBroadcast1() throws InterruptedException { |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 650 | final ResultReceiver receiver = new ResultReceiver(); |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 651 | |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 652 | registerBroadcastReceiver(receiver, new IntentFilter(ResultReceiver.MOCK_ACTION)); |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 653 | |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 654 | mContextWrapper.sendBroadcast(new Intent(ResultReceiver.MOCK_ACTION)); |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 655 | |
Kristian Monsen | 0162547 | 2011-11-02 11:38:23 +0000 | [diff] [blame] | 656 | new PollingCheck(BROADCAST_TIMEOUT){ |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 657 | @Override |
| 658 | protected boolean check() { |
| 659 | return receiver.hasReceivedBroadCast(); |
| 660 | } |
| 661 | }.run(); |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 662 | } |
| 663 | |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 664 | public void testSendBroadcast2() throws InterruptedException { |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 665 | final ResultReceiver receiver = new ResultReceiver(); |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 666 | |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 667 | registerBroadcastReceiver(receiver, new IntentFilter(ResultReceiver.MOCK_ACTION)); |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 668 | |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 669 | mContextWrapper.sendBroadcast(new Intent(ResultReceiver.MOCK_ACTION), null); |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 670 | |
Kristian Monsen | 0162547 | 2011-11-02 11:38:23 +0000 | [diff] [blame] | 671 | new PollingCheck(BROADCAST_TIMEOUT){ |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 672 | @Override |
| 673 | protected boolean check() { |
| 674 | return receiver.hasReceivedBroadCast(); |
| 675 | } |
| 676 | }.run(); |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 677 | } |
| 678 | |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 679 | public void testEnforceCallingOrSelfUriPermission() { |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 680 | try { |
| 681 | Uri uri = Uri.parse("content://ctstest"); |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 682 | mContextWrapper.enforceCallingOrSelfUriPermission(uri, |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 683 | Intent.FLAG_GRANT_WRITE_URI_PERMISSION, |
| 684 | "enforceCallingOrSelfUriPermission is not working without possessing an IPC."); |
| 685 | fail("enforceCallingOrSelfUriPermission is not working without possessing an IPC."); |
| 686 | } catch (SecurityException e) { |
| 687 | // If the function is OK, it should throw a SecurityException here because currently no |
| 688 | // IPC is handled by this process. |
| 689 | } |
| 690 | } |
| 691 | |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 692 | public void testCheckPermission() { |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 693 | // Test with root user, everything will be granted. |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 694 | int returnValue = mContextWrapper.checkPermission(PERMISSION_HARDWARE_TEST, 1, 0); |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 695 | assertEquals(PackageManager.PERMISSION_GRANTED, returnValue); |
| 696 | |
| 697 | // Test with non-root user, only included granted permission. |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 698 | returnValue = mContextWrapper.checkPermission(PERMISSION_HARDWARE_TEST, 1, 1); |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 699 | assertEquals(PackageManager.PERMISSION_DENIED, returnValue); |
| 700 | |
| 701 | // Test with null permission. |
| 702 | try { |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 703 | returnValue = mContextWrapper.checkPermission(null, 0, 0); |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 704 | fail("checkPermission should not accept null permission"); |
| 705 | } catch (IllegalArgumentException e) { |
| 706 | } |
| 707 | |
| 708 | // Test with invalid uid and included granted permission. |
Amith Yamasani | 83d9010 | 2014-10-01 17:12:43 -0700 | [diff] [blame] | 709 | returnValue = mContextWrapper.checkPermission("android.permission.SET_WALLPAPER", 1, -11); |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 710 | assertEquals(PackageManager.PERMISSION_DENIED, returnValue); |
| 711 | } |
| 712 | |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 713 | public void testGetSystemService() { |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 714 | // Test invalid service name |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 715 | assertNull(mContextWrapper.getSystemService("invalid")); |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 716 | |
| 717 | // Test valid service name |
Christian Mehlmauer | 9ff90a3 | 2010-06-01 23:06:29 +0200 | [diff] [blame] | 718 | assertNotNull(mContextWrapper.getSystemService(Context.WINDOW_SERVICE)); |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 719 | } |
| 720 | |
Jeff Brown | 7aea52d | 2015-02-25 14:04:26 -0800 | [diff] [blame] | 721 | public void testGetSystemServiceByClass() { |
| 722 | // Test invalid service class |
| 723 | assertNull(mContextWrapper.getSystemService(Object.class)); |
| 724 | |
| 725 | // Test valid service name |
| 726 | assertNotNull(mContextWrapper.getSystemService(WindowManager.class)); |
| 727 | assertEquals(mContextWrapper.getSystemService(Context.WINDOW_SERVICE), |
| 728 | mContextWrapper.getSystemService(WindowManager.class)); |
| 729 | } |
| 730 | |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 731 | public void testGetAssets() { |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 732 | assertSame(mContext.getAssets(), mContextWrapper.getAssets()); |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 733 | } |
| 734 | |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 735 | public void testGetResources() { |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 736 | assertSame(mContext.getResources(), mContextWrapper.getResources()); |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 737 | } |
| 738 | |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 739 | public void testStartInstrumentation() { |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 740 | // Use wrong name |
| 741 | ComponentName cn = new ComponentName("com.android", |
| 742 | "com.android.content.FalseLocalSampleInstrumentation"); |
| 743 | assertNotNull(cn); |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 744 | assertNotNull(mContextWrapper); |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 745 | // If the target instrumentation is wrong, the function should return false. |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 746 | assertFalse(mContextWrapper.startInstrumentation(cn, null, null)); |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 747 | } |
| 748 | |
| 749 | private void bindExpectResult(Context contextWrapper, Intent service) |
| 750 | throws InterruptedException { |
| 751 | if (service == null) { |
| 752 | fail("No service created!"); |
| 753 | } |
| 754 | TestConnection conn = new TestConnection(true, false); |
| 755 | |
| 756 | contextWrapper.bindService(service, conn, Context.BIND_AUTO_CREATE); |
| 757 | contextWrapper.startService(service); |
| 758 | |
| 759 | // Wait for a short time, so the service related operations could be |
| 760 | // working. |
| 761 | synchronized (this) { |
| 762 | wait(2500); |
| 763 | } |
| 764 | // Test stop Service |
| 765 | assertTrue(contextWrapper.stopService(service)); |
| 766 | contextWrapper.unbindService(conn); |
| 767 | |
| 768 | synchronized (this) { |
| 769 | wait(1000); |
| 770 | } |
| 771 | } |
| 772 | |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 773 | private interface Condition { |
| 774 | public boolean onCondition(); |
| 775 | } |
| 776 | |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 777 | private synchronized void waitForCondition(Condition con) throws InterruptedException { |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 778 | // check the condition every 1 second until the condition is fulfilled |
| 779 | // and wait for 3 seconds at most |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 780 | for (int i = 0; !con.onCondition() && i <= 3; i++) { |
| 781 | wait(1000); |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 782 | } |
| 783 | } |
| 784 | |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 785 | private void waitForReceiveBroadCast(final ResultReceiver receiver) |
| 786 | throws InterruptedException { |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 787 | Condition con = new Condition() { |
| 788 | public boolean onCondition() { |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 789 | return receiver.hasReceivedBroadCast(); |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 790 | } |
| 791 | }; |
| 792 | waitForCondition(con); |
| 793 | } |
| 794 | |
Fyodor Kupolov | d476b03 | 2015-10-26 12:40:24 -0700 | [diff] [blame^] | 795 | private void waitForFilteredIntent(ContextWrapper contextWrapper, final String action) |
| 796 | throws InterruptedException { |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 797 | contextWrapper.sendOrderedBroadcast(new Intent(action), null); |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 798 | |
| 799 | synchronized (mLockObj) { |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 800 | mLockObj.wait(BROADCAST_TIMEOUT); |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 801 | } |
| 802 | } |
| 803 | |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 804 | private static final class MockContextWrapper extends ContextWrapper { |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 805 | public MockContextWrapper(Context base) { |
| 806 | super(base); |
| 807 | } |
| 808 | |
| 809 | @Override |
| 810 | public void attachBaseContext(Context base) { |
| 811 | super.attachBaseContext(base); |
| 812 | } |
| 813 | } |
| 814 | |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 815 | private final class TestBroadcastReceiver extends BroadcastReceiver { |
| 816 | boolean mHadReceivedBroadCast; |
| 817 | boolean mIsOrderedBroadcasts; |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 818 | |
| 819 | @Override |
| 820 | public void onReceive(Context context, Intent intent) { |
| 821 | synchronized (this) { |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 822 | if (mIsOrderedBroadcasts) { |
| 823 | setResultCode(3); |
| 824 | setResultData(ACTUAL_RESULT); |
| 825 | } |
| 826 | |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 827 | Bundle map = getResultExtras(false); |
| 828 | if (map != null) { |
| 829 | map.remove(KEY_REMOVED); |
| 830 | map.putString(KEY_ADDED, VALUE_ADDED); |
| 831 | } |
| 832 | mHadReceivedBroadCast = true; |
| 833 | this.notifyAll(); |
| 834 | } |
| 835 | |
| 836 | synchronized (mLockObj) { |
| 837 | mLockObj.notify(); |
| 838 | } |
| 839 | } |
| 840 | |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 841 | boolean hadReceivedBroadCast() { |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 842 | return mHadReceivedBroadCast; |
| 843 | } |
| 844 | |
Phil Dubach | b59283e | 2009-07-21 14:45:09 -0700 | [diff] [blame] | 845 | void reset(){ |
The Android Open Source Project | f805710 | 2009-03-15 16:47:16 -0700 | [diff] [blame] | 846 | mHadReceivedBroadCast = false; |
| 847 | } |
| 848 | } |
| 849 | |
| 850 | private class FilteredReceiver extends BroadcastReceiver { |
| 851 | private boolean mHadReceivedBroadCast1 = false; |
| 852 | |
| 853 | private boolean mHadReceivedBroadCast2 = false; |
| 854 | |
| 855 | public void onReceive(Context context, Intent intent) { |
| 856 | String action = intent.getAction(); |
| 857 | if (MOCK_ACTION1.equals(action)) { |
| 858 | mHadReceivedBroadCast1 = true; |
| 859 | } else if (MOCK_ACTION2.equals(action)) { |
| 860 | mHadReceivedBroadCast2 = true; |
| 861 | } |
| 862 | |
| 863 | synchronized (mLockObj) { |
| 864 | mLockObj.notify(); |
| 865 | } |
| 866 | } |
| 867 | |
| 868 | public boolean hadReceivedBroadCast1() { |
| 869 | return mHadReceivedBroadCast1; |
| 870 | } |
| 871 | |
| 872 | public boolean hadReceivedBroadCast2() { |
| 873 | return mHadReceivedBroadCast2; |
| 874 | } |
| 875 | |
| 876 | public void reset(){ |
| 877 | mHadReceivedBroadCast1 = false; |
| 878 | mHadReceivedBroadCast2 = false; |
| 879 | } |
| 880 | } |
| 881 | |
| 882 | private class TestConnection implements ServiceConnection { |
| 883 | public TestConnection(boolean expectDisconnect, boolean setReporter) { |
| 884 | } |
| 885 | |
| 886 | void setMonitor(boolean v) { |
| 887 | } |
| 888 | |
| 889 | public void onServiceConnected(ComponentName name, IBinder service) { |
| 890 | } |
| 891 | |
| 892 | public void onServiceDisconnected(ComponentName name) { |
| 893 | } |
| 894 | } |
| 895 | } |