1 files changed, 12 insertions, 96 deletions

diff --git a/android/arch/lifecycle/TestUtils.java b/android/arch/lifecycle/TestUtils.java
index f7f9bbe5..f0214bfb 100644
--- a/android/arch/lifecycle/TestUtils.java
+++ b/android/arch/lifecycle/TestUtils.java
@@ -16,35 +16,16 @@
 
 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.util.Pair;
+import android.support.v4.app.FragmentActivity;
 
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
 import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.TimeUnit;
 
 class TestUtils {
 
@@ -80,88 +61,23 @@ class TestUtils {
         return result;
     }
 
-    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)
+    static void waitTillResumed(final FragmentActivity a, ActivityTestRule<?> activityRule)
             throws Throwable {
         final CountDownLatch latch = new CountDownLatch(1);
         activityRule.runOnUiThread(() -> {
-            Lifecycle.State currentState = owner.getLifecycle().getCurrentState();
-            if (currentState == state) {
+            Lifecycle.State currentState = a.getLifecycle().getCurrentState();
+            if (currentState == RESUMED) {
                 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);
+                }
+            });
         });
-        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
-        });
+        latch.await();
     }
 
-    @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));
-    }
 }