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