}
                latch.countDown()
              }

              override fun onFailure(
                hostname: String,
                e: IOException,
              ) {
                synchronized(allExceptions) {
                  allExceptions.add(e)
                }
                latch.countDown()
              }
            },
          )

    final CountDownLatch latch = new CountDownLatch(1);
    Object unused =
        new Object() {
          @SuppressWarnings({"removal", "Finalize"}) // b/260137033
          @Override
          protected void finalize() {
            latch.countDown();
          }
        };
    unused = null; // Hint to the JIT that unused is unreachable
    GcFinalization.await(latch);
    assertEquals(0, latch.getCount());
  }

            deferred.resolve(new SuggestResponse("", 0, Collections.emptyList(), 0, null));
        });
        th.start();

        final CountDownLatch latch = new CountDownLatch(1);
        deferred.promise().then(response -> latch.countDown());
        assertTrue(latch.await(10, TimeUnit.SECONDS));
    }

    @Test
    public void test_doneAfterResolve() throws Exception {

    // thread because the task will block on the task latch after unblocking
    // the run latch.
    exec.execute(task);
    runLatch.await();
    assertEquals(1, listenerLatch.getCount());
    assertFalse(task.isDone());
    assertFalse(task.isCancelled());

    // Finish the task by unblocking the task latch.  Then wait for the
    // listener to be called by blocking on the listener latch.
    taskLatch.countDown();

                  throw new AssertionError(e);
                }

                dispatcher.dispatch("foo", stringSubscribers.iterator());
                latch.countDown();
              }
            })
        .start();

    Uninterruptibles.awaitUninterruptibly(latch);

    // See Dispatcher.LegacyAsyncDispatcher for an explanation of why there aren't really any

constraints.AssertTrue.message  = {item} muss wahr sein.
constraints.DecimalMax.message  = {item} muss kleiner ${inclusive == true ? 'oder gleich ' : 'als '}{value} sein.
constraints.DecimalMin.message  = {item} muss größer ${inclusive == true ? 'oder gleich ' : 'als '}{value} sein.
constraints.Digits.message      = {item} is numeric value out of bounds (<{integer} digits>.<{fraction} digits> expected).

                Arguments.of(true, new String[] {"--force-interactive", "--non-interactive", "--batch-mode"}, false),
                Arguments.of(false, new String[] {"--non-interactive"}, true),
                Arguments.of(false, new String[] {"--batch-mode"}, true),
                Arguments.of(false, new String[] {"--non-interactive", "--batch-mode"}, true));
    }

        taskRunner.kickCoordinator(this)
      }
      return newTask.latch
    }
  }

  private class AwaitIdleTask : Task("$okHttpName awaitIdle", cancelable = false) {
    val latch = CountDownLatch(1)

    override fun runOnce(): Long {
      latch.countDown()
      return -1L
    }
  }

    val secondResponseCode = AtomicInteger()
    val secondRequest = "/bar"
    val firstRequest = "/foo"
    val latch = CountDownLatch(1)
    val dispatcher: Dispatcher =
      object : Dispatcher() {
        override fun dispatch(request: RecordedRequest): MockResponse {
          if (request.path == firstRequest) {
            latch.await()
          }
          return MockResponse()
        }
      }

    private final Queue<Consumer<RESPONSE>> doneCallbacks = new LinkedBlockingQueue<>();

    private final Queue<Consumer<Throwable>> errorCallbacks = new LinkedBlockingQueue<>();

    private final CountDownLatch latch = new CountDownLatch(1);

    public void resolve(final RESPONSE r) {
        final ArrayList<Consumer<RESPONSE>> executeCallbacks;
        synchronized (Deferred.this) {
            if (response != null || error != null) {