1 /* 2 * Copyright (C) 2017 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.arch.lifecycle; 18 19 import static android.arch.lifecycle.Lifecycle.Event.ON_ANY; 20 import static android.arch.lifecycle.Lifecycle.Event.ON_CREATE; 21 import static android.arch.lifecycle.Lifecycle.Event.ON_DESTROY; 22 import static android.arch.lifecycle.Lifecycle.Event.ON_PAUSE; 23 import static android.arch.lifecycle.Lifecycle.Event.ON_RESUME; 24 import static android.arch.lifecycle.Lifecycle.Event.ON_START; 25 import static android.arch.lifecycle.Lifecycle.Event.ON_STOP; 26 import static android.arch.lifecycle.Lifecycle.State.CREATED; 27 import static android.arch.lifecycle.Lifecycle.State.INITIALIZED; 28 import static android.arch.lifecycle.Lifecycle.State.RESUMED; 29 import static android.arch.lifecycle.Lifecycle.State.STARTED; 30 31 import static org.hamcrest.MatcherAssert.assertThat; 32 import static org.hamcrest.core.Is.is; 33 import static org.mockito.Mockito.mock; 34 import static org.mockito.Mockito.never; 35 import static org.mockito.Mockito.reset; 36 import static org.mockito.Mockito.verify; 37 import static org.mockito.Mockito.when; 38 39 import org.junit.Before; 40 import org.junit.Test; 41 import org.junit.runner.RunWith; 42 import org.junit.runners.JUnit4; 43 import org.mockito.Matchers; 44 45 @RunWith(JUnit4.class) 46 public class ReflectiveGenericLifecycleObserverTest { 47 private LifecycleOwner mOwner; 48 private Lifecycle mLifecycle; 49 50 @Before 51 public void initMocks() { 52 mOwner = mock(LifecycleOwner.class); 53 mLifecycle = mock(Lifecycle.class); 54 when(mOwner.getLifecycle()).thenReturn(mLifecycle); 55 } 56 57 @Test 58 public void anyState() { 59 AnyStateListener obj = mock(AnyStateListener.class); 60 ReflectiveGenericLifecycleObserver observer = new ReflectiveGenericLifecycleObserver(obj); 61 when(mLifecycle.getCurrentState()).thenReturn(STARTED); 62 observer.onStateChanged(mOwner, ON_CREATE); 63 verify(obj).onAnyState(mOwner, ON_CREATE); 64 reset(obj); 65 66 observer.onStateChanged(mOwner, ON_START); 67 verify(obj).onAnyState(mOwner, ON_START); 68 reset(obj); 69 70 observer.onStateChanged(mOwner, ON_RESUME); 71 verify(obj).onAnyState(mOwner, ON_RESUME); 72 reset(obj); 73 74 observer.onStateChanged(mOwner, ON_PAUSE); 75 verify(obj).onAnyState(mOwner, ON_PAUSE); 76 reset(obj); 77 78 observer.onStateChanged(mOwner, ON_STOP); 79 verify(obj).onAnyState(mOwner, ON_STOP); 80 reset(obj); 81 82 observer.onStateChanged(mOwner, ON_DESTROY); 83 verify(obj).onAnyState(mOwner, ON_DESTROY); 84 reset(obj); 85 } 86 87 private static class AnyStateListener implements LifecycleObserver { 88 @OnLifecycleEvent(ON_ANY) 89 void onAnyState(LifecycleOwner owner, Lifecycle.Event event) { 90 91 } 92 } 93 94 @Test 95 public void singleMethod() { 96 CreatedStateListener obj = mock(CreatedStateListener.class); 97 ReflectiveGenericLifecycleObserver observer = new ReflectiveGenericLifecycleObserver(obj); 98 when(mLifecycle.getCurrentState()).thenReturn(CREATED); 99 observer.onStateChanged(mOwner, ON_CREATE); 100 verify(obj).onCreated(); 101 verify(obj).onCreated(mOwner); 102 } 103 104 private static class CreatedStateListener implements LifecycleObserver { 105 @OnLifecycleEvent(ON_CREATE) 106 void onCreated() { 107 108 } 109 @SuppressWarnings("UnusedParameters") 110 @OnLifecycleEvent(ON_CREATE) 111 void onCreated(LifecycleOwner provider) { 112 113 } 114 } 115 116 @Test 117 public void eachEvent() { 118 AllMethodsListener obj = mock(AllMethodsListener.class); 119 ReflectiveGenericLifecycleObserver observer = new ReflectiveGenericLifecycleObserver(obj); 120 when(mLifecycle.getCurrentState()).thenReturn(CREATED); 121 122 observer.onStateChanged(mOwner, ON_CREATE); 123 verify(obj).created(); 124 reset(obj); 125 126 when(mLifecycle.getCurrentState()).thenReturn(STARTED); 127 observer.onStateChanged(mOwner, ON_START); 128 verify(obj).started(); 129 reset(obj); 130 131 when(mLifecycle.getCurrentState()).thenReturn(RESUMED); 132 observer.onStateChanged(mOwner, ON_RESUME); 133 verify(obj).resumed(); 134 reset(obj); 135 136 when(mLifecycle.getCurrentState()).thenReturn(STARTED); 137 observer.onStateChanged(mOwner, ON_PAUSE); 138 verify(obj).paused(); 139 reset(obj); 140 141 when(mLifecycle.getCurrentState()).thenReturn(CREATED); 142 observer.onStateChanged(mOwner, ON_STOP); 143 verify(obj).stopped(); 144 reset(obj); 145 146 when(mLifecycle.getCurrentState()).thenReturn(INITIALIZED); 147 observer.onStateChanged(mOwner, ON_DESTROY); 148 verify(obj).destroyed(); 149 reset(obj); 150 } 151 152 153 private static class AllMethodsListener implements LifecycleObserver { 154 @OnLifecycleEvent(ON_CREATE) 155 void created() {} 156 157 @OnLifecycleEvent(ON_START) 158 void started() {} 159 160 @OnLifecycleEvent(ON_RESUME) 161 void resumed() {} 162 163 @OnLifecycleEvent(ON_PAUSE) 164 void paused() {} 165 166 @OnLifecycleEvent(ON_STOP) 167 void stopped() {} 168 169 @OnLifecycleEvent(ON_DESTROY) 170 void destroyed() { 171 } 172 } 173 174 @Test 175 public void testFailingObserver() { 176 class UnprecedentedError extends Error { 177 } 178 179 LifecycleObserver obj = new LifecycleObserver() { 180 @OnLifecycleEvent(ON_START) 181 void started() { 182 throw new UnprecedentedError(); 183 } 184 }; 185 ReflectiveGenericLifecycleObserver observer = new ReflectiveGenericLifecycleObserver(obj); 186 try { 187 observer.onStateChanged(mOwner, ON_START); 188 } catch (Exception e) { 189 assertThat("exception cause is wrong", 190 e.getCause() instanceof UnprecedentedError); 191 } 192 } 193 194 @Test 195 public void testPrivateObserverMethods() { 196 class ObserverWithPrivateMethod implements LifecycleObserver { 197 boolean mCalled = false; 198 @OnLifecycleEvent(ON_START) 199 private void started() { 200 mCalled = true; 201 } 202 } 203 204 ObserverWithPrivateMethod obj = mock(ObserverWithPrivateMethod.class); 205 ReflectiveGenericLifecycleObserver observer = new ReflectiveGenericLifecycleObserver(obj); 206 observer.onStateChanged(mOwner, ON_START); 207 assertThat(obj.mCalled, is(true)); 208 } 209 210 @Test(expected = IllegalArgumentException.class) 211 public void testWrongFirstParam1() { 212 LifecycleObserver observer = new LifecycleObserver() { 213 @OnLifecycleEvent(ON_START) 214 private void started(Lifecycle.Event e) { 215 } 216 }; 217 new ReflectiveGenericLifecycleObserver(observer); 218 } 219 220 @Test(expected = IllegalArgumentException.class) 221 public void testWrongFirstParam2() { 222 LifecycleObserver observer = new LifecycleObserver() { 223 @OnLifecycleEvent(ON_ANY) 224 private void started(Lifecycle l, Lifecycle.Event e) { 225 } 226 }; 227 new ReflectiveGenericLifecycleObserver(observer); 228 } 229 230 @Test(expected = IllegalArgumentException.class) 231 public void testWrongSecondParam() { 232 LifecycleObserver observer = new LifecycleObserver() { 233 @OnLifecycleEvent(ON_START) 234 private void started(LifecycleOwner owner, Lifecycle l) { 235 } 236 }; 237 new ReflectiveGenericLifecycleObserver(observer); 238 } 239 240 @Test(expected = IllegalArgumentException.class) 241 public void testThreeParams() { 242 LifecycleObserver observer = new LifecycleObserver() { 243 @OnLifecycleEvent(ON_ANY) 244 private void started(LifecycleOwner owner, Lifecycle.Event e, int i) { 245 } 246 }; 247 new ReflectiveGenericLifecycleObserver(observer); 248 } 249 250 class BaseClass1 implements LifecycleObserver { 251 @OnLifecycleEvent(ON_START) 252 void foo(LifecycleOwner owner) { 253 } 254 } 255 256 class DerivedClass1 extends BaseClass1 { 257 @OnLifecycleEvent(ON_STOP) 258 void foo(LifecycleOwner owner) { 259 } 260 } 261 262 @Test(expected = IllegalArgumentException.class) 263 public void testInvalidSuper1() { 264 new ReflectiveGenericLifecycleObserver(new DerivedClass1()); 265 } 266 267 class BaseClass2 implements LifecycleObserver { 268 @OnLifecycleEvent(ON_START) 269 void foo(LifecycleOwner owner) { 270 } 271 } 272 273 class DerivedClass2 extends BaseClass1 { 274 @OnLifecycleEvent(ON_STOP) 275 void foo() { 276 } 277 } 278 279 @Test 280 public void testValidSuper1() { 281 DerivedClass2 obj = mock(DerivedClass2.class); 282 ReflectiveGenericLifecycleObserver observer = new ReflectiveGenericLifecycleObserver(obj); 283 observer.onStateChanged(mock(LifecycleOwner.class), ON_START); 284 verify(obj).foo(Matchers.<LifecycleOwner>any()); 285 verify(obj, never()).foo(); 286 reset(obj); 287 observer.onStateChanged(mock(LifecycleOwner.class), ON_STOP); 288 verify(obj).foo(); 289 verify(obj, never()).foo(Matchers.<LifecycleOwner>any()); 290 } 291 292 class BaseClass3 implements LifecycleObserver { 293 @OnLifecycleEvent(ON_START) 294 void foo(LifecycleOwner owner) { 295 } 296 } 297 298 interface Interface3 extends LifecycleObserver { 299 @OnLifecycleEvent(ON_STOP) 300 void foo(LifecycleOwner owner); 301 } 302 303 class DerivedClass3 extends BaseClass3 implements Interface3 { 304 @Override 305 public void foo(LifecycleOwner owner) { 306 } 307 } 308 309 @Test(expected = IllegalArgumentException.class) 310 public void testInvalidSuper2() { 311 new ReflectiveGenericLifecycleObserver(new DerivedClass3()); 312 } 313 314 class BaseClass4 implements LifecycleObserver { 315 @OnLifecycleEvent(ON_START) 316 void foo(LifecycleOwner owner) { 317 } 318 } 319 320 interface Interface4 extends LifecycleObserver { 321 @OnLifecycleEvent(ON_START) 322 void foo(LifecycleOwner owner); 323 } 324 325 class DerivedClass4 extends BaseClass4 implements Interface4 { 326 @Override 327 @OnLifecycleEvent(ON_START) 328 public void foo(LifecycleOwner owner) { 329 } 330 331 @OnLifecycleEvent(ON_START) 332 public void foo() { 333 } 334 } 335 336 @Test 337 public void testValidSuper2() { 338 DerivedClass4 obj = mock(DerivedClass4.class); 339 ReflectiveGenericLifecycleObserver observer = new ReflectiveGenericLifecycleObserver(obj); 340 observer.onStateChanged(mock(LifecycleOwner.class), ON_START); 341 verify(obj).foo(Matchers.<LifecycleOwner>any()); 342 verify(obj).foo(); 343 } 344 345 interface InterfaceStart extends LifecycleObserver { 346 @OnLifecycleEvent(ON_START) 347 void foo(LifecycleOwner owner); 348 } 349 350 interface InterfaceStop extends LifecycleObserver { 351 @OnLifecycleEvent(ON_STOP) 352 void foo(LifecycleOwner owner); 353 } 354 355 class DerivedClass5 implements InterfaceStart, InterfaceStop { 356 @Override 357 public void foo(LifecycleOwner owner) { 358 } 359 } 360 361 @Test(expected = IllegalArgumentException.class) 362 public void testInvalidSuper3() { 363 new ReflectiveGenericLifecycleObserver(new DerivedClass5()); 364 } 365 } 366