"x": 0,
        "y": 12
      },
      "hideTimeOverride": false,
      "id": 73,
      "links": [],
      "options": {
        "cellHeight": "sm",
        "footer": {
          "countRows": false,
          "fields": "",
          "reducer": [
            "sum"
          ],
          "show": false
        },
        "showHeader": true
      },
      "pluginVersion": "10.1.5",

    val waiting = CountDownLatch(1)
    client =
      client.newBuilder()
        .addInterceptor(
          Interceptor { chain: Interceptor.Chain? ->
            try {
              ready.countDown()
              waiting.await()
            } catch (e: InterruptedException) {
              throw AssertionError()
            }
            throw IOException()
          },
        )
        .build()

            synchronized(failures) {
              failures.add(e)
            }
            latch.countDown()
          }

          override fun onResponse(
            call: Call,
            response: Response,
          ) {
            processResponse(response, hostname, responses, failures)
            latch.countDown()
          }
        },
      )
    }

    try {
      latch.await()

          response: Response,
        ) {
          bodies.add(response.body.string())
          latch.countDown()
        }

        override fun onFailure(
          call: Call,
          e: IOException,
        ) {
          errors.add(e)
          latch.countDown()
        }
      }
    client.newCall(Request.Builder().url(server.url("/")).build()).enqueue(
      callback,

          throw new RuntimeException(e);
        }
        doneSignal.countDown();
      }
    }.start();

    try {
      computingSignal.await();
    } catch (InterruptedException e) {
      throw new RuntimeException(e);
    }

    map.put(one, two);
    assertSame(two, map.get(one));
    startSignal.countDown();

    try {
      doneSignal.await();

          throw new RuntimeException(e);
        }
        doneSignal.countDown();
      }
    }.start();

    try {
      computingSignal.await();
    } catch (InterruptedException e) {
      throw new RuntimeException(e);
    }

    map.put(one, two);
    assertSame(two, map.get(one));
    startSignal.countDown();

    try {
      doneSignal.await();

                    executor.execute(new ResolveTask(
                            classLoader, latch, artifact, session, node.getRemoteRepositories(), result));
                } else {
                    latch.countDown();
                }
            }
            try {
                latch.await();
            } catch (InterruptedException e) {
                result.addErrorArtifactException(

                    ps.println(line);
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                latch.countDown();
            }
        }).start();
        return os;
    }

    clientListener.assertOpen()
    clientListener.assertFailure(
      SocketTimeoutException::class.java,
      "sent ping but didn't receive pong within 500ms (after 0 successful ping/pongs)",
    )
    latch.countDown()
    val elapsedUntilFailure = System.nanoTime() - openAtNanos
    assertThat(TimeUnit.NANOSECONDS.toMillis(elapsedUntilFailure).toDouble())
      .isCloseTo(1000.0, 250.0)
  }

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