}
  }

  override fun onFailure(
    webSocket: WebSocket,
    t: Throwable,
    response: Response?,
  ) {
    Platform.get().log("[WS $name] onFailure", Platform.INFO, t)
    val delegate = delegate
    if (delegate != null) {
      this.delegate = null
      delegate.onFailure(webSocket, t, response)
    } else {
      events.add(Failure(t, response))
    }
  }

      }
    }

    if (failures.isNotEmpty()) {
      for (failure in failures) {
        println(failure)
      }
      throw failures.first()
    }
  }

  private fun testToAscii(
    input: String,
    output: String?,
    comment: String?,
  ) {
    val url = "https://$input/".toHttpUrlOrNull()
    assertThat(url?.host, name = comment ?: input).isEqualTo(output)
  }

    body: Buffer,
    sequenceNumber: Int,
    failure: IOException?,
    method: String?,
    path: String?,
    handshake: Handshake?,
    requestUrl: HttpUrl?,
  ) {
    this.requestLine = requestLine
    this.headers = headers
    this.chunkSizes = chunkSizes
    this.bodySize = bodySize
    this.body = body
    this.sequenceNumber = sequenceNumber
    this.failure = failure
    this.method = method
    this.path = path

	initial := timeout.Timeout()

	for i := 0; i < dynamicTimeoutLogSize; i++ {
		timeout.LogFailure()
	}

	adjusted := timeout.Timeout()

	if initial >= adjusted {
		t.Errorf("Failure to increase timeout, expected %v to be more than %v", adjusted, initial)
	}
}

func TestDynamicTimeoutDualIncrease(t *testing.T) {
	timeout := newDynamicTimeout(time.Minute, time.Second)

	initial := timeout.Timeout()

    /**
     * The cause of the build failure.
     */
    private final Throwable cause;

    /**
     * Creates a new build summary for the specified project.
     *
     * @param project The project being summarized, must not be {@code null}.
     * @param time The build time of the project in milliseconds.
     * @param cause The cause of the build failure, may be {@code null}.
     */

        if (expectedClass.isInstance(failure)) {
          found = true
          break
        }
      }
      assertThat(
        found,
        "Expected exception type among ${allowedExceptionTypes.contentToString()}, got $failure",
      ).isTrue()
    }

  fun assertFailure(vararg messages: String) =
    apply {
      assertThat(failure, "No failure found").isNotNull()

    get().log("[ES] onClosed", Platform.INFO, null)
    events.add(Closed)
    drainCancelQueue(eventSource)
  }

  override fun onFailure(
    eventSource: EventSource,
    t: Throwable?,
    response: Response?,
  ) {
    get().log("[ES] onFailure", Platform.INFO, t)
    events.add(Failure(t, response))
    drainCancelQueue(eventSource)
  }

  private fun drainCancelQueue(eventSource: EventSource) {
    if (cancel) {

var (
	resultLabel                   = monitoring.CreateLabel("result")
	resultSuccess                 = "SUCCESS"
	resultCopyBinariesFailure     = "COPY_BINARIES_FAILURE"
	resultCreateKubeConfigFailure = "CREATE_KUBECONFIG_FAILURE"
	resultCreateCNIConfigFailure  = "CREATE_CNI_CONFIG_FAILURE"

	cniInstalls = monitoring.NewSum(
		"istio_cni_installs_total",
		"Total number of CNI plugins installed by the Istio CNI installer",
	)

  }

  public void testCheckNoOverflow_failure() {
    try {
      MathPreconditions.checkNoOverflow(false, "testCheckNoOverflow_failure", 0, 0);
      fail();
    } catch (ArithmeticException expected) {
      assertThat(expected).hasMessageThat().contains("testCheckNoOverflow_failure(0, 0)");
    }
  }

  public void testNulls() {
    /*

    @Nullable private String value = null;
    @Nullable private Throwable failure = null;
    private boolean wasCalled = false;

    MockCallback(String expectedValue) {
      this.value = expectedValue;
    }

    public MockCallback(Throwable expectedFailure) {
      this.failure = expectedFailure;
    }

    @Override
    public synchronized void onSuccess(String result) {