// Ignore in concurrent test
                            }
                        }
                    }
                } finally {
                    latch.countDown();
                }
            });
        }

        assertTrue(latch.await(10, TimeUnit.SECONDS), "Concurrent ops should complete");
        executor.shutdown();

        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()

            numObInputDoc.set(response.getNumberOfInputDocs());
            latch.countDown();
        }).error(t -> {
            t.printStackTrace();
            latch.countDown();
            fail();
        });
        latch.await();
        assertEquals(num, numObInputDoc.get());

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

    /*

                    WebApiUtil.validate();
                } catch (Exception e) {
                    errorCount.incrementAndGet();
                } finally {
                    latch.countDown();
                }
            }).start();
        }

        try {
            latch.await();
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();

    listener =
      object : RecordingEventListener() {
        override fun requestHeadersEnd(
          call: Call,
          request: Request,
        ) {
          requestFinished.countDown()
          super.responseHeadersStart(call)
        }
      }
    client =
      client
        .newBuilder()
        .dns(DoubleInetAddressDns())

        final AtomicBoolean errorOccurred = new AtomicBoolean(false);

        indexUpdater.setUncaughtExceptionHandler((t, e) -> {
            errorOccurred.set(true);
            latch.countDown();
        });

        // Set up test data service to return empty results
        ((TestDataService) dataService).setAccessResultList(new TestOpenSearchResultList());

        // Start indexer in separate thread

    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

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

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

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