System.out.println("Response 2 equals Response 1? " + response1Body.equals(response2Body));
      }
    ```

            <sourceFileExclude>**/ForceGuavaCompilation*</sourceFileExclude>
          </sourceFileExcludes>
          <!-- The above exclusion doesn't actually matter unless I prevent Javadoc from autodiscovering the source in the sourcepath, which defaults to the source directory :\ Boo for -sourcepath. -->
          <sourcepath>doesnotexist</sourcepath>

    return contentType.type == "text" && contentType.subtype == "event-stream"
  }

  override fun onFailure(
    call: Call,
    e: IOException,
  ) {
    listener.onFailure(this, e, null)
  }

  override fun request(): Request = request

  override fun cancel() {
    canceled = true
    call?.cancel()
  }

  override fun onEvent(
    id: String?,
    type: String?,
    data: String,

        // 11
        "id\r".encodeUtf8(),
        // 12
        "id\n".encodeUtf8(),
        // 13
        "event: ".encodeUtf8(),
        // 14
        "event:".encodeUtf8(),
        // 15
        "event\r\n".encodeUtf8(),
        // 16
        "event\r".encodeUtf8(),
        // 17
        "event\n".encodeUtf8(),
        // 18
        "retry: ".encodeUtf8(),
        // 19
        "retry:".encodeUtf8(),

  /**
   * Invoked when an event source has been accepted by the remote peer and may begin transmitting
   * events.
   */
  open fun onOpen(
    eventSource: EventSource,
    response: Response,
  ) {
  }

  /**
   * Invoked when a new event has been sent to the client.
   *
   * @param id The `id` line of the event, might be null.
   * @param type The `event` line of the event, might be null.

      ?: throw AssertionError("Timed out waiting for event.")

  fun assertExhausted() {
    assertThat(events).isEmpty()
  }

  fun assertEvent(
    id: String?,
    type: String?,
    data: String,
  ) {
    assertThat(nextEvent()).isEqualTo(Event(id, type, data))
  }

  fun assertOpen(): EventSource {
    val event = nextEvent() as Open
    return event.eventSource
  }

  fun assertClose() {

}

public abstract class okhttp3/sse/EventSourceListener {
	public fun <init> ()V
	public fun onClosed (Lokhttp3/sse/EventSource;)V
	public fun onEvent (Lokhttp3/sse/EventSource;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V
	public fun onFailure (Lokhttp3/sse/EventSource;Ljava/lang/Throwable;Lokhttp3/Response;)V

     */
    public boolean calibrateCpuLoad(final long timeoutInMillis) {
        final short percent = ComponentUtil.getFessConfig().getAdaptiveLoadControlAsInteger().shortValue();
        if (percent <= 0) {
            return true;
        }
        short current = getSystemCpuPercent();
        if (current < percent) {
            return true;
        }
        final long startTime = getCurrentTimeAsLong();

      public void onOpen(@NotNull EventSource eventSource, @NotNull Response response) {
        try {
          assertEquals("text/event-stream", response.request().header("Accept"));
        } catch (Exception e) {
          future.completeExceptionally(e);
        }
      }

      @Override
      public void onEvent(@NotNull EventSource eventSource, @Nullable String id, @Nullable String type, @NotNull String data) {
        try {

   *
   * <p>TODO: b/147144588 - We are currently also missing the methods inherited from {@link
   * AnnotatedElement}, which {@code TypeVariable} began to extend only in Java 8. Those methods
   * refer only to types present under Android, so we could implement them in {@code
   * TypeVariableImpl} today. (We could probably then make {@code TypeVariableImpl} implement {@code
   * AnnotatedElement} so that we get partial compile-time checking.)
   *