Make Espresso release TestLooperManager from main looper.

Previously Espresso's UIControllerImpl would acquire a TestLooperManager and effectively never release it.
Which would cause any tests that attempted to acquire the TestLooperManager after any Espresso code was run
to fail.

This commit changes UIControllerImpl to only acquire the main Looper TestLooperManager when interrogatoring,
and release it immediately afterwards.

PiperOrigin-RevId: 746198594

Author: brettchabot

espresso/CHANGELOG.md

@@ -17,6 +17,7 @@ The following artifacts were released:
 **Bug Fixes**
 
 * Downgrade to kotlin 1.9
+* Only hold main Looper's TestLooperManager during interrogation
 
 **New Features**
 

espresso/core/java/androidx/test/espresso/base/Interrogator.java

@@ -92,27 +92,16 @@ interface InterrogationHandler<R> extends QueueInterrogationHandler<R> {
     public String getMessage();
   }
 
-  private final TestLooperManagerCompat testLooperManager;
-
-  static Interrogator acquire(Looper looper) {
-    return new Interrogator(TestLooperManagerCompat.acquire(looper));
-  }
-
-  private Interrogator(TestLooperManagerCompat testLooperManager) {
-    this.testLooperManager = testLooperManager;
-  }
-
-  void release() {
-    testLooperManager.release();
-  }
+  Interrogator() {}
 
   /**
    * Loops the main thread and informs the interrogation handler at interesting points in the exec
    * state.
    *
    * @param handler an interrogation handler that controls whether to continue looping or not.
    */
