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));
+    }
 }