putEdge(N1, N2);
    assertThat(graph.inDegree(N2)).isEqualTo(1);
    // Edge direction handled correctly
    assertThat(graph.inDegree(N1)).isEqualTo(0);
  }

  @Test
  public void outDegree_oneEdge() {
    putEdge(N1, N2);
    assertThat(graph.outDegree(N1)).isEqualTo(1);
    // Edge direction handled correctly
    assertThat(graph.outDegree(N2)).isEqualTo(0);
  }

  @Test

    byte[] b5 = "スューー".getBytes(Charsets.US_ASCII);
    // Assert they are all equal (using the transitive property)
    assertThat(b1).isEqualTo(b2);
    assertThat(b2).isEqualTo(b3);
    assertThat(b3).isEqualTo(b4);
    assertThat(b4).isEqualTo(b5);
  }

    val response = client.newCall(request).execute()
    assertThat(response.code).isEqualTo(200)
    assertThat(response.body.string()).isEqualTo("thank you for retrying")
    assertThat(server.takeRequest().body?.utf8()).isEqualTo("attempt 0")
    assertThat(server.takeRequest().body?.utf8()).isEqualTo("attempt 1")
    assertThat(server.requestCount).isEqualTo(2)
  }

  @Test
  fun cannotRetryOneShotRequestBody() {

  public void testToString() {
    assertThat(md5().toString()).isEqualTo("Hashing.md5()");
    assertThat(sha1().toString()).isEqualTo("Hashing.sha1()");
    assertThat(sha256().toString()).isEqualTo("Hashing.sha256()");
    assertThat(sha512().toString()).isEqualTo("Hashing.sha512()");
  }

  private static void assertMessageDigestHashing(byte[] input, String algorithmName)

          headerBlock: List<Header>,
        ) {
          assertThat(inFinished).isTrue()
          assertThat(streamId).isEqualTo(expectedStreamId)
          assertThat(associatedStreamId).isEqualTo(-1)
          assertThat(headerBlock).isEqualTo(sentHeaders)
        }
      },
    )
  }

  @Test fun headersWithPriority() {
    val sentHeaders = headerEntries("name", "value")
    val headerBytes = literalHeaders(sentHeaders)

    String expectedToString = "cdab0000";

    assertEquals(expectedInt, hashCode.asInt());
    assertThat(hashCode.toString()).isEqualTo(expectedToString);

    bytes[0] = (byte) 0x00;

    assertEquals(expectedInt, hashCode.asInt());
    assertThat(hashCode.toString()).isEqualTo(expectedToString);
  }

  public void testFromBytesNoCopy_noCopyOccurs() {

      .assertFailureMatches("stream was reset: REFUSED_STREAM")

    assertThat(client.routeDatabase.failedRoutes).isEmpty()
    server1.takeRequest()
    assertThat(server1.requestCount).isEqualTo(1)
    assertThat(server2.requestCount).isEqualTo(0)

    assertThat(clientTestRule.recordedConnectionEventTypes()).containsExactly(
      "ConnectStart",
      "ConnectEnd",
      "ConnectionAcquired",
      "ConnectionReleased",

import assertk.assertions.isEqualTo
import assertk.assertions.isNull
import java.time.Instant
import java.util.Date
import okhttp3.Headers.Companion.headersOf
import org.junit.jupiter.api.Test

class HeadersKotlinTest {
  @Test fun getOperator() {
    val headers = headersOf("a", "b", "c", "d")
    assertThat(headers["a"]).isEqualTo("b")
    assertThat(headers["c"]).isEqualTo("d")
    assertThat(headers["e"]).isNull()

    assertThat(HashCode.fromBytes(mac.doFinal()).toString()).isEqualTo(knownOutput);
    assertThat(HashCode.fromBytes(mac.doFinal(input.getBytes(UTF_8))).toString())
        .isEqualTo(knownOutput);
    assertThat(hmacMd5(MD5_KEY).hashString(input, UTF_8).toString()).isEqualTo(knownOutput);
    assertThat(hmacMd5(MD5_KEY).hashBytes(input.getBytes(UTF_8)).toString()).isEqualTo(knownOutput);
  }

    assertThat(table.toString()).isEqualTo("{bar={1=b}, foo={1=a, 3=c}}");
    assertThat(table.rowMap().toString()).isEqualTo("{bar={1=b}, foo={1=a, 3=c}}");
  }

  public void testCellSetToString_ordered() {
    table = create("foo", 1, 'a', "bar", 1, 'b', "foo", 3, 'c');
    assertThat(table.cellSet().toString()).isEqualTo("[(bar,1)=b, (foo,1)=a, (foo,3)=c]");
  }