diff options
Diffstat (limited to 'android/arch/lifecycle/TestUtils.java')
-rw-r--r-- | android/arch/lifecycle/TestUtils.java | 108 |
1 files changed, 96 insertions, 12 deletions
diff --git a/android/arch/lifecycle/TestUtils.java b/android/arch/lifecycle/TestUtils.java index f0214bfb..f7f9bbe5 100644 --- a/android/arch/lifecycle/TestUtils.java +++ b/android/arch/lifecycle/TestUtils.java @@ -16,16 +16,35 @@ package android.arch.lifecycle; +import static android.arch.lifecycle.Lifecycle.Event.ON_CREATE; +import static android.arch.lifecycle.Lifecycle.Event.ON_DESTROY; +import static android.arch.lifecycle.Lifecycle.Event.ON_PAUSE; +import static android.arch.lifecycle.Lifecycle.Event.ON_RESUME; +import static android.arch.lifecycle.Lifecycle.Event.ON_START; +import static android.arch.lifecycle.Lifecycle.Event.ON_STOP; +import static android.arch.lifecycle.Lifecycle.State.CREATED; +import static android.arch.lifecycle.Lifecycle.State.DESTROYED; import static android.arch.lifecycle.Lifecycle.State.RESUMED; +import static android.arch.lifecycle.Lifecycle.State.STARTED; +import static android.arch.lifecycle.testapp.TestEvent.LIFECYCLE_EVENT; +import static android.arch.lifecycle.testapp.TestEvent.OWNER_CALLBACK; + +import static org.hamcrest.CoreMatchers.is; +import static org.hamcrest.MatcherAssert.assertThat; import android.app.Activity; import android.app.Instrumentation; import android.app.Instrumentation.ActivityMonitor; +import android.arch.lifecycle.testapp.TestEvent; import android.support.test.InstrumentationRegistry; import android.support.test.rule.ActivityTestRule; -import android.support.v4.app.FragmentActivity; +import android.support.v4.util.Pair; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; import java.util.concurrent.CountDownLatch; +import java.util.concurrent.TimeUnit; class TestUtils { @@ -61,23 +80,88 @@ class TestUtils { return result; } - static void waitTillResumed(final FragmentActivity a, ActivityTestRule<?> activityRule) + static void waitTillCreated(final LifecycleOwner owner, ActivityTestRule<?> activityRule) + throws Throwable { + waitTillState(owner, activityRule, CREATED); + } + + static void waitTillStarted(final LifecycleOwner owner, ActivityTestRule<?> activityRule) + throws Throwable { + waitTillState(owner, activityRule, STARTED); + } + + static void waitTillResumed(final LifecycleOwner owner, ActivityTestRule<?> activityRule) + throws Throwable { + waitTillState(owner, activityRule, RESUMED); + } + + static void waitTillDestroyed(final LifecycleOwner owner, ActivityTestRule<?> activityRule) + throws Throwable { + waitTillState(owner, activityRule, DESTROYED); + } + + static void waitTillState(final LifecycleOwner owner, ActivityTestRule<?> activityRule, + Lifecycle.State state) throws Throwable { final CountDownLatch latch = new CountDownLatch(1); activityRule.runOnUiThread(() -> { - Lifecycle.State currentState = a.getLifecycle().getCurrentState(); - if (currentState == RESUMED) { + Lifecycle.State currentState = owner.getLifecycle().getCurrentState(); + if (currentState == state) { latch.countDown(); + } else { + owner.getLifecycle().addObserver(new LifecycleObserver() { + @OnLifecycleEvent(Lifecycle.Event.ON_ANY) + public void onStateChanged(LifecycleOwner provider) { + if (provider.getLifecycle().getCurrentState() == state) { + latch.countDown(); + provider.getLifecycle().removeObserver(this); + } + } + }); } - a.getLifecycle().addObserver(new LifecycleObserver() { - @OnLifecycleEvent(Lifecycle.Event.ON_RESUME) - public void onStateChanged(LifecycleOwner provider) { - latch.countDown(); - provider.getLifecycle().removeObserver(this); - } - }); }); - latch.await(); + boolean latchResult = latch.await(1, TimeUnit.MINUTES); + assertThat("expected " + state + " never happened. Current state:" + + owner.getLifecycle().getCurrentState(), latchResult, is(true)); + + // wait for another loop to ensure all observers are called + activityRule.runOnUiThread(() -> { + // do nothing + }); } + @SafeVarargs + static <T> List<T> flatMap(List<T>... items) { + ArrayList<T> result = new ArrayList<>(); + for (List<T> item : items) { + result.addAll(item); + } + return result; + } + + /** + * Event tuples of {@link TestEvent} and {@link Lifecycle.Event} + * in the order they should arrive. + */ + @SuppressWarnings("unchecked") + static class OrderedTuples { + static final List<Pair<TestEvent, Lifecycle.Event>> CREATE = + Arrays.asList(new Pair(OWNER_CALLBACK, ON_CREATE), + new Pair(LIFECYCLE_EVENT, ON_CREATE)); + static final List<Pair<TestEvent, Lifecycle.Event>> START = + Arrays.asList(new Pair(OWNER_CALLBACK, ON_START), + new Pair(LIFECYCLE_EVENT, ON_START)); + static final List<Pair<TestEvent, Lifecycle.Event>> RESUME = + Arrays.asList(new Pair(OWNER_CALLBACK, ON_RESUME), + new Pair(LIFECYCLE_EVENT, ON_RESUME)); + static final List<Pair<TestEvent, Lifecycle.Event>> PAUSE = + Arrays.asList(new Pair(LIFECYCLE_EVENT, ON_PAUSE), + new Pair(OWNER_CALLBACK, ON_PAUSE)); + static final List<Pair<TestEvent, Lifecycle.Event>> STOP = + Arrays.asList(new Pair(LIFECYCLE_EVENT, ON_STOP), + new Pair(OWNER_CALLBACK, ON_STOP)); + static final List<Pair<TestEvent, Lifecycle.Event>> DESTROY = + Arrays.asList(new Pair(LIFECYCLE_EVENT, ON_DESTROY), + new Pair(OWNER_CALLBACK, ON_DESTROY)); + } } |