1 /* 2 * Copyright (C) 2014 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.support.test.internal.runner.lifecycle; 18 19 import static org.hamcrest.MatcherAssert.assertThat; 20 import static org.hamcrest.Matchers.is; 21 import static org.hamcrest.Matchers.isIn; 22 import static org.mockito.Mockito.mock; 23 import static org.mockito.Mockito.never; 24 import static org.mockito.Mockito.verify; 25 26 import android.app.Activity; 27 import android.support.test.internal.runner.lifecycle.ActivityLifecycleMonitorImpl; 28 import android.support.test.runner.lifecycle.ActivityLifecycleCallback; 29 import android.support.test.runner.lifecycle.Stage; 30 import android.test.suitebuilder.annotation.SmallTest; 31 32 import junit.framework.TestCase; 33 34 import java.util.ArrayList; 35 import java.util.List; 36 37 /** 38 * ActivityLifecycleMonitorImpl tests. 39 */ 40 @SmallTest 41 public class ActivityLifecycleMonitorImplTest extends TestCase { 42 43 private final Activity mMockActivity = mock(Activity.class); 44 45 private final ActivityLifecycleMonitorImpl mMonitor = new ActivityLifecycleMonitorImpl(true); 46 47 public void testAddRemoveListener() { 48 ActivityLifecycleCallback callback = mock(ActivityLifecycleCallback.class); 49 50 // multiple adds should only register once. 51 mMonitor.addLifecycleCallback(callback); 52 mMonitor.addLifecycleCallback(callback); 53 mMonitor.addLifecycleCallback(callback); 54 55 mMonitor.signalLifecycleChange(Stage.CREATED, mMockActivity); 56 mMonitor.signalLifecycleChange(Stage.STARTED, mMockActivity); 57 58 // multiple removes should no-op. 59 mMonitor.removeLifecycleCallback(callback); 60 mMonitor.removeLifecycleCallback(callback); 61 62 mMonitor.signalLifecycleChange(Stage.DESTROYED, mMockActivity); 63 64 65 verify(callback).onActivityLifecycleChanged(mMockActivity, Stage.CREATED); 66 verify(callback).onActivityLifecycleChanged(mMockActivity, Stage.STARTED); 67 verify(callback, never()).onActivityLifecycleChanged(mMockActivity, Stage.DESTROYED); 68 } 69 70 public void testCallbackConsistancy() { 71 ConsistancyCheckingCallback callback = new ConsistancyCheckingCallback(); 72 mMonitor.addLifecycleCallback(callback); 73 74 for (Stage stage : Stage.values()) { 75 mMonitor.signalLifecycleChange(stage, mMockActivity); 76 if (null != callback.mError) { 77 throw callback.mError; 78 } 79 } 80 } 81 82 public void testDirectQueries() { 83 Activity mock1 = mock(Activity.class); 84 Activity mock2 = mock(Activity.class); 85 Activity mock3 = mock(Activity.class); 86 87 mMonitor.signalLifecycleChange(Stage.CREATED, mock1); 88 mMonitor.signalLifecycleChange(Stage.CREATED, mock2); 89 mMonitor.signalLifecycleChange(Stage.CREATED, mock3); 90 91 assertThat(mMonitor.getLifecycleStageOf(mock1), is(Stage.CREATED)); 92 assertThat(mMonitor.getLifecycleStageOf(mock2), is(Stage.CREATED)); 93 assertThat(mMonitor.getLifecycleStageOf(mock3), is(Stage.CREATED)); 94 95 List<Activity> expectedActivities = new ArrayList<Activity>(); 96 expectedActivities.add(mock1); 97 expectedActivities.add(mock2); 98 expectedActivities.add(mock3); 99 100 assertTrue(expectedActivities.containsAll(mMonitor.getActivitiesInStage(Stage.CREATED))); 101 102 mMonitor.signalLifecycleChange(Stage.DESTROYED, mock1); 103 mMonitor.signalLifecycleChange(Stage.PAUSED, mock2); 104 mMonitor.signalLifecycleChange(Stage.PAUSED, mock3); 105 assertThat(mMonitor.getLifecycleStageOf(mock1), is(Stage.DESTROYED)); 106 assertThat(mMonitor.getLifecycleStageOf(mock2), is(Stage.PAUSED)); 107 assertThat(mMonitor.getLifecycleStageOf(mock3), is(Stage.PAUSED)); 108 109 assertThat(mMonitor.getActivitiesInStage(Stage.CREATED).isEmpty(), is(true)); 110 assertThat(mock1, isIn(mMonitor.getActivitiesInStage(Stage.DESTROYED))); 111 assertThat(mock2, isIn(mMonitor.getActivitiesInStage(Stage.PAUSED))); 112 assertThat(mock3, isIn(mMonitor.getActivitiesInStage(Stage.PAUSED))); 113 } 114 115 private class ConsistancyCheckingCallback implements ActivityLifecycleCallback { 116 private RuntimeException mError = null; 117 118 @Override 119 public void onActivityLifecycleChanged(Activity activity, Stage stage) { 120 try { 121 assertThat(activity, isIn(mMonitor.getActivitiesInStage(stage))); 122 assertThat(mMonitor.getLifecycleStageOf(activity), is(stage)); 123 } catch (RuntimeException re) { 124 mError = re; 125 } 126 } 127 } 128 }