1 package org.robolectric.shadows; 2 3 import static android.os.Build.VERSION_CODES.M; 4 import static android.os.Build.VERSION_CODES.N; 5 import static android.os.Build.VERSION_CODES.O; 6 import static android.os.Build.VERSION_CODES.O_MR1; 7 import static android.os.Build.VERSION_CODES.Q; 8 import static android.os.Build.VERSION_CODES.S; 9 import static android.os.Build.VERSION_CODES.UPSIDE_DOWN_CAKE; 10 import static android.os.Looper.getMainLooper; 11 import static com.google.common.truth.Truth.assertThat; 12 import static com.google.common.truth.Truth.assertWithMessage; 13 import static org.junit.Assert.assertEquals; 14 import static org.junit.Assert.assertFalse; 15 import static org.junit.Assert.assertNotNull; 16 import static org.junit.Assert.assertNotSame; 17 import static org.junit.Assert.assertNull; 18 import static org.junit.Assert.assertSame; 19 import static org.junit.Assert.assertThrows; 20 import static org.junit.Assert.assertTrue; 21 import static org.junit.Assert.fail; 22 import static org.robolectric.Robolectric.buildActivity; 23 import static org.robolectric.Robolectric.setupActivity; 24 import static org.robolectric.RuntimeEnvironment.getApplication; 25 import static org.robolectric.RuntimeEnvironment.systemContext; 26 import static org.robolectric.Shadows.shadowOf; 27 import static org.robolectric.annotation.LooperMode.Mode.LEGACY; 28 29 import android.Manifest; 30 import android.app.ActionBar; 31 import android.app.Activity; 32 import android.app.ActivityOptions; 33 import android.app.Application; 34 import android.app.Dialog; 35 import android.app.DirectAction; 36 import android.app.Fragment; 37 import android.app.PendingIntent; 38 import android.app.PictureInPictureParams; 39 import android.appwidget.AppWidgetProvider; 40 import android.content.ComponentName; 41 import android.content.Context; 42 import android.content.Intent; 43 import android.content.IntentFilter; 44 import android.content.IntentSender; 45 import android.content.LocusId; 46 import android.content.SharedPreferences; 47 import android.content.pm.ActivityInfo; 48 import android.database.Cursor; 49 import android.database.MatrixCursor; 50 import android.graphics.Color; 51 import android.media.AudioManager; 52 import android.net.Uri; 53 import android.os.Build.VERSION_CODES; 54 import android.os.Bundle; 55 import android.os.CancellationSignal; 56 import android.view.Display; 57 import android.view.KeyEvent; 58 import android.view.Menu; 59 import android.view.MenuInflater; 60 import android.view.MenuItem; 61 import android.view.View; 62 import android.view.ViewGroup; 63 import android.view.ViewRootImpl; 64 import android.view.Window; 65 import android.view.WindowManager; 66 import android.widget.FrameLayout; 67 import android.widget.LinearLayout; 68 import android.widget.SearchView; 69 import androidx.test.core.app.ApplicationProvider; 70 import androidx.test.ext.junit.runners.AndroidJUnit4; 71 import java.util.ArrayList; 72 import java.util.Collections; 73 import java.util.List; 74 import java.util.concurrent.atomic.AtomicBoolean; 75 import java.util.function.Consumer; 76 import org.junit.Test; 77 import org.junit.runner.RunWith; 78 import org.robolectric.R; 79 import org.robolectric.Robolectric; 80 import org.robolectric.android.controller.ActivityController; 81 import org.robolectric.annotation.Config; 82 import org.robolectric.annotation.LooperMode; 83 import org.robolectric.annotation.LooperMode.Mode; 84 import org.robolectric.fakes.RoboSplashScreen; 85 import org.robolectric.shadows.ShadowActivity.IntentSenderRequest; 86 import org.robolectric.util.TestRunnable; 87 88 /** Test of ShadowActivity. */ 89 @RunWith(AndroidJUnit4.class) 90 @SuppressWarnings("RobolectricSystemContext") // preexisting when check was enabled 91 public class ShadowActivityTest { 92 private Activity activity; 93 94 @Test shouldUseApplicationLabelFromManifestAsTitleForActivity()95 public void shouldUseApplicationLabelFromManifestAsTitleForActivity() throws Exception { 96 activity = Robolectric.setupActivity(LabelTestActivity1.class); 97 assertThat(activity.getTitle()).isNotNull(); 98 assertThat(activity.getTitle().toString()).isEqualTo(activity.getString(R.string.app_name)); 99 } 100 101 @Test shouldUseActivityLabelFromManifestAsTitleForActivity()102 public void shouldUseActivityLabelFromManifestAsTitleForActivity() throws Exception { 103 activity = Robolectric.setupActivity(LabelTestActivity2.class); 104 assertThat(activity.getTitle()).isNotNull(); 105 assertThat(activity.getTitle().toString()) 106 .isEqualTo(activity.getString(R.string.activity_name)); 107 } 108 109 @Test shouldUseActivityLabelFromManifestAsTitleForActivityWithShortName()110 public void shouldUseActivityLabelFromManifestAsTitleForActivityWithShortName() throws Exception { 111 activity = Robolectric.setupActivity(LabelTestActivity3.class); 112 assertThat(activity.getTitle()).isNotNull(); 113 assertThat(activity.getTitle().toString()) 114 .isEqualTo(activity.getString(R.string.activity_name)); 115 } 116 117 @Test createActivity_noDisplayFinished_shouldFinishActivity()118 public void createActivity_noDisplayFinished_shouldFinishActivity() { 119 try (ActivityController<Activity> controller = Robolectric.buildActivity(Activity.class)) { 120 controller.get().setTheme(android.R.style.Theme_NoDisplay); 121 controller.create(); 122 controller.get().finish(); 123 controller.start().visible().resume(); 124 125 activity = controller.get(); 126 assertThat(activity.isFinishing()).isTrue(); 127 } 128 } 129 130 @Config(minSdk = M) 131 @Test createActivity_noDisplayNotFinished_shouldThrowIllegalStateException()132 public void createActivity_noDisplayNotFinished_shouldThrowIllegalStateException() { 133 try { 134 ActivityController<Activity> controller = Robolectric.buildActivity(Activity.class); 135 controller.get().setTheme(android.R.style.Theme_NoDisplay); 136 controller.setup(); 137 138 // For apps targeting above Lollipop MR1, an exception "Activity <activity> did not call 139 // finish() prior to onResume() completing" will be thrown 140 fail("IllegalStateException should be thrown"); 141 } catch (IllegalStateException e) { 142 // pass 143 } 144 } 145 146 public static final class LabelTestActivity1 extends Activity {} 147 148 public static final class LabelTestActivity2 extends Activity {} 149 150 public static final class LabelTestActivity3 extends Activity {} 151 152 @Test 153 public void shouldNotComplainIfActivityIsDestroyedWhileAnotherActivityHasRegisteredBroadcastReceivers()154 shouldNotComplainIfActivityIsDestroyedWhileAnotherActivityHasRegisteredBroadcastReceivers() 155 throws Exception { 156 try (ActivityController<DialogCreatingActivity> controller = 157 Robolectric.buildActivity(DialogCreatingActivity.class)) { 158 activity = controller.get(); 159 160 DialogLifeCycleActivity activity2 = Robolectric.setupActivity(DialogLifeCycleActivity.class); 161 activity2.registerReceiver(new AppWidgetProvider(), new IntentFilter()); 162 163 controller.destroy(); 164 } 165 } 166 167 @Test shouldNotRegisterNullBroadcastReceiver()168 public void shouldNotRegisterNullBroadcastReceiver() { 169 try (ActivityController<DialogCreatingActivity> controller = 170 Robolectric.buildActivity(DialogCreatingActivity.class)) { 171 activity = controller.get(); 172 activity.registerReceiver(null, new IntentFilter()); 173 174 controller.destroy(); 175 } 176 } 177 178 @Test shouldReportDestroyedStatus()179 public void shouldReportDestroyedStatus() { 180 try (ActivityController<DialogCreatingActivity> controller = 181 Robolectric.buildActivity(DialogCreatingActivity.class)) { 182 activity = controller.get(); 183 184 controller.destroy(); 185 assertThat(activity.isDestroyed()).isTrue(); 186 } 187 } 188 189 @Test startActivity_shouldDelegateToStartActivityForResult()190 public void startActivity_shouldDelegateToStartActivityForResult() { 191 192 TranscriptActivity activity = Robolectric.setupActivity(TranscriptActivity.class); 193 194 activity.startActivity(new Intent().setType("image/*")); 195 196 shadowOf(activity) 197 .receiveResult( 198 new Intent().setType("image/*"), 199 Activity.RESULT_OK, 200 new Intent().setData(Uri.parse("content:foo"))); 201 assertThat(activity.transcript) 202 .containsExactly( 203 "onActivityResult called with requestCode -1, resultCode -1, intent data content:foo"); 204 } 205 206 public static class TranscriptActivity extends Activity { 207 final List<String> transcript = new ArrayList<>(); 208 209 @Override onActivityResult(int requestCode, int resultCode, Intent data)210 protected void onActivityResult(int requestCode, int resultCode, Intent data) { 211 transcript.add( 212 "onActivityResult called with requestCode " 213 + requestCode 214 + ", resultCode " 215 + resultCode 216 + ", intent data " 217 + data.getData()); 218 } 219 } 220 221 @Test startActivities_shouldStartAllActivities()222 public void startActivities_shouldStartAllActivities() { 223 activity = Robolectric.setupActivity(DialogLifeCycleActivity.class); 224 225 final Intent view = new Intent(Intent.ACTION_VIEW); 226 final Intent pick = new Intent(Intent.ACTION_PICK); 227 activity.startActivities(new Intent[] {view, pick}); 228 229 assertThat(shadowOf(activity).getNextStartedActivity()).isEqualTo(pick); 230 assertThat(shadowOf(activity).getNextStartedActivity()).isEqualTo(view); 231 } 232 233 @Test startActivities_withBundle_shouldStartAllActivities()234 public void startActivities_withBundle_shouldStartAllActivities() { 235 activity = Robolectric.setupActivity(DialogLifeCycleActivity.class); 236 237 final Intent view = new Intent(Intent.ACTION_VIEW); 238 final Intent pick = new Intent(Intent.ACTION_PICK); 239 activity.startActivities(new Intent[] {view, pick}, new Bundle()); 240 241 assertThat(shadowOf(activity).getNextStartedActivity()).isEqualTo(pick); 242 assertThat(shadowOf(activity).getNextStartedActivity()).isEqualTo(view); 243 } 244 245 @Test startActivityForResultAndReceiveResult_shouldSendResponsesBackToActivity()246 public void startActivityForResultAndReceiveResult_shouldSendResponsesBackToActivity() { 247 TranscriptActivity activity = Robolectric.setupActivity(TranscriptActivity.class); 248 activity.startActivityForResult(new Intent().setType("audio/*"), 123); 249 activity.startActivityForResult(new Intent().setType("image/*"), 456); 250 251 shadowOf(activity) 252 .receiveResult( 253 new Intent().setType("image/*"), 254 Activity.RESULT_OK, 255 new Intent().setData(Uri.parse("content:foo"))); 256 assertThat(activity.transcript) 257 .containsExactly( 258 "onActivityResult called with requestCode 456, resultCode -1, intent data content:foo"); 259 } 260 261 @Test startActivityForResultAndReceiveResult_whenNoIntentMatches_shouldThrowException()262 public void startActivityForResultAndReceiveResult_whenNoIntentMatches_shouldThrowException() { 263 Intent requestIntent = new Intent(); 264 try (ActivityController<ThrowOnResultActivity> controller = 265 Robolectric.buildActivity(ThrowOnResultActivity.class)) { 266 ThrowOnResultActivity activity = controller.get(); 267 activity.startActivityForResult(new Intent().setType("audio/*"), 123); 268 activity.startActivityForResult(new Intent().setType("image/*"), 456); 269 270 requestIntent.setType("video/*"); 271 shadowOf(activity) 272 .receiveResult( 273 requestIntent, Activity.RESULT_OK, new Intent().setData(Uri.parse("content:foo"))); 274 fail(); 275 } catch (Exception e) { 276 assertThat(e.getMessage()).startsWith("No intent matches " + requestIntent); 277 } 278 } 279 280 public static class ThrowOnResultActivity extends Activity { 281 @Override onActivityResult(int requestCode, int resultCode, Intent data)282 protected void onActivityResult(int requestCode, int resultCode, Intent data) { 283 throw new IllegalStateException("should not be called"); 284 } 285 } 286 287 @Test shouldSupportStartActivityForResult()288 public void shouldSupportStartActivityForResult() { 289 activity = Robolectric.setupActivity(DialogLifeCycleActivity.class); 290 Intent intent = new Intent().setClass(activity, DialogLifeCycleActivity.class); 291 assertThat(shadowOf(activity).getNextStartedActivity()).isNull(); 292 293 activity.startActivityForResult(intent, 142); 294 295 Intent startedIntent = shadowOf(activity).getNextStartedActivity(); 296 assertThat(startedIntent).isNotNull(); 297 assertThat(startedIntent).isSameInstanceAs(intent); 298 } 299 300 @Test shouldSupportGetStartedActivitiesForResult()301 public void shouldSupportGetStartedActivitiesForResult() { 302 activity = Robolectric.setupActivity(DialogLifeCycleActivity.class); 303 Intent intent = new Intent().setClass(activity, DialogLifeCycleActivity.class); 304 305 activity.startActivityForResult(intent, 142); 306 307 ShadowActivity.IntentForResult intentForResult = 308 shadowOf(activity).getNextStartedActivityForResult(); 309 assertThat(intentForResult).isNotNull(); 310 assertThat(shadowOf(activity).getNextStartedActivityForResult()).isNull(); 311 assertThat(intentForResult.intent).isNotNull(); 312 assertThat(intentForResult.intent).isSameInstanceAs(intent); 313 assertThat(intentForResult.requestCode).isEqualTo(142); 314 } 315 316 @Test shouldSupportPeekStartedActivitiesForResult()317 public void shouldSupportPeekStartedActivitiesForResult() { 318 activity = Robolectric.setupActivity(DialogLifeCycleActivity.class); 319 Intent intent = new Intent().setClass(activity, DialogLifeCycleActivity.class); 320 321 activity.startActivityForResult(intent, 142); 322 323 ShadowActivity.IntentForResult intentForResult = 324 shadowOf(activity).peekNextStartedActivityForResult(); 325 assertThat(intentForResult).isNotNull(); 326 assertThat(shadowOf(activity).peekNextStartedActivityForResult()) 327 .isSameInstanceAs(intentForResult); 328 assertThat(intentForResult.intent).isNotNull(); 329 assertThat(intentForResult.intent).isSameInstanceAs(intent); 330 assertThat(intentForResult.requestCode).isEqualTo(142); 331 } 332 333 @Test onContentChangedShouldBeCalledAfterContentViewIsSet()334 public void onContentChangedShouldBeCalledAfterContentViewIsSet() throws RuntimeException { 335 final List<String> transcript = new ArrayList<>(); 336 ActivityWithContentChangedTranscript customActivity = 337 Robolectric.setupActivity(ActivityWithContentChangedTranscript.class); 338 customActivity.setTranscript(transcript); 339 customActivity.setContentView(R.layout.main); 340 assertThat(transcript).containsExactly("onContentChanged was called; title is \"Main Layout\""); 341 } 342 343 @Test shouldRetrievePackageNameFromTheManifest()344 public void shouldRetrievePackageNameFromTheManifest() { 345 assertThat(Robolectric.setupActivity(Activity.class).getPackageName()) 346 .isEqualTo(ApplicationProvider.getApplicationContext().getPackageName()); 347 } 348 349 @Test shouldRunUiTasksImmediatelyByDefault()350 public void shouldRunUiTasksImmediatelyByDefault() { 351 TestRunnable runnable = new TestRunnable(); 352 activity = Robolectric.setupActivity(DialogLifeCycleActivity.class); 353 activity.runOnUiThread(runnable); 354 assertTrue(runnable.wasRun); 355 } 356 357 @Test 358 @LooperMode(LEGACY) shouldQueueUiTasksWhenUiThreadIsPaused()359 public void shouldQueueUiTasksWhenUiThreadIsPaused() { 360 shadowOf(getMainLooper()).pause(); 361 362 activity = Robolectric.setupActivity(DialogLifeCycleActivity.class); 363 TestRunnable runnable = new TestRunnable(); 364 activity.runOnUiThread(runnable); 365 assertFalse(runnable.wasRun); 366 367 shadowOf(getMainLooper()).idle(); 368 assertTrue(runnable.wasRun); 369 } 370 371 /** 372 * The legacy behavior spec-ed in {@link #shouldQueueUiTasksWhenUiThreadIsPaused()} is actually 373 * incorrect. The {@link Activity#runOnUiThread} will execute posted tasks inline. 374 */ 375 @Test 376 @LooperMode(Mode.PAUSED) shouldExecutePostedUiTasksInRealisticLooper()377 public void shouldExecutePostedUiTasksInRealisticLooper() { 378 activity = Robolectric.setupActivity(DialogLifeCycleActivity.class); 379 TestRunnable runnable = new TestRunnable(); 380 activity.runOnUiThread(runnable); 381 assertTrue(runnable.wasRun); 382 } 383 384 @Test showDialog_shouldCreatePrepareAndShowDialog()385 public void showDialog_shouldCreatePrepareAndShowDialog() { 386 final DialogLifeCycleActivity activity = 387 Robolectric.setupActivity(DialogLifeCycleActivity.class); 388 final AtomicBoolean dialogWasShown = new AtomicBoolean(false); 389 390 new Dialog(activity) { 391 { 392 activity.dialog = this; 393 } 394 395 @Override 396 public void show() { 397 dialogWasShown.set(true); 398 } 399 }; 400 401 activity.showDialog(1); 402 403 assertTrue(activity.createdDialog); 404 assertTrue(activity.preparedDialog); 405 assertTrue(dialogWasShown.get()); 406 } 407 408 @Test showDialog_shouldCreatePrepareAndShowDialogWithBundle()409 public void showDialog_shouldCreatePrepareAndShowDialogWithBundle() { 410 final DialogLifeCycleActivity activity = 411 Robolectric.setupActivity(DialogLifeCycleActivity.class); 412 final AtomicBoolean dialogWasShown = new AtomicBoolean(false); 413 414 new Dialog(activity) { 415 { 416 activity.dialog = this; 417 } 418 419 @Override 420 public void show() { 421 dialogWasShown.set(true); 422 } 423 }; 424 425 activity.showDialog(1, new Bundle()); 426 427 assertTrue(activity.createdDialog); 428 assertTrue(activity.preparedDialogWithBundle); 429 assertTrue(dialogWasShown.get()); 430 } 431 432 @Test showDialog_shouldReturnFalseIfDialogDoesNotExist()433 public void showDialog_shouldReturnFalseIfDialogDoesNotExist() { 434 final DialogLifeCycleActivity activity = 435 Robolectric.setupActivity(DialogLifeCycleActivity.class); 436 boolean dialogCreated = activity.showDialog(97, new Bundle()); 437 438 assertThat(dialogCreated).isFalse(); 439 assertThat(activity.createdDialog).isTrue(); 440 assertThat(activity.preparedDialogWithBundle).isFalse(); 441 } 442 443 @Test showDialog_shouldReuseDialogs()444 public void showDialog_shouldReuseDialogs() { 445 final DialogCreatingActivity activity = Robolectric.setupActivity(DialogCreatingActivity.class); 446 activity.showDialog(1); 447 Dialog firstDialog = ShadowDialog.getLatestDialog(); 448 activity.showDialog(1); 449 450 Dialog secondDialog = ShadowDialog.getLatestDialog(); 451 assertSame("dialogs should be the same instance", firstDialog, secondDialog); 452 } 453 454 @Test showDialog_shouldShowDialog()455 public void showDialog_shouldShowDialog() { 456 final DialogCreatingActivity activity = Robolectric.setupActivity(DialogCreatingActivity.class); 457 activity.showDialog(1); 458 Dialog dialog = ShadowDialog.getLatestDialog(); 459 assertTrue(dialog.isShowing()); 460 } 461 462 @Test dismissDialog_shouldDismissPreviouslyShownDialog()463 public void dismissDialog_shouldDismissPreviouslyShownDialog() { 464 final DialogCreatingActivity activity = Robolectric.setupActivity(DialogCreatingActivity.class); 465 activity.showDialog(1); 466 activity.dismissDialog(1); 467 Dialog dialog = ShadowDialog.getLatestDialog(); 468 assertFalse(dialog.isShowing()); 469 } 470 471 @Test dismissDialog_shouldThrowExceptionIfDialogWasNotPreviouslyShown()472 public void dismissDialog_shouldThrowExceptionIfDialogWasNotPreviouslyShown() { 473 final DialogCreatingActivity activity = Robolectric.setupActivity(DialogCreatingActivity.class); 474 try { 475 activity.dismissDialog(1); 476 } catch (Throwable expected) { 477 assertThat(expected).isInstanceOf(IllegalArgumentException.class); 478 } 479 } 480 481 @Test removeDialog_shouldCreateDialogAgain()482 public void removeDialog_shouldCreateDialogAgain() { 483 final DialogCreatingActivity activity = Robolectric.setupActivity(DialogCreatingActivity.class); 484 activity.showDialog(1); 485 Dialog firstDialog = ShadowDialog.getLatestDialog(); 486 487 activity.removeDialog(1); 488 assertNull(shadowOf(activity).getDialogById(1)); 489 490 activity.showDialog(1); 491 Dialog secondDialog = ShadowDialog.getLatestDialog(); 492 493 assertNotSame("dialogs should not be the same instance", firstDialog, secondDialog); 494 } 495 496 @Test shouldCallOnCreateDialogFromShowDialog()497 public void shouldCallOnCreateDialogFromShowDialog() { 498 ActivityWithOnCreateDialog activity = 499 Robolectric.setupActivity(ActivityWithOnCreateDialog.class); 500 activity.showDialog(123); 501 assertTrue(activity.onCreateDialogWasCalled); 502 assertThat(ShadowDialog.getLatestDialog()).isNotNull(); 503 } 504 505 @Test shouldCallFinishInOnBackPressed()506 public void shouldCallFinishInOnBackPressed() { 507 Activity activity = new Activity(); 508 activity.onBackPressed(); 509 510 assertTrue(activity.isFinishing()); 511 } 512 513 @Test shouldCallFinishOnFinishAffinity()514 public void shouldCallFinishOnFinishAffinity() { 515 Activity activity = new Activity(); 516 activity.finishAffinity(); 517 518 assertTrue(activity.isFinishing()); 519 } 520 521 @Test shouldCallFinishOnFinishAndRemoveTask()522 public void shouldCallFinishOnFinishAndRemoveTask() { 523 Activity activity = new Activity(); 524 activity.finishAndRemoveTask(); 525 526 assertTrue(activity.isFinishing()); 527 } 528 529 @Test shouldCallFinishOnFinish()530 public void shouldCallFinishOnFinish() { 531 Activity activity = new Activity(); 532 activity.finish(); 533 534 assertTrue(activity.isFinishing()); 535 } 536 537 @Test shouldSupportCurrentFocus()538 public void shouldSupportCurrentFocus() { 539 activity = Robolectric.setupActivity(DialogLifeCycleActivity.class); 540 541 assertNull(activity.getCurrentFocus()); 542 View view = new View(activity); 543 shadowOf(activity).setCurrentFocus(view); 544 assertEquals(view, activity.getCurrentFocus()); 545 } 546 547 @Test shouldSetOrientation()548 public void shouldSetOrientation() { 549 activity = Robolectric.setupActivity(DialogLifeCycleActivity.class); 550 activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT); 551 assertThat(activity.getRequestedOrientation()) 552 .isEqualTo(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT); 553 } 554 555 @Test setDefaultKeyMode_shouldSetKeyMode()556 public void setDefaultKeyMode_shouldSetKeyMode() { 557 int[] modes = { 558 Activity.DEFAULT_KEYS_DISABLE, 559 Activity.DEFAULT_KEYS_SHORTCUT, 560 Activity.DEFAULT_KEYS_DIALER, 561 Activity.DEFAULT_KEYS_SEARCH_LOCAL, 562 Activity.DEFAULT_KEYS_SEARCH_GLOBAL 563 }; 564 Activity activity = new Activity(); 565 566 for (int mode : modes) { 567 activity.setDefaultKeyMode(mode); 568 assertWithMessage("Unexpected key mode") 569 .that(shadowOf(activity).getDefaultKeymode()) 570 .isEqualTo(mode); 571 } 572 } 573 574 @Test 575 @Config(minSdk = O_MR1) setShowWhenLocked_shouldSetShowWhenLocked()576 public void setShowWhenLocked_shouldSetShowWhenLocked() { 577 try (ActivityController<Activity> controller = Robolectric.buildActivity(Activity.class)) { 578 activity = controller.create().get(); 579 ShadowActivity shadowActivity = shadowOf(activity); 580 assertThat(shadowActivity.getShowWhenLocked()).isFalse(); 581 activity.setShowWhenLocked(true); 582 assertThat(shadowActivity.getShowWhenLocked()).isTrue(); 583 activity.setShowWhenLocked(false); 584 assertThat(shadowActivity.getShowWhenLocked()).isFalse(); 585 } 586 } 587 588 @Test 589 @Config(minSdk = O_MR1) setTurnScreenOn_shouldSetTurnScreenOn()590 public void setTurnScreenOn_shouldSetTurnScreenOn() { 591 try (ActivityController<Activity> controller = Robolectric.buildActivity(Activity.class)) { 592 activity = controller.create().get(); 593 ShadowActivity shadowActivity = shadowOf(activity); 594 assertThat(shadowActivity.getTurnScreenOn()).isFalse(); 595 activity.setTurnScreenOn(true); 596 assertThat(shadowActivity.getTurnScreenOn()).isTrue(); 597 activity.setTurnScreenOn(false); 598 assertThat(shadowActivity.getTurnScreenOn()).isFalse(); 599 } 600 } 601 602 @Test // unclear what the correct behavior should be here... shouldPopulateWindowDecorViewWithMergeLayoutContents()603 public void shouldPopulateWindowDecorViewWithMergeLayoutContents() { 604 try (ActivityController<Activity> controller = Robolectric.buildActivity(Activity.class)) { 605 Activity activity = controller.create().get(); 606 activity.setContentView(R.layout.toplevel_merge); 607 608 View contentView = activity.findViewById(android.R.id.content); 609 assertThat(((ViewGroup) contentView).getChildCount()).isEqualTo(2); 610 } 611 } 612 613 @Test setContentView_shouldReplaceOldContentView()614 public void setContentView_shouldReplaceOldContentView() { 615 View view1 = new View(getApplication()); 616 view1.setId(R.id.burritos); 617 View view2 = new View(getApplication()); 618 view2.setId(R.id.button); 619 620 Activity activity = buildActivity(Activity.class).create().get(); 621 activity.setContentView(view1); 622 assertSame(view1, activity.findViewById(R.id.burritos)); 623 624 activity.setContentView(view2); 625 assertNull(activity.findViewById(R.id.burritos)); 626 assertSame(view2, activity.findViewById(R.id.button)); 627 } 628 629 @Test onKeyUp_callsOnBackPressedWhichFinishesTheActivity()630 public void onKeyUp_callsOnBackPressedWhichFinishesTheActivity() { 631 OnBackPressedActivity activity = buildActivity(OnBackPressedActivity.class).setup().get(); 632 boolean downConsumed = 633 activity.dispatchKeyEvent(new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_BACK)); 634 boolean upConsumed = 635 activity.dispatchKeyEvent(new KeyEvent(KeyEvent.ACTION_UP, KeyEvent.KEYCODE_BACK)); 636 637 assertTrue(downConsumed); 638 assertTrue(upConsumed); 639 assertTrue(activity.onBackPressedCalled); 640 assertTrue(activity.isFinishing()); 641 } 642 643 @Test shouldGiveSharedPreferences()644 public void shouldGiveSharedPreferences() { 645 Activity activity = Robolectric.setupActivity(Activity.class); 646 SharedPreferences preferences = activity.getPreferences(Context.MODE_PRIVATE); 647 assertNotNull(preferences); 648 preferences.edit().putString("foo", "bar").commit(); 649 assertThat(activity.getPreferences(Context.MODE_PRIVATE).getString("foo", null)) 650 .isEqualTo("bar"); 651 } 652 653 @Test shouldFindContentViewContainerWithChild()654 public void shouldFindContentViewContainerWithChild() { 655 Activity activity = buildActivity(Activity.class).create().get(); 656 View contentView = new View(activity); 657 activity.setContentView(contentView); 658 659 FrameLayout contentViewContainer = (FrameLayout) activity.findViewById(android.R.id.content); 660 assertThat(contentViewContainer.getChildAt(0)).isSameInstanceAs(contentView); 661 } 662 663 @Test shouldFindContentViewContainerWithoutChild()664 public void shouldFindContentViewContainerWithoutChild() { 665 Activity activity = buildActivity(Activity.class).create().get(); 666 667 FrameLayout contentViewContainer = (FrameLayout) activity.findViewById(android.R.id.content); 668 assertThat(contentViewContainer.getId()).isEqualTo(android.R.id.content); 669 } 670 671 @Test recreateGoesThroughFullLifeCycle()672 public void recreateGoesThroughFullLifeCycle() { 673 ActivityController<TestActivity> activityController = 674 buildActivity(TestActivity.class).create(); 675 TestActivity oldActivity = activityController.get(); 676 677 // Recreate should create new instance. 678 activityController.recreate(); 679 680 assertThat(activityController.get()).isNotSameInstanceAs(oldActivity); 681 682 assertThat(oldActivity.transcript) 683 .containsExactly( 684 "onCreate", 685 "onStart", 686 "onPostCreate", 687 "onResume", 688 "onPause", 689 "onStop", 690 "onSaveInstanceState", 691 "onRetainNonConfigurationInstance", 692 "onDestroy") 693 .inOrder(); 694 assertThat(activityController.get().transcript) 695 .containsExactly( 696 "onCreate", "onStart", "onRestoreInstanceState", "onPostCreate", "onResume") 697 .inOrder(); 698 } 699 700 @Test recreateBringsBackTheOriginalLifeCycleStateAfterRecreate_resumed()701 public void recreateBringsBackTheOriginalLifeCycleStateAfterRecreate_resumed() { 702 ActivityController<TestActivity> activityController = buildActivity(TestActivity.class).setup(); 703 TestActivity oldActivity = activityController.get(); 704 705 // Recreate the paused activity. 706 activityController.recreate(); 707 708 assertThat(activityController.get()).isNotSameInstanceAs(oldActivity); 709 710 assertThat(oldActivity.transcript) 711 .containsExactly( 712 "onCreate", 713 "onStart", 714 "onPostCreate", 715 "onResume", 716 "onPause", 717 "onStop", 718 "onSaveInstanceState", 719 "onRetainNonConfigurationInstance", 720 "onDestroy") 721 .inOrder(); 722 assertThat(activityController.get().transcript) 723 .containsExactly( 724 "onCreate", "onStart", "onRestoreInstanceState", "onPostCreate", "onResume") 725 .inOrder(); 726 } 727 728 @Test recreateBringsBackTheOriginalLifeCycleStateAfterRecreate_paused()729 public void recreateBringsBackTheOriginalLifeCycleStateAfterRecreate_paused() { 730 ActivityController<TestActivity> activityController = buildActivity(TestActivity.class).setup(); 731 TestActivity oldActivity = activityController.get(); 732 733 // Recreate the paused activity. 734 activityController.pause(); 735 activityController.recreate(); 736 737 assertThat(activityController.get()).isNotSameInstanceAs(oldActivity); 738 739 assertThat(oldActivity.transcript) 740 .containsExactly( 741 "onCreate", 742 "onStart", 743 "onPostCreate", 744 "onResume", 745 "onPause", 746 "onStop", 747 "onSaveInstanceState", 748 "onRetainNonConfigurationInstance", 749 "onDestroy") 750 .inOrder(); 751 assertThat(activityController.get().transcript) 752 .containsExactly( 753 "onCreate", "onStart", "onRestoreInstanceState", "onPostCreate", "onResume", "onPause") 754 .inOrder(); 755 } 756 757 @Test recreateBringsBackTheOriginalLifeCycleStateAfterRecreate_stopped()758 public void recreateBringsBackTheOriginalLifeCycleStateAfterRecreate_stopped() { 759 ActivityController<TestActivity> activityController = buildActivity(TestActivity.class).setup(); 760 TestActivity oldActivity = activityController.get(); 761 762 // Recreate the stopped activity. 763 activityController.pause().stop(); 764 activityController.recreate(); 765 766 assertThat(activityController.get()).isNotSameInstanceAs(oldActivity); 767 768 assertThat(oldActivity.transcript) 769 .containsExactly( 770 "onCreate", 771 "onStart", 772 "onPostCreate", 773 "onResume", 774 "onPause", 775 "onStop", 776 "onSaveInstanceState", 777 "onRetainNonConfigurationInstance", 778 "onDestroy") 779 .inOrder(); 780 assertThat(activityController.get().transcript) 781 .containsExactly( 782 "onCreate", 783 "onStart", 784 "onRestoreInstanceState", 785 "onPostCreate", 786 "onResume", 787 "onPause", 788 "onStop") 789 .inOrder(); 790 } 791 792 @Test startAndStopManagingCursorTracksCursors()793 public void startAndStopManagingCursorTracksCursors() { 794 TestActivity activity = new TestActivity(); 795 796 assertThat(shadowOf(activity).getManagedCursors()).isNotNull(); 797 assertThat(shadowOf(activity).getManagedCursors()).isEmpty(); 798 799 Cursor c = new MatrixCursor(new String[] {"a"}); 800 activity.startManagingCursor(c); 801 802 assertThat(shadowOf(activity).getManagedCursors()).isNotNull(); 803 assertThat(shadowOf(activity).getManagedCursors()).hasSize(1); 804 assertThat(shadowOf(activity).getManagedCursors().get(0)).isSameInstanceAs(c); 805 806 activity.stopManagingCursor(c); 807 808 assertThat(shadowOf(activity).getManagedCursors()).isNotNull(); 809 assertThat(shadowOf(activity).getManagedCursors()).isEmpty(); 810 c.close(); 811 } 812 813 @Test setVolumeControlStream_setsTheSpecifiedStreamType()814 public void setVolumeControlStream_setsTheSpecifiedStreamType() { 815 TestActivity activity = new TestActivity(); 816 activity.setVolumeControlStream(AudioManager.STREAM_ALARM); 817 assertThat(activity.getVolumeControlStream()).isEqualTo(AudioManager.STREAM_ALARM); 818 } 819 820 @Test decorViewSizeEqualToDisplaySize()821 public void decorViewSizeEqualToDisplaySize() { 822 Activity activity = buildActivity(Activity.class).create().visible().get(); 823 View decorView = activity.getWindow().getDecorView(); 824 assertThat(decorView).isNotEqualTo(null); 825 ViewRootImpl root = decorView.getViewRootImpl(); 826 assertThat(root).isNotEqualTo(null); 827 assertThat(decorView.getWidth()).isNotEqualTo(0); 828 assertThat(decorView.getHeight()).isNotEqualTo(0); 829 Display display = ShadowDisplay.getDefaultDisplay(); 830 assertThat(decorView.getWidth()).isEqualTo(display.getWidth()); 831 assertThat(decorView.getHeight()).isEqualTo(display.getHeight()); 832 } 833 834 @Test 835 @Config(minSdk = M) requestsPermissions()836 public void requestsPermissions() { 837 TestActivity activity = Robolectric.setupActivity(TestActivity.class); 838 activity.requestPermissions(new String[] {Manifest.permission.CAMERA}, 1007); 839 } 840 841 private static class TestActivity extends Activity { 842 List<String> transcript = new ArrayList<>(); 843 844 private boolean isRecreating = false; 845 private boolean returnMalformedDirectAction = false; 846 847 @Override onSaveInstanceState(Bundle outState)848 public void onSaveInstanceState(Bundle outState) { 849 isRecreating = true; 850 transcript.add("onSaveInstanceState"); 851 outState.putString("TestActivityKey", "TestActivityValue"); 852 super.onSaveInstanceState(outState); 853 } 854 855 @Override onRestoreInstanceState(Bundle savedInstanceState)856 public void onRestoreInstanceState(Bundle savedInstanceState) { 857 transcript.add("onRestoreInstanceState"); 858 assertTrue(savedInstanceState.containsKey("TestActivityKey")); 859 assertEquals("TestActivityValue", savedInstanceState.getString("TestActivityKey")); 860 super.onRestoreInstanceState(savedInstanceState); 861 } 862 863 @Override onRetainNonConfigurationInstance()864 public Object onRetainNonConfigurationInstance() { 865 transcript.add("onRetainNonConfigurationInstance"); 866 return 5; 867 } 868 869 @Override onPause()870 public void onPause() { 871 transcript.add("onPause"); 872 super.onPause(); 873 } 874 875 @Override onDestroy()876 public void onDestroy() { 877 transcript.add("onDestroy"); 878 super.onDestroy(); 879 } 880 881 @Override onCreate(Bundle savedInstanceState)882 public void onCreate(Bundle savedInstanceState) { 883 transcript.add("onCreate"); 884 885 if (isRecreating) { 886 assertTrue(savedInstanceState.containsKey("TestActivityKey")); 887 assertEquals("TestActivityValue", savedInstanceState.getString("TestActivityKey")); 888 } 889 890 super.onCreate(savedInstanceState); 891 } 892 893 @Override onStart()894 public void onStart() { 895 transcript.add("onStart"); 896 super.onStart(); 897 } 898 899 @Override onPostCreate(Bundle savedInstanceState)900 public void onPostCreate(Bundle savedInstanceState) { 901 transcript.add("onPostCreate"); 902 super.onPostCreate(savedInstanceState); 903 } 904 905 @Override onStop()906 public void onStop() { 907 transcript.add("onStop"); 908 super.onStop(); 909 } 910 911 @Override onRestart()912 public void onRestart() { 913 transcript.add("onRestart"); 914 super.onRestart(); 915 } 916 917 @Override onResume()918 public void onResume() { 919 transcript.add("onResume"); 920 super.onResume(); 921 } 922 setReturnMalformedDirectAction(boolean returnMalformedDirectAction)923 void setReturnMalformedDirectAction(boolean returnMalformedDirectAction) { 924 this.returnMalformedDirectAction = returnMalformedDirectAction; 925 } 926 getDirectActionForTesting()927 DirectAction getDirectActionForTesting() { 928 Bundle extras = new Bundle(); 929 extras.putParcelable("componentName", this.getComponentName()); 930 return new DirectAction.Builder("testDirectAction") 931 .setExtras(extras) 932 .setLocusId(new LocusId("unused")) 933 .build(); 934 } 935 getMalformedDirectAction()936 DirectAction getMalformedDirectAction() { 937 return new DirectAction.Builder("malformedDirectAction").build(); 938 } 939 940 @Override onGetDirectActions( CancellationSignal cancellationSignal, Consumer<List<DirectAction>> callback)941 public void onGetDirectActions( 942 CancellationSignal cancellationSignal, Consumer<List<DirectAction>> callback) { 943 if (returnMalformedDirectAction) { 944 callback.accept(Collections.singletonList(getMalformedDirectAction())); 945 } else { 946 callback.accept(Collections.singletonList(getDirectActionForTesting())); 947 } 948 } 949 } 950 951 @Test getAndSetParentActivity_shouldWorkForTestingPurposes()952 public void getAndSetParentActivity_shouldWorkForTestingPurposes() { 953 Activity parentActivity = new Activity(); 954 Activity activity = new Activity(); 955 shadowOf(activity).setParent(parentActivity); 956 assertSame(parentActivity, activity.getParent()); 957 } 958 959 @Test getAndSetRequestedOrientation_shouldRemember()960 public void getAndSetRequestedOrientation_shouldRemember() { 961 Activity activity = new Activity(); 962 activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT); 963 assertEquals(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT, activity.getRequestedOrientation()); 964 } 965 966 @Test getAndSetRequestedOrientation_shouldDelegateToParentIfPresent()967 public void getAndSetRequestedOrientation_shouldDelegateToParentIfPresent() { 968 Activity parentActivity = new Activity(); 969 Activity activity = new Activity(); 970 shadowOf(activity).setParent(parentActivity); 971 parentActivity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT); 972 assertEquals(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT, activity.getRequestedOrientation()); 973 activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE); 974 assertEquals( 975 ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE, 976 parentActivity.getRequestedOrientation()); 977 } 978 979 @Test shouldSupportIsTaskRoot()980 public void shouldSupportIsTaskRoot() { 981 Activity activity = Robolectric.setupActivity(Activity.class); 982 assertTrue( 983 activity.isTaskRoot()); // as implemented, Activities are considered task roots by default 984 985 shadowOf(activity).setIsTaskRoot(false); 986 assertFalse(activity.isTaskRoot()); 987 } 988 989 @Test 990 @Config(minSdk = N) shouldSupportIsInMultiWindowMode()991 public void shouldSupportIsInMultiWindowMode() { 992 Activity activity = Robolectric.setupActivity(Activity.class); 993 994 assertThat(activity.isInMultiWindowMode()) 995 .isFalse(); // Activity is not in multi window mode by default. 996 shadowOf(activity).setInMultiWindowMode(true); 997 998 assertThat(activity.isInMultiWindowMode()).isTrue(); 999 } 1000 1001 @Test getPendingTransitionEnterAnimationResourceId_should()1002 public void getPendingTransitionEnterAnimationResourceId_should() { 1003 Activity activity = Robolectric.setupActivity(Activity.class); 1004 activity.overridePendingTransition(15, 2); 1005 assertThat(shadowOf(activity).getPendingTransitionEnterAnimationResourceId()).isEqualTo(15); 1006 } 1007 1008 @Test getPendingTransitionExitAnimationResourceId_should()1009 public void getPendingTransitionExitAnimationResourceId_should() { 1010 Activity activity = Robolectric.setupActivity(Activity.class); 1011 activity.overridePendingTransition(15, 2); 1012 assertThat(shadowOf(activity).getPendingTransitionExitAnimationResourceId()).isEqualTo(2); 1013 } 1014 1015 @Test 1016 @Config(minSdk = UPSIDE_DOWN_CAKE) getOverriddenActivityTransitionOpen_withoutBackgroundColor()1017 public void getOverriddenActivityTransitionOpen_withoutBackgroundColor() { 1018 try (ActivityController<Activity> controller = buildActivity(Activity.class).setup()) { 1019 Activity activity = controller.get(); 1020 activity.overrideActivityTransition(Activity.OVERRIDE_TRANSITION_OPEN, 15, 2); 1021 ShadowActivity.OverriddenActivityTransition overriddenActivityTransition = 1022 shadowOf(activity).getOverriddenActivityTransition(Activity.OVERRIDE_TRANSITION_OPEN); 1023 1024 assertThat(overriddenActivityTransition).isNotNull(); 1025 assertThat(overriddenActivityTransition.enterAnim).isEqualTo(15); 1026 assertThat(overriddenActivityTransition.exitAnim).isEqualTo(2); 1027 assertThat(overriddenActivityTransition.backgroundColor).isEqualTo(Color.TRANSPARENT); 1028 } 1029 } 1030 1031 @Test 1032 @Config(minSdk = UPSIDE_DOWN_CAKE) getOverriddenActivityTransitionClose_withoutBackgroundColor()1033 public void getOverriddenActivityTransitionClose_withoutBackgroundColor() { 1034 try (ActivityController<Activity> controller = buildActivity(Activity.class).setup()) { 1035 Activity activity = controller.get(); 1036 ShadowActivity shadowActivity = shadowOf(activity); 1037 activity.overrideActivityTransition(Activity.OVERRIDE_TRANSITION_CLOSE, 15, 2); 1038 ShadowActivity.OverriddenActivityTransition overriddenActivityTransition = 1039 shadowActivity.getOverriddenActivityTransition(Activity.OVERRIDE_TRANSITION_CLOSE); 1040 1041 assertThat(overriddenActivityTransition).isNotNull(); 1042 assertThat(overriddenActivityTransition.enterAnim).isEqualTo(15); 1043 assertThat(overriddenActivityTransition.exitAnim).isEqualTo(2); 1044 assertThat(overriddenActivityTransition.backgroundColor).isEqualTo(Color.TRANSPARENT); 1045 } 1046 } 1047 1048 @Test 1049 @Config(minSdk = UPSIDE_DOWN_CAKE) getOverriddenActivityTransitionOpen_withBackgroundColor()1050 public void getOverriddenActivityTransitionOpen_withBackgroundColor() { 1051 try (ActivityController<Activity> controller = buildActivity(Activity.class).setup()) { 1052 Activity activity = controller.get(); 1053 activity.overrideActivityTransition(Activity.OVERRIDE_TRANSITION_OPEN, 33, 12, Color.RED); 1054 ShadowActivity.OverriddenActivityTransition overriddenActivityTransition = 1055 shadowOf(activity).getOverriddenActivityTransition(Activity.OVERRIDE_TRANSITION_OPEN); 1056 1057 assertThat(overriddenActivityTransition).isNotNull(); 1058 assertThat(overriddenActivityTransition.enterAnim).isEqualTo(33); 1059 assertThat(overriddenActivityTransition.exitAnim).isEqualTo(12); 1060 assertThat(overriddenActivityTransition.backgroundColor).isEqualTo(Color.RED); 1061 } 1062 } 1063 1064 @Test 1065 @Config(minSdk = UPSIDE_DOWN_CAKE) getOverriddenActivityTransitionClose_withBackgroundColor()1066 public void getOverriddenActivityTransitionClose_withBackgroundColor() { 1067 try (ActivityController<Activity> controller = buildActivity(Activity.class).setup()) { 1068 Activity activity = controller.get(); 1069 ShadowActivity shadowActivity = shadowOf(activity); 1070 activity.overrideActivityTransition(Activity.OVERRIDE_TRANSITION_CLOSE, 33, 12, Color.RED); 1071 ShadowActivity.OverriddenActivityTransition overriddenActivityTransition = 1072 shadowActivity.getOverriddenActivityTransition(Activity.OVERRIDE_TRANSITION_CLOSE); 1073 1074 assertThat(overriddenActivityTransition).isNotNull(); 1075 assertThat(overriddenActivityTransition.enterAnim).isEqualTo(33); 1076 assertThat(overriddenActivityTransition.exitAnim).isEqualTo(12); 1077 assertThat(overriddenActivityTransition.backgroundColor).isEqualTo(Color.RED); 1078 } 1079 } 1080 1081 @Test 1082 @Config(minSdk = UPSIDE_DOWN_CAKE) getOverriddenActivityTransition_invalidType()1083 public void getOverriddenActivityTransition_invalidType() { 1084 try (ActivityController<Activity> controller = buildActivity(Activity.class).setup()) { 1085 Activity activity = controller.get(); 1086 activity.overrideActivityTransition(Activity.OVERRIDE_TRANSITION_CLOSE, 33, 12, Color.RED); 1087 ShadowActivity.OverriddenActivityTransition overriddenActivityTransition = 1088 shadowOf(activity).getOverriddenActivityTransition(-1); 1089 assertThat(overriddenActivityTransition).isNull(); 1090 } 1091 } 1092 1093 @Test 1094 @Config(minSdk = UPSIDE_DOWN_CAKE) getOverriddenActivityTransition_beforeOverridingOrAfterClearing()1095 public void getOverriddenActivityTransition_beforeOverridingOrAfterClearing() { 1096 try (ActivityController<Activity> controller = buildActivity(Activity.class).setup()) { 1097 Activity activity = controller.get(); 1098 ShadowActivity shadowActivity = shadowOf(activity); 1099 1100 assertThat(shadowActivity.getOverriddenActivityTransition(Activity.OVERRIDE_TRANSITION_OPEN)) 1101 .isNull(); 1102 1103 assertThat(shadowActivity.getOverriddenActivityTransition(Activity.OVERRIDE_TRANSITION_CLOSE)) 1104 .isNull(); 1105 1106 activity.overrideActivityTransition(Activity.OVERRIDE_TRANSITION_OPEN, 12, 33); 1107 activity.overrideActivityTransition(Activity.OVERRIDE_TRANSITION_CLOSE, 33, 12); 1108 activity.clearOverrideActivityTransition(Activity.OVERRIDE_TRANSITION_OPEN); 1109 activity.clearOverrideActivityTransition(Activity.OVERRIDE_TRANSITION_CLOSE); 1110 1111 assertThat(shadowActivity.getOverriddenActivityTransition(Activity.OVERRIDE_TRANSITION_OPEN)) 1112 .isNull(); 1113 1114 assertThat(shadowActivity.getOverriddenActivityTransition(Activity.OVERRIDE_TRANSITION_CLOSE)) 1115 .isNull(); 1116 } 1117 } 1118 1119 @Test getActionBar_shouldWorkIfActivityHasAnAppropriateTheme()1120 public void getActionBar_shouldWorkIfActivityHasAnAppropriateTheme() { 1121 try (ActivityController<ActionBarThemedActivity> controller = 1122 Robolectric.buildActivity(ActionBarThemedActivity.class)) { 1123 ActionBarThemedActivity myActivity = controller.create().get(); 1124 ActionBar actionBar = myActivity.getActionBar(); 1125 assertThat(actionBar).isNotNull(); 1126 } 1127 } 1128 1129 public static class ActionBarThemedActivity extends Activity { 1130 1131 @Override onCreate(Bundle savedInstanceState)1132 protected void onCreate(Bundle savedInstanceState) { 1133 super.onCreate(savedInstanceState); 1134 setTheme(android.R.style.Theme_Holo_Light); 1135 setContentView(new LinearLayout(this)); 1136 } 1137 } 1138 1139 @Test canGetOptionsMenu()1140 public void canGetOptionsMenu() { 1141 Activity activity = buildActivity(OptionsMenuActivity.class).create().visible().get(); 1142 Menu optionsMenu = shadowOf(activity).getOptionsMenu(); 1143 assertThat(optionsMenu).isNotNull(); 1144 assertThat(optionsMenu.getItem(0).getTitle().toString()).isEqualTo("Algebraic!"); 1145 } 1146 1147 @Test canGetOptionsMenuWithActionMenu()1148 public void canGetOptionsMenuWithActionMenu() { 1149 ActionMenuActivity activity = buildActivity(ActionMenuActivity.class).create().visible().get(); 1150 1151 SearchView searchView = activity.mSearchView; 1152 // This blows up when ShadowPopupMenu existed. 1153 searchView.setIconifiedByDefault(false); 1154 } 1155 1156 @Test canStartActivityFromFragment()1157 public void canStartActivityFromFragment() { 1158 final Activity activity = Robolectric.setupActivity(Activity.class); 1159 1160 Intent intent = new Intent(Intent.ACTION_VIEW); 1161 activity.startActivityFromFragment(new Fragment(), intent, 4); 1162 1163 ShadowActivity.IntentForResult intentForResult = 1164 shadowOf(activity).getNextStartedActivityForResult(); 1165 assertThat(intentForResult.intent).isSameInstanceAs(intent); 1166 assertThat(intentForResult.requestCode).isEqualTo(4); 1167 } 1168 1169 @Test canStartActivityFromFragment_withBundle()1170 public void canStartActivityFromFragment_withBundle() { 1171 final Activity activity = buildActivity(Activity.class).create().get(); 1172 1173 Bundle options = new Bundle(); 1174 Intent intent = new Intent(Intent.ACTION_VIEW); 1175 activity.startActivityFromFragment(new Fragment(), intent, 5, options); 1176 1177 ShadowActivity.IntentForResult intentForResult = 1178 shadowOf(activity).getNextStartedActivityForResult(); 1179 assertThat(intentForResult.intent).isSameInstanceAs(intent); 1180 assertThat(intentForResult.options).isSameInstanceAs(options); 1181 assertThat(intentForResult.requestCode).isEqualTo(5); 1182 } 1183 1184 @Test shouldUseAnimationOverride()1185 public void shouldUseAnimationOverride() { 1186 Activity activity = Robolectric.setupActivity(Activity.class); 1187 Intent intent = new Intent(activity, OptionsMenuActivity.class); 1188 1189 Bundle animationBundle = 1190 ActivityOptions.makeCustomAnimation(activity, R.anim.test_anim_1, R.anim.test_anim_1) 1191 .toBundle(); 1192 activity.startActivity(intent, animationBundle); 1193 assertThat(shadowOf(activity).getNextStartedActivityForResult().options) 1194 .isSameInstanceAs(animationBundle); 1195 } 1196 1197 @Test shouldCallActivityLifecycleCallbacks()1198 public void shouldCallActivityLifecycleCallbacks() { 1199 final List<String> transcript = new ArrayList<>(); 1200 final ActivityController<Activity> controller = buildActivity(Activity.class); 1201 Application applicationContext = ApplicationProvider.getApplicationContext(); 1202 applicationContext.registerActivityLifecycleCallbacks( 1203 new ActivityLifecycleCallbacks(transcript)); 1204 1205 controller.create(); 1206 assertThat(transcript).containsExactly("onActivityCreated"); 1207 transcript.clear(); 1208 1209 controller.start(); 1210 assertThat(transcript).containsExactly("onActivityStarted"); 1211 transcript.clear(); 1212 1213 controller.resume(); 1214 assertThat(transcript).containsExactly("onActivityResumed"); 1215 transcript.clear(); 1216 1217 controller.saveInstanceState(new Bundle()); 1218 assertThat(transcript).containsExactly("onActivitySaveInstanceState"); 1219 transcript.clear(); 1220 1221 controller.pause(); 1222 assertThat(transcript).containsExactly("onActivityPaused"); 1223 transcript.clear(); 1224 1225 controller.stop(); 1226 assertThat(transcript).containsExactly("onActivityStopped"); 1227 transcript.clear(); 1228 1229 controller.destroy(); 1230 assertThat(transcript).containsExactly("onActivityDestroyed"); 1231 } 1232 1233 /** Activity for testing */ 1234 public static class ChildActivity extends Activity {} 1235 1236 /** Activity for testing */ 1237 public static class ParentActivity extends Activity {} 1238 1239 @Test getParentActivityIntent()1240 public void getParentActivityIntent() { 1241 Activity activity = setupActivity(ChildActivity.class); 1242 1243 assertThat(activity.getParentActivityIntent().getComponent().getClassName()) 1244 .isEqualTo(ParentActivity.class.getName()); 1245 } 1246 1247 @Test getCallingActivity_defaultsToNull()1248 public void getCallingActivity_defaultsToNull() { 1249 Activity activity = Robolectric.setupActivity(Activity.class); 1250 1251 assertNull(activity.getCallingActivity()); 1252 } 1253 1254 @Test getCallingActivity_returnsSetValue()1255 public void getCallingActivity_returnsSetValue() { 1256 Activity activity = Robolectric.setupActivity(Activity.class); 1257 ComponentName componentName = new ComponentName("com.example.package", "SomeActivity"); 1258 1259 shadowOf(activity).setCallingActivity(componentName); 1260 1261 assertEquals(componentName, activity.getCallingActivity()); 1262 } 1263 1264 @Test getCallingActivity_returnsValueSetInPackage()1265 public void getCallingActivity_returnsValueSetInPackage() { 1266 Activity activity = Robolectric.setupActivity(Activity.class); 1267 String packageName = "com.example.package"; 1268 1269 shadowOf(activity).setCallingPackage(packageName); 1270 1271 assertEquals(packageName, activity.getCallingActivity().getPackageName()); 1272 } 1273 1274 @Test getCallingActivity_notOverwrittenByPackage()1275 public void getCallingActivity_notOverwrittenByPackage() { 1276 Activity activity = Robolectric.setupActivity(Activity.class); 1277 ComponentName componentName = new ComponentName("com.example.package", "SomeActivity"); 1278 1279 shadowOf(activity).setCallingActivity(componentName); 1280 shadowOf(activity).setCallingPackage(componentName.getPackageName()); 1281 1282 assertEquals(componentName, activity.getCallingActivity()); 1283 } 1284 1285 @Test getCallingPackage_defaultsToNull()1286 public void getCallingPackage_defaultsToNull() { 1287 Activity activity = Robolectric.setupActivity(Activity.class); 1288 1289 assertNull(activity.getCallingPackage()); 1290 } 1291 1292 @Test getCallingPackage_returnsSetValue()1293 public void getCallingPackage_returnsSetValue() { 1294 Activity activity = Robolectric.setupActivity(Activity.class); 1295 String packageName = "com.example.package"; 1296 1297 shadowOf(activity).setCallingPackage(packageName); 1298 1299 assertEquals(packageName, activity.getCallingPackage()); 1300 } 1301 1302 @Test getCallingPackage_returnsValueSetInActivity()1303 public void getCallingPackage_returnsValueSetInActivity() { 1304 Activity activity = Robolectric.setupActivity(Activity.class); 1305 ComponentName componentName = new ComponentName("com.example.package", "SomeActivity"); 1306 1307 shadowOf(activity).setCallingActivity(componentName); 1308 1309 assertEquals(componentName.getPackageName(), activity.getCallingPackage()); 1310 } 1311 1312 @Test lockTask()1313 public void lockTask() { 1314 Activity activity = Robolectric.setupActivity(Activity.class); 1315 1316 assertThat(shadowOf(activity).isLockTask()).isFalse(); 1317 1318 activity.startLockTask(); 1319 assertThat(shadowOf(activity).isLockTask()).isTrue(); 1320 1321 activity.stopLockTask(); 1322 assertThat(shadowOf(activity).isLockTask()).isFalse(); 1323 } 1324 1325 @Test 1326 @Config(minSdk = M) getPermission_shouldReturnRequestedPermissions()1327 public void getPermission_shouldReturnRequestedPermissions() { 1328 // GIVEN 1329 String[] permission = {Manifest.permission.CAMERA}; 1330 int requestCode = 1007; 1331 Activity activity = Robolectric.setupActivity(Activity.class); 1332 1333 // WHEN 1334 activity.requestPermissions(permission, requestCode); 1335 1336 // THEN 1337 ShadowActivity.PermissionsRequest request = shadowOf(activity).getLastRequestedPermission(); 1338 assertThat(request.requestCode).isEqualTo(requestCode); 1339 assertThat(request.requestedPermissions).isEqualTo(permission); 1340 } 1341 1342 @Test getLastIntentSenderRequest()1343 public void getLastIntentSenderRequest() throws IntentSender.SendIntentException { 1344 Activity activity = Robolectric.setupActivity(Activity.class); 1345 int requestCode = 108; 1346 Intent intent = new Intent("action"); 1347 Intent fillInIntent = new Intent(); 1348 PendingIntent pendingIntent = PendingIntent.getActivity(systemContext, requestCode, intent, 0); 1349 1350 Bundle options = new Bundle(); 1351 int flagsMask = 1; 1352 int flagsValues = 2; 1353 int extraFlags = 3; 1354 IntentSender intentSender = pendingIntent.getIntentSender(); 1355 activity.startIntentSenderForResult( 1356 intentSender, requestCode, fillInIntent, flagsMask, flagsValues, extraFlags, options); 1357 1358 IntentSenderRequest lastIntentSenderRequest = shadowOf(activity).getLastIntentSenderRequest(); 1359 assertThat(lastIntentSenderRequest.intentSender).isEqualTo(intentSender); 1360 assertThat(lastIntentSenderRequest.fillInIntent).isEqualTo(fillInIntent); 1361 assertThat(lastIntentSenderRequest.requestCode).isEqualTo(requestCode); 1362 assertThat(lastIntentSenderRequest.flagsMask).isEqualTo(flagsMask); 1363 assertThat(lastIntentSenderRequest.flagsValues).isEqualTo(flagsValues); 1364 assertThat(lastIntentSenderRequest.extraFlags).isEqualTo(extraFlags); 1365 assertThat(lastIntentSenderRequest.options).isEqualTo(options); 1366 } 1367 1368 @Test getLastIntentSenderRequest_sendWithRequestCode()1369 public void getLastIntentSenderRequest_sendWithRequestCode() 1370 throws IntentSender.SendIntentException { 1371 TranscriptActivity activity = Robolectric.setupActivity(TranscriptActivity.class); 1372 int requestCode = 108; 1373 Intent intent = new Intent("action"); 1374 Intent fillInIntent = new Intent(); 1375 PendingIntent pendingIntent = 1376 PendingIntent.getActivity(getApplication(), requestCode, intent, 0); 1377 1378 IntentSender intentSender = pendingIntent.getIntentSender(); 1379 activity.startIntentSenderForResult(intentSender, requestCode, fillInIntent, 0, 0, 0, null); 1380 1381 shadowOf(activity).receiveResult(intent, Activity.RESULT_OK, intent); 1382 assertThat(activity.transcript) 1383 .containsExactly( 1384 "onActivityResult called with requestCode 108, resultCode -1, intent data null"); 1385 } 1386 1387 @Test startIntentSenderForResult_throwsException()1388 public void startIntentSenderForResult_throwsException() { 1389 Activity activity = Robolectric.setupActivity(Activity.class); 1390 shadowOf(activity).setThrowIntentSenderException(true); 1391 IntentSender intentSender = 1392 PendingIntent.getActivity(systemContext, 0, new Intent("action"), 0).getIntentSender(); 1393 1394 try { 1395 activity.startIntentSenderForResult(intentSender, 0, null, 0, 0, 0); 1396 fail("An IntentSender.SendIntentException should have been thrown"); 1397 } catch (IntentSender.SendIntentException e) { 1398 // NOP 1399 } 1400 } 1401 1402 @Test reportFullyDrawn_reported()1403 public void reportFullyDrawn_reported() { 1404 Activity activity = Robolectric.setupActivity(Activity.class); 1405 activity.reportFullyDrawn(); 1406 assertThat(shadowOf(activity).getReportFullyDrawn()).isTrue(); 1407 } 1408 1409 @Test 1410 @Config(minSdk = N) enterPip()1411 public void enterPip() { 1412 Activity activity = Robolectric.setupActivity(Activity.class); 1413 assertThat(activity.isInPictureInPictureMode()).isFalse(); 1414 activity.enterPictureInPictureMode(); 1415 assertThat(activity.isInPictureInPictureMode()).isTrue(); 1416 activity.moveTaskToBack(false); 1417 assertThat(activity.isInPictureInPictureMode()).isFalse(); 1418 } 1419 1420 @Test 1421 @Config(minSdk = O) enterPipWithParams()1422 public void enterPipWithParams() { 1423 Activity activity = Robolectric.setupActivity(Activity.class); 1424 assertThat(activity.isInPictureInPictureMode()).isFalse(); 1425 activity.enterPictureInPictureMode(new PictureInPictureParams.Builder().build()); 1426 assertThat(activity.isInPictureInPictureMode()).isTrue(); 1427 } 1428 1429 @Test 1430 @Config(minSdk = N) initializeVoiceInteractor_succeeds()1431 public void initializeVoiceInteractor_succeeds() { 1432 Activity activity = Robolectric.setupActivity(Activity.class); 1433 shadowOf(activity).initializeVoiceInteractor(); 1434 assertThat(activity.getVoiceInteractor()).isNotNull(); 1435 } 1436 1437 @Test 1438 @Config(minSdk = O) buildActivity_noOptionsBundle_launchesOnDefaultDisplay()1439 public void buildActivity_noOptionsBundle_launchesOnDefaultDisplay() { 1440 try (ActivityController<Activity> controller = 1441 Robolectric.buildActivity(Activity.class, null)) { 1442 Activity activity = controller.setup().get(); 1443 1444 assertThat(activity.getWindowManager().getDefaultDisplay().getDisplayId()) 1445 .isEqualTo(Display.DEFAULT_DISPLAY); 1446 } 1447 } 1448 1449 @Test 1450 @Config(minSdk = O) buildActivity_optionBundleWithNoDisplaySet_launchesOnDefaultDisplay()1451 public void buildActivity_optionBundleWithNoDisplaySet_launchesOnDefaultDisplay() { 1452 try (ActivityController<Activity> controller = 1453 Robolectric.buildActivity(Activity.class, null, ActivityOptions.makeBasic().toBundle())) { 1454 Activity activity = controller.setup().get(); 1455 1456 assertThat(activity.getWindowManager().getDefaultDisplay().getDisplayId()) 1457 .isEqualTo(Display.DEFAULT_DISPLAY); 1458 } 1459 } 1460 1461 @Test 1462 @Config(minSdk = O) buildActivity_optionBundleWithDefaultDisplaySet_launchesOnDefaultDisplay()1463 public void buildActivity_optionBundleWithDefaultDisplaySet_launchesOnDefaultDisplay() { 1464 try (ActivityController<Activity> controller = 1465 Robolectric.buildActivity( 1466 Activity.class, 1467 null, 1468 ActivityOptions.makeBasic().setLaunchDisplayId(Display.DEFAULT_DISPLAY).toBundle())) { 1469 Activity activity = controller.setup().get(); 1470 assertThat(activity.getWindowManager().getDefaultDisplay().getDisplayId()) 1471 .isEqualTo(Display.DEFAULT_DISPLAY); 1472 } 1473 } 1474 1475 @Test 1476 @Config(minSdk = O) buildActivity_optionBundleWithValidNonDefaultDisplaySet_launchesOnSpecifiedDisplay()1477 public void buildActivity_optionBundleWithValidNonDefaultDisplaySet_launchesOnSpecifiedDisplay() { 1478 int displayId = ShadowDisplayManager.addDisplay(""); 1479 try (ActivityController<Activity> controller = 1480 Robolectric.buildActivity( 1481 Activity.class, 1482 null, 1483 ActivityOptions.makeBasic().setLaunchDisplayId(displayId).toBundle())) { 1484 Activity activity = controller.setup().get(); 1485 assertThat(activity.getWindowManager().getDefaultDisplay().getDisplayId()) 1486 .isNotEqualTo(Display.DEFAULT_DISPLAY); 1487 assertThat(activity.getWindowManager().getDefaultDisplay().getDisplayId()) 1488 .isEqualTo(displayId); 1489 } 1490 } 1491 1492 @Test 1493 @Config(minSdk = O) buildActivity_optionBundleWithInvalidNonDefaultDisplaySet_launchesOnDefaultDisplay()1494 public void buildActivity_optionBundleWithInvalidNonDefaultDisplaySet_launchesOnDefaultDisplay() { 1495 try (ActivityController<Activity> controller = 1496 Robolectric.buildActivity( 1497 Activity.class, null, ActivityOptions.makeBasic().setLaunchDisplayId(123).toBundle())) { 1498 Activity activity = controller.setup().get(); 1499 assertThat(activity.getWindowManager().getDefaultDisplay().getDisplayId()) 1500 .isEqualTo(Display.DEFAULT_DISPLAY); 1501 } 1502 } 1503 1504 @Test 1505 @Config(minSdk = Q) callOnGetDirectActions_succeeds()1506 public void callOnGetDirectActions_succeeds() { 1507 try (ActivityController<TestActivity> controller = 1508 Robolectric.buildActivity(TestActivity.class)) { 1509 TestActivity testActivity = controller.setup().get(); 1510 Consumer<List<DirectAction>> testConsumer = 1511 (directActions) -> { 1512 assertThat(directActions.size()).isEqualTo(1); 1513 DirectAction action = directActions.get(0); 1514 assertThat(action.getId()).isEqualTo(testActivity.getDirectActionForTesting().getId()); 1515 ComponentName componentName = action.getExtras().getParcelable("componentName"); 1516 assertThat(componentName.compareTo(testActivity.getComponentName())).isEqualTo(0); 1517 }; 1518 shadowOf(testActivity).callOnGetDirectActions(new CancellationSignal(), testConsumer); 1519 } 1520 } 1521 1522 @Test 1523 @Config(minSdk = Q) callOnGetDirectActions_malformedDirectAction_fails()1524 public void callOnGetDirectActions_malformedDirectAction_fails() { 1525 try (ActivityController<TestActivity> controller = 1526 Robolectric.buildActivity(TestActivity.class)) { 1527 TestActivity testActivity = controller.setup().get(); 1528 // malformed DirectAction has missing LocusId 1529 testActivity.setReturnMalformedDirectAction(true); 1530 assertThrows( 1531 NullPointerException.class, 1532 () -> { 1533 shadowOf(testActivity).callOnGetDirectActions(new CancellationSignal(), (unused) -> {}); 1534 }); 1535 } 1536 } 1537 1538 @Test 1539 @Config(minSdk = S) splashScreen_setThemeId_succeeds()1540 public void splashScreen_setThemeId_succeeds() { 1541 int splashScreenThemeId = 173; 1542 try (ActivityController<Activity> controller = Robolectric.buildActivity(Activity.class)) { 1543 Activity activity = controller.setup().get(); 1544 1545 activity.getSplashScreen().setSplashScreenTheme(splashScreenThemeId); 1546 1547 RoboSplashScreen roboSplashScreen = (RoboSplashScreen) activity.getSplashScreen(); 1548 assertThat(roboSplashScreen.getSplashScreenTheme()).isEqualTo(splashScreenThemeId); 1549 } 1550 } 1551 1552 @Test 1553 @Config(minSdk = S) splashScreen_instanceOfRoboSplashScreen_succeeds()1554 public void splashScreen_instanceOfRoboSplashScreen_succeeds() { 1555 try (ActivityController<Activity> controller = Robolectric.buildActivity(Activity.class)) { 1556 Activity activity = controller.setup().get(); 1557 assertThat(activity.getSplashScreen()).isInstanceOf(RoboSplashScreen.class); 1558 } 1559 } 1560 1561 @Test applicationWindow_hasCorrectWindowTokens()1562 public void applicationWindow_hasCorrectWindowTokens() { 1563 try (ActivityController<TestActivity> controller = 1564 Robolectric.buildActivity(TestActivity.class)) { 1565 Activity activity = controller.setup().get(); 1566 View activityView = activity.getWindow().getDecorView(); 1567 WindowManager.LayoutParams activityLp = 1568 (WindowManager.LayoutParams) activityView.getLayoutParams(); 1569 1570 View windowView = new View(activity); 1571 WindowManager.LayoutParams windowViewLp = new WindowManager.LayoutParams(); 1572 windowViewLp.type = WindowManager.LayoutParams.TYPE_APPLICATION; 1573 ((WindowManager) activity.getSystemService(Context.WINDOW_SERVICE)) 1574 .addView(windowView, windowViewLp); 1575 ShadowLooper.idleMainLooper(); 1576 1577 assertThat(activityLp.token).isNotNull(); 1578 assertThat(windowViewLp.token).isEqualTo(activityLp.token); 1579 } 1580 } 1581 1582 @Test subWindow_hasCorrectWindowTokens()1583 public void subWindow_hasCorrectWindowTokens() { 1584 try (ActivityController<TestActivity> controller = 1585 Robolectric.buildActivity(TestActivity.class)) { 1586 Activity activity = controller.setup().get(); 1587 View activityView = activity.getWindow().getDecorView(); 1588 WindowManager.LayoutParams activityLp = 1589 (WindowManager.LayoutParams) activityView.getLayoutParams(); 1590 1591 View windowView = new View(activity); 1592 WindowManager.LayoutParams windowViewLp = new WindowManager.LayoutParams(); 1593 windowViewLp.type = WindowManager.LayoutParams.TYPE_APPLICATION_PANEL; 1594 ((WindowManager) activity.getSystemService(Context.WINDOW_SERVICE)) 1595 .addView(windowView, windowViewLp); 1596 ShadowLooper.idleMainLooper(); 1597 1598 assertThat(activityLp.token).isNotNull(); 1599 assertThat(windowViewLp.token).isEqualTo(activityView.getWindowToken()); 1600 assertThat(windowView.getApplicationWindowToken()).isEqualTo(activityView.getWindowToken()); 1601 } 1602 } 1603 1604 @Test 1605 @Config(minSdk = VERSION_CODES.R) getDisplay_succeeds()1606 public void getDisplay_succeeds() { 1607 try { 1608 System.setProperty("robolectric.createActivityContexts", "true"); 1609 1610 Activity activity = Robolectric.setupActivity(Activity.class); 1611 assertThat(activity.getDisplay()).isNotNull(); 1612 } finally { 1613 System.setProperty("robolectric.createActivityContexts", "false"); 1614 } 1615 } 1616 1617 ///////////////////////////// 1618 1619 private static class DialogCreatingActivity extends Activity { 1620 @Override onCreateDialog(int id)1621 protected Dialog onCreateDialog(int id) { 1622 return new Dialog(this); 1623 } 1624 } 1625 1626 private static class OptionsMenuActivity extends Activity { 1627 1628 @Override onCreate(Bundle savedInstanceState)1629 protected void onCreate(Bundle savedInstanceState) { 1630 super.onCreate(savedInstanceState); 1631 // Requesting the action bar causes it to be properly initialized when the Activity becomes 1632 // visible 1633 getWindow().requestFeature(Window.FEATURE_ACTION_BAR); 1634 setContentView(new FrameLayout(this)); 1635 } 1636 1637 @Override onCreateOptionsMenu(Menu menu)1638 public boolean onCreateOptionsMenu(Menu menu) { 1639 super.onCreateOptionsMenu(menu); 1640 menu.add("Algebraic!"); 1641 return true; 1642 } 1643 } 1644 1645 private static class ActionMenuActivity extends Activity { 1646 SearchView mSearchView; 1647 1648 @Override onCreate(Bundle savedInstanceState)1649 protected void onCreate(Bundle savedInstanceState) { 1650 super.onCreate(savedInstanceState); 1651 getWindow().requestFeature(Window.FEATURE_ACTION_BAR); 1652 setContentView(new FrameLayout(this)); 1653 } 1654 1655 @Override onCreateOptionsMenu(Menu menu)1656 public boolean onCreateOptionsMenu(Menu menu) { 1657 MenuInflater inflater = getMenuInflater(); 1658 inflater.inflate(R.menu.action_menu, menu); 1659 1660 MenuItem searchMenuItem = menu.findItem(R.id.action_search); 1661 mSearchView = (SearchView) searchMenuItem.getActionView(); 1662 return true; 1663 } 1664 } 1665 1666 private static class DialogLifeCycleActivity extends Activity { 1667 public boolean createdDialog = false; 1668 public boolean preparedDialog = false; 1669 public boolean preparedDialogWithBundle = false; 1670 public Dialog dialog = null; 1671 1672 @Override onCreate(Bundle savedInstanceState)1673 protected void onCreate(Bundle savedInstanceState) { 1674 super.onCreate(savedInstanceState); 1675 setContentView(new FrameLayout(this)); 1676 } 1677 1678 @Override onDestroy()1679 protected void onDestroy() { 1680 super.onDestroy(); 1681 } 1682 1683 @Override onCreateDialog(int id)1684 protected Dialog onCreateDialog(int id) { 1685 createdDialog = true; 1686 return dialog; 1687 } 1688 1689 @Override onPrepareDialog(int id, Dialog dialog)1690 protected void onPrepareDialog(int id, Dialog dialog) { 1691 preparedDialog = true; 1692 } 1693 1694 @Override onPrepareDialog(int id, Dialog dialog, Bundle bundle)1695 protected void onPrepareDialog(int id, Dialog dialog, Bundle bundle) { 1696 preparedDialogWithBundle = true; 1697 } 1698 } 1699 1700 private static class ActivityWithOnCreateDialog extends Activity { 1701 boolean onCreateDialogWasCalled = false; 1702 1703 @Override onCreateDialog(int id)1704 protected Dialog onCreateDialog(int id) { 1705 onCreateDialogWasCalled = true; 1706 return new Dialog(this); 1707 } 1708 } 1709 1710 private static class ActivityWithContentChangedTranscript extends Activity { 1711 private List<String> transcript; 1712 1713 @Override onContentChanged()1714 public void onContentChanged() { 1715 transcript.add( 1716 "onContentChanged was called; title is \"" 1717 + shadowOf((View) findViewById(R.id.title)).innerText() 1718 + "\""); 1719 } 1720 setTranscript(List<String> transcript)1721 private void setTranscript(List<String> transcript) { 1722 this.transcript = transcript; 1723 } 1724 } 1725 1726 private static class OnBackPressedActivity extends Activity { 1727 public boolean onBackPressedCalled = false; 1728 1729 @Override onBackPressed()1730 public void onBackPressed() { 1731 onBackPressedCalled = true; 1732 super.onBackPressed(); 1733 } 1734 } 1735 1736 private static class ActivityLifecycleCallbacks 1737 implements Application.ActivityLifecycleCallbacks { 1738 private final List<String> transcript; 1739 ActivityLifecycleCallbacks(List<String> transcript)1740 public ActivityLifecycleCallbacks(List<String> transcript) { 1741 this.transcript = transcript; 1742 } 1743 1744 @Override onActivityCreated(Activity activity, Bundle bundle)1745 public void onActivityCreated(Activity activity, Bundle bundle) { 1746 transcript.add("onActivityCreated"); 1747 } 1748 1749 @Override onActivityStarted(Activity activity)1750 public void onActivityStarted(Activity activity) { 1751 transcript.add("onActivityStarted"); 1752 } 1753 1754 @Override onActivityResumed(Activity activity)1755 public void onActivityResumed(Activity activity) { 1756 transcript.add("onActivityResumed"); 1757 } 1758 1759 @Override onActivityPaused(Activity activity)1760 public void onActivityPaused(Activity activity) { 1761 transcript.add("onActivityPaused"); 1762 } 1763 1764 @Override onActivityStopped(Activity activity)1765 public void onActivityStopped(Activity activity) { 1766 transcript.add("onActivityStopped"); 1767 } 1768 1769 @Override onActivitySaveInstanceState(Activity activity, Bundle bundle)1770 public void onActivitySaveInstanceState(Activity activity, Bundle bundle) { 1771 transcript.add("onActivitySaveInstanceState"); 1772 } 1773 1774 @Override onActivityDestroyed(Activity activity)1775 public void onActivityDestroyed(Activity activity) { 1776 transcript.add("onActivityDestroyed"); 1777 } 1778 } 1779 1780 /** Activity for testing */ 1781 public static class TestActivityWithAnotherTheme 1782 extends org.robolectric.shadows.testing.TestActivity {} 1783 } 1784