assertThat(keySet).containsExactly(6, 8, 0, 1, 2, 5, 7, 9);

    // 6 expires
    ticker.advance(1, MILLISECONDS);
    assertThat(keySet).containsExactly(8, 0, 1, 2, 5, 7, 9);
    ticker.advance(1, MILLISECONDS);
    assertThat(keySet).containsExactly(8, 0, 1, 2, 5, 7, 9);

    // 8 expires
    ticker.advance(1, MILLISECONDS);
    assertThat(keySet).containsExactly(0, 1, 2, 5, 7, 9);
  }

    assertTrue(graphAsMutableGraph.putEdge(N2, N3));
    assertThat(graph.nodes()).containsExactly(N1, N5, N4, N2, N3).inOrder();
    assertThat(graph.adjacentNodes(N1)).containsExactly(N4, N5);
    assertThat(graph.adjacentNodes(N2)).containsExactly(N3);
    assertThat(graph.adjacentNodes(N3)).containsExactly(N2);
    assertThat(graph.adjacentNodes(N4)).containsExactly(N1);
    assertThat(graph.adjacentNodes(N5)).containsExactly(N1);
  }

    }.also { expected ->
      assertThat(expected.message)
        .isEqualTo("Control frames must be final.")
    }
  }

  @Test fun reservedFlag1IsUnsupportedWithNoCompression() {
    data.write("ca00".decodeHex()) // Empty pong, flag 1 set.
    assertFailsWith<ProtocolException> {
      clientReader.processNextFrame()
    }.also { expected ->
      assertThat(expected.message).isEqualTo("Unexpected rsv1 flag")
    }

    assertThat(cacheControl.noStore).isFalse()
    assertThat(cacheControl.maxAgeSeconds).isEqualTo(-1)
    assertThat(cacheControl.sMaxAgeSeconds).isEqualTo(-1)
    assertThat(cacheControl.isPrivate).isFalse()
    assertThat(cacheControl.isPublic).isFalse()
    assertThat(cacheControl.mustRevalidate).isFalse()
    assertThat(cacheControl.maxStaleSeconds).isEqualTo(-1)
    assertThat(cacheControl.minFreshSeconds).isEqualTo(-1)

    assertThat(UnsignedLongs.divide(0xfffffffffffffffeL, 2)).isEqualTo(0x7fffffffffffffffL);
    assertThat(UnsignedLongs.divide(0xfffffffffffffffeL, 5)).isEqualTo(3689348814741910322L);
  }

  public void testRemainder() {
    assertThat(UnsignedLongs.remainder(14, 5)).isEqualTo(4);
    assertThat(UnsignedLongs.remainder(0, 50)).isEqualTo(0);
    assertThat(UnsignedLongs.remainder(0xfffffffffffffffeL, 0xfffffffffffffffdL)).isEqualTo(1);

    assertThat(challenges.size).isEqualTo(1)
    assertThat(challenges[0].scheme).isEqualTo("Digest")
    assertThat(challenges[0].realm).isNull()
    assertThat(challenges[0].authParams).isEqualTo(emptyMap<Any, Any>())
  }

  @Test fun basicChallenge() {
    val headers =
      Headers
        .Builder()
        .add("WWW-Authenticate: Basic realm=\"protected area\"")
        .build()

    val set: MutableSet<Any> = CopyOnWriteArraySet()
    assertThat(set.add(ConnectionSpec.MODERN_TLS)).isTrue()
    assertThat(set.add(ConnectionSpec.COMPATIBLE_TLS)).isTrue()
    assertThat(set.add(ConnectionSpec.CLEARTEXT)).isTrue()
    assertThat(set.add(allTlsVersions)).isTrue()
    assertThat(set.add(allCipherSuites)).isTrue()
    allCipherSuites.hashCode()
    assertThat(allCipherSuites.equals(null)).isFalse()

        assertThat(map.get(null), is(nullValue()));
        assertThat(map.get("test3"), is(nullValue()));
        assertThat(map.getAt(0), is(nullValue()));
    }

    /**
     * @throws Exception
     */
    @Test
    public void testPut() throws Exception {
        assertThat(map.put("1", "test3"), is("test"));
        assertThat(map.get("1"), is("test3"));

    val contentType = requestBody.contentType()!!

    assertThat(contentType.mediaType).isEqualTo("text/plain; charset=utf-8")
    assertThat(contentType.parameter("charset")).isEqualTo("utf-8")
  }

    assertThat(graphA.nodeOrder()).isEqualTo(graphB.nodeOrder());

    assertThat(graphA).isEqualTo(graphB);
  }

  static void assertStronglyEquivalent(Network<?, ?> networkA, Network<?, ?> networkB) {
    // Properties not covered by equals()
    assertThat(networkA.allowsParallelEdges()).isEqualTo(networkB.allowsParallelEdges());
    assertThat(networkA.allowsSelfLoops()).isEqualTo(networkB.allowsSelfLoops());