-  <T> T loopAndInterrogate(InterrogationHandler<T> handler) {
+  <T> T loopAndInterrogate(
+      TestLooperManagerCompat testLooperManager, InterrogationHandler<T> handler) {
     checkSanity();
     interrogating.set(Boolean.TRUE);
     boolean stillInterested = true;
@@ -124,7 +113,7 @@ <T> T loopAndInterrogate(InterrogationHandler<T> handler) {
       final long threadIdentity = Binder.clearCallingIdentity();
       while (stillInterested) {
         // run until the observer is no longer interested.
-        stillInterested = interrogateQueueState(handler);
+        stillInterested = interrogateQueueState(testLooperManager, handler);
         if (stillInterested) {
           Message m = testLooperManager.next();
 
@@ -179,16 +168,18 @@ <T> T loopAndInterrogate(InterrogationHandler<T> handler) {
    *     queueEmpty(), taskDueSoon(), taskDueLong() or barrierUp(). once and only once.
    * @return the result of handler.get()
    */
-  <T> T peekAtQueueState(QueueInterrogationHandler<T> handler) {
+  <T> T peekAtQueueState(
+      TestLooperManagerCompat testLooperManager, QueueInterrogationHandler<T> handler) {
     checkNotNull(handler);
     checkState(
-        !interrogateQueueState(handler),
+        !interrogateQueueState(testLooperManager, handler),
         "It is expected that %s would stop interrogation after a single peak at the queue.",
         handler);
     return handler.get();
   }
 
-  private boolean interrogateQueueState(QueueInterrogationHandler<?> handler) {
+  private boolean interrogateQueueState(
+      TestLooperManagerCompat testLooperManager, QueueInterrogationHandler<?> handler) {
     synchronized (testLooperManager.getQueue()) {
       if (testLooperManager.isBlockedOnSyncBarrier()) {
         if (Log.isLoggable(TAG, Log.DEBUG)) {

espresso/core/java/androidx/test/espresso/base/LooperIdlingResourceInterrogationHandler.java

@@ -71,7 +71,7 @@ public boolean barrierUp() {
   private volatile Looper looper = null;
   private volatile boolean idle = true;
 
-  private volatile Interrogator interrogator = null;
+  private volatile TestLooperManagerCompat testLooperManager = null;
 
   // written on main - read on looper
   private volatile IdlingResource.ResourceCallback cb = null;
@@ -99,9 +99,9 @@ static LooperIdlingResourceInterrogationHandler forLooper(Looper l) {
               @Override
               public void run() {
                 ir.looper = Looper.myLooper();
-                ir.interrogator = Interrogator.acquire(ir.looper);
+                ir.testLooperManager = TestLooperManagerCompat.acquire(ir.looper);
                 ir.started = true;
-                ir.interrogator.loopAndInterrogate(ir);
+                new Interrogator().loopAndInterrogate(ir.testLooperManager, ir);
               }
             });
 
@@ -118,7 +118,10 @@ public String getMessage() {
 
   @Override
   public void quitting() {
-    interrogator.release();
+    if (testLooperManager != null) {
+      testLooperManager.release();
+      testLooperManager = null;
+    }
     transitionToIdle();
   }
 
@@ -166,7 +169,8 @@ public boolean isIdleNow() {
       // make sure nothing has arrived in the queue while the looper thread is waiting to pull a
       // new task out of it. There can be some delay between a new message entering the queue and
       // the looper thread pulling it out and processing it.
-      return Boolean.FALSE.equals(interrogator.peekAtQueueState(queueHasNewTasks));
+      return Boolean.FALSE.equals(
+          new Interrogator().peekAtQueueState(testLooperManager, queueHasNewTasks));
     }
     return false;
   }
@@ -189,6 +193,9 @@ private void transitionToIdle() {
   }
 
   public void release() {
-    interrogator.release();
+    if (testLooperManager != null) {
+      testLooperManager.release();
+      testLooperManager = null;
+    }
   }
 }

espresso/core/java/androidx/test/espresso/base/UiControllerImpl.java

@@ -502,13 +502,15 @@ private IdleNotifier<IdleNotificationCallback> loopUntil(
       EnumSet<IdleCondition> conditions, IdleNotifier<IdleNotificationCallback> dynamicIdle) {
     IdlingPolicy masterIdlePolicy = IdlingPolicies.getMasterIdlingPolicy();
     IdlingPolicy dynamicIdlePolicy = IdlingPolicies.getDynamicIdlingResourceErrorPolicy();
+    TestLooperManagerCompat testLooperManager = TestLooperManagerCompat.acquire(mainLooper);
     try {
       long start = SystemClock.uptimeMillis();
       long end =
           start + masterIdlePolicy.getIdleTimeoutUnit().toMillis(masterIdlePolicy.getIdleTimeout());
       interrogation = new MainThreadInterrogation(conditions, conditionSet, end);
 
-      InterrogationStatus result = getInterrogator().loopAndInterrogate(interrogation);
+      InterrogationStatus result =
+          new Interrogator().loopAndInterrogate(testLooperManager, interrogation);
       if (InterrogationStatus.COMPLETED == result) {
         // did not time out, all conditions happy.
         return dynamicIdle;
@@ -582,17 +584,10 @@ private IdleNotifier<IdleNotificationCallback> loopUntil(
         condition.reset(conditionSet);
       }
       interrogation = null;
+      testLooperManager.release();
     }
     return dynamicIdle;
   }
-
-  private Interrogator getInterrogator() {
-    if (interrogator == null) {
-      interrogator = Interrogator.acquire(mainLooper);
-    }
-    return interrogator;
-  }
-
   @Override
   public void interruptEspressoTasks() {
     controllerHandler.post(

espresso/core/javatests/androidx/test/espresso/base/EspressoIdleTest.java

@@ -1,11 +1,15 @@
 package androidx.test.espresso.base;
 
 import static android.os.Looper.getMainLooper;
+import static androidx.test.platform.app.InstrumentationRegistry.getInstrumentation;
 import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assume.assumeTrue;
 
+import android.os.Build.VERSION;
 import android.os.Handler;
 import android.os.HandlerThread;
 import android.os.Looper;
+import android.os.TestLooperManager;
 import androidx.test.espresso.Espresso;
 import androidx.test.espresso.IdlingRegistry;
 import androidx.test.ext.junit.runners.AndroidJUnit4;
@@ -64,4 +68,41 @@ public void onIdle_afterPost_backgroundLooper() {
       ht.quit();
     }
   }
+
+  /** Verify TestLooperManager can be used after Espresso idle is run. */
+  @Test
+  public void onIdle_with_TestLooperManager() {
+    assumeTrue(VERSION.SDK_INT >= 36);
+
+    Espresso.onIdle();
+
+    TestLooperManager manager = getInstrumentation().acquireLooperManager(getMainLooper());
+    assertThat(manager).isNotNull();
+    manager.release();
+
+    Espresso.onIdle();
+  }
+
+  @Test
+  public void onIdle_backgroundLooper_with_TestLooperManager() throws InterruptedException {
+    assumeTrue(VERSION.SDK_INT >= 36);
+
+    HandlerThread ht = new HandlerThread("onIdle_backgroundLooper_with_TestLooperManager");
+    ht.start();
+    Looper looper = ht.getLooper();
+
+    IdlingRegistry.getInstance().registerLooperAsIdlingResource(looper);
+    AtomicBoolean wasRun = new AtomicBoolean(false);
+    new Handler(looper).post(() -> wasRun.set(true));
+    Espresso.onIdle();
+    assertThat(wasRun.get()).isTrue();
+    IdlingRegistry.getInstance().unregisterLooperAsIdlingResource(looper);
+
+    Espresso.onIdle();
+
+    TestLooperManager manager = getInstrumentation().acquireLooperManager(looper);
+    assertThat(manager).isNotNull();
+    manager.release();
+    ht.quit();
+  }
 }