override fun onFailure(
          call: Call,
          e: IOException,
        ) {
          completionLatch.countDown()
        }

        override fun onResponse(
          call: Call,
          response: Response,
        ) {
          response.close()
          completionLatch.countDown()
        }
      }
    call.enqueue(callback)
    completionLatch.await()

    val requestFinishedListener =
      object : EventListener() {
        override fun requestHeadersEnd(
          call: Call,
          request: Request,
        ) {
          requestFinished.countDown()
        }
      }
    client =
      client
        .newBuilder()
        .dns(DoubleInetAddressDns())
        .eventListenerFactory(

    ScheduledThreadPoolExecutor delegate =
        new ScheduledThreadPoolExecutor(1) {
          @Override
          protected void afterExecute(Runnable r, Throwable t) {
            completed.countDown();
          }
        };
    ListeningScheduledExecutorService service = listeningDecorator(delegate);
    ListenableFuture<Integer> future = service.schedule(Callables.returning(42), 1, MILLISECONDS);

    /*

    private final CountDownLatch latch = new CountDownLatch(1);
    
    @Override
    public void onWitnessNotification(WitnessNotification notification) {
        notificationReceived = true;
        latch.countDown();
    }
    
    @Override
    public void onRegistrationFailed(WitnessRegistration registration, Exception error) {
        // Test implementation
    }
    
    @Override

          connection: Http2Connection,
          settings: Settings,
        ) {
          maxConcurrentStreams.set(settings.getMaxConcurrentStreams())
          maxConcurrentStreamsUpdated.countDown()
        }
      }
    val connection = connect(peer, IGNORE, listener)
    connection.withLock {
      assertThat(connection.peerSettings.getMaxConcurrentStreams()).isEqualTo(10)
    }

        } catch (InterruptedException | ExecutionException e) {
          return;
        } catch (TimeoutException e) {
          // do nothing
        } finally {
          completedIteration.countDown();
        }
      }
    }

    void awaitInLoop() {
      Uninterruptibles.awaitUninterruptibly(completedIteration);
    }
  }

        } catch (InterruptedException | ExecutionException e) {
          return;
        } catch (TimeoutException e) {
          // do nothing
        } finally {
          completedIteration.countDown();
        }
      }
    }

    void awaitInLoop() {
      Uninterruptibles.awaitUninterruptibly(completedIteration);
    }
  }

      }
      for (Map.Entry<AutoCloseable, Executor> entry : entrySet()) {
        closeQuietly(entry.getKey(), entry.getValue());
      }
      clear();
      if (whenClosed != null) {
        whenClosed.countDown();
      }
    }

    void add(@Nullable AutoCloseable closeable, Executor executor) {
      checkNotNull(executor);
      if (closeable == null) {
        return;
      }

 - reach GA, and deprecate the beta, or
 - have a new beta version _(and deprecate the previous beta)_.

If a REST API reaches the end of that nine-month countdown, then the next Kubernetes release will deprecate that API version. More information can be found on [the Kubernetes Blog](https://kubernetes.io/blog/2020/08/21/moving-forward-from-beta/).