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