assertEquals("hello, world!", chat.messages());

  chat.loadMore();
  chat.loadMore();
  assertEquals(""
      + "hello, world!\n"
      + "sup, bra?\n"
      + "yo dog", chat.messages());

  // Optional: confirm that your app made the HTTP requests you were expecting.
  RecordedRequest request1 = server.takeRequest();
  assertEquals("/v1/chat/messages/", request1.getUrl().encodedPath());

  - type: checkboxes
    id: privileged
    attributes:
      label: Privileged issue
      description: Confirm that you are allowed to create an issue here.
      options:
        - label: I'm @tiangolo or he asked me directly to create an issue here.
          required: true
  - type: textarea
    id: content
    attributes:

            )
            text(
                "confirmationCode",
                "",
                label = "Confirmation Code",
                description = "Enter the value '$requiredConfirmationCode' (no quotes) to confirm the promotion",
                display = ParameterDisplay.PROMPT,
                allowEmpty = false,
            )
            text(
                "gitUserName",
                "",

    filesystem.setFaultyDelete(cacheDir / "a.1", true)
    taskFaker.runNextTask()

    // Confirm the partial snapshot is not returned.
    assertThat(cache["a"]).isNull()

    // Confirm we prevent edits after a trim failure.
    assertThat(cache.edit("a")).isNull()

    // Confirm the partial snapshot is not returned after a successful trim.
    filesystem.setFaultyDelete(cacheDir / "a.1", false)

    expectedEvents += ResponseBodyEnd::class
    expectedEvents += ConnectionReleased::class
    expectedEvents += CallEnd::class
    assertThat(eventRecorder.recordedEventTypes()).isEqualTo(expectedEvents)

    // Confirm that the connection pool was not corrupted by making another call.
    makeSimpleCall()
  }

  /**
   * If the server returns a full response, it doesn't really matter if the HTTP/2 stream is reset.

import java.util.concurrent.ThreadFactory
import java.util.concurrent.TimeUnit
import org.junit.jupiter.api.AfterEach
import org.junit.jupiter.api.Tag
import org.junit.jupiter.api.Test

/**
 * Integration test to confirm that [TaskRunner] works with a real backend. Business logic is all
 * exercised by [TaskRunnerTest].
 *
 * This test is doing real sleeping with tolerances of 250 ms. Hopefully that's enough for even the
 * busiest of CI servers.

            else -> {
              call.acquireConnectionNoEvents(connection)
              true
            }
          }
        }
      if (!acquired) continue

      // Confirm the connection is healthy and return it.
      if (connection.isHealthy(doExtensiveHealthChecks)) return connection

      // In the second synchronized block, release the unhealthy acquired connection. We're also on

    }.also { expected ->
      assertThat(expected.message).isEqualTo("timeout")
    }

    // Confirm that a subsequent request on the same connection is not impacted.
    val call2 = client.newCall(Request(server.url("/")))
    val response2 = call2.execute()
    assertThat(response2.body.string()).isEqualTo("A")

    // Confirm that the connection was reused.
    assertThat(server.takeRequest().exchangeIndex).isEqualTo(0)

    val buffer = Buffer()
    buffer.writeUtf8("hello ".repeat(1024))
    assertThat(buffer.isProbablyUtf8(100L)).isTrue()
    assertThat(buffer.readUtf8()).isEqualTo("hello ".repeat(1024))
  }

  /** Confirm [isProbablyUtf8] doesn't attempt to read the entire stream. */
  @Test fun doesNotReadEntireSource() {
    val unlimitedSource =
      object : Source {
        override fun read(
          sink: Buffer,

    serverListener.assertClosing(1000, "goodbye")

    // Confirm that the hard cancel occurred after 500 ms.
    clientListener.assertFailure()
    val elapsedUntilFailure = System.nanoTime() - closeAtNanos
    assertThat(TimeUnit.NANOSECONDS.toMillis(elapsedUntilFailure).toDouble())
      .isCloseTo(500.0, 250.0)

    // Close the server and confirm it saw what we expected.
    server.close(1000, null)