var result = cachedDns.lookup("google.com")
    assertThat(result).containsExactly(address("157.240.1.18"))
    var recordedRequest = server.takeRequest()
    assertThat(recordedRequest.method).isEqualTo("GET")
    assertThat(recordedRequest.url.encodedQuery)
      .isEqualTo("ct&dns=AAABAAABAAAAAAAABmdvb2dsZQNjb20AAAEAAQ")

    assertThat(cacheEvents()).containsExactly("CacheMiss")

    result = cachedDns.lookup("google.com")

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package okhttp3.dnsoverhttps

import assertk.assertThat
import assertk.assertions.containsExactly
import assertk.assertions.isEqualTo
import java.net.InetAddress
import java.net.UnknownHostException
import kotlin.test.assertFailsWith
import okhttp3.dnsoverhttps.DnsRecordCodec.TYPE_A

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package mockwebserver3

import assertk.assertThat
import assertk.assertions.containsExactly
import assertk.assertions.isEmpty
import assertk.assertions.isEqualTo
import assertk.assertions.isTrue
import mockwebserver3.junit5.StartStop
import okhttp3.Dns
import okhttp3.Headers.Companion.headersOf

      assertThat(headersToList(response)).containsExactly("Content-Length: 0")
    }
  }

  @Test
  fun setStatusControlsWholeStatusLine() {
    val response = MockResponse().setStatus("HTTP/1.1 202 That'll do pig")
    assertThat(headersToList(response)).containsExactly("Content-Length: 0")
    assertThat(response.status).isEqualTo("HTTP/1.1 202 That'll do pig")
  }

      .containsExactly("a", "\uD83C\uDF69", "c")
    assertThat(parse("http://host/a/%62/c").pathSegments)
      .containsExactly("a", "b", "c")
    assertThat(parse("http://host/a/%7A/c").pathSegments)
      .containsExactly("a", "z", "c")
    assertThat(parse("http://host/a/%7a/c").pathSegments)
      .containsExactly("a", "z", "c")
  }

  @Test

    assertThat(elementSet).containsExactly("a", "b", "c", "d", "e", "f").inOrder();
    SortedSet<String> subset = elementSet.subSet("b", "f");
    assertThat(subset).containsExactly("b", "c", "d", "e").inOrder();

    assertTrue(subset.remove("c"));
    assertThat(elementSet).containsExactly("a", "b", "d", "e", "f").inOrder();
    assertThat(subset).containsExactly("b", "d", "e").inOrder();
    assertEquals(10, ms.size());

    assertThat(set.headSet(2)).containsExactly(1).inOrder();
    assertThat(set.headSet(3)).containsExactly(1, 2).inOrder();
    assertThat(set.headSet(4)).containsExactly(1, 2, 3).inOrder();
    assertThat(set.headSet(Integer.MAX_VALUE)).containsExactly(1, 2, 3).inOrder();
    assertThat(set.headSet(1, true)).containsExactly(1).inOrder();
    assertThat(set.headSet(2, true)).containsExactly(1, 2).inOrder();

      assertThat(headersToList(builder)).containsExactly("Content-Length: 0")
    }
  }

  @Test
  fun setStatusControlsWholeStatusLine() {
    val builder = MockResponse.Builder().status("HTTP/1.1 202 That'll do pig")
    assertThat(headersToList(builder)).containsExactly("Content-Length: 0")
    assertThat(builder.status).isEqualTo("HTTP/1.1 202 That'll do pig")
  }

  }

  public void testOf1() {
    assertThat(ImmutableLongArray.of(0).asList()).containsExactly(0L);
  }

  public void testOf2() {
    assertThat(ImmutableLongArray.of(0, 1).asList()).containsExactly(0L, 1L).inOrder();
  }

  public void testOf3() {
    assertThat(ImmutableLongArray.of(0, 1, 3).asList()).containsExactly(0L, 1L, 3L).inOrder();
  }

  public void testOf4() {

    assertThat(network.edgesConnecting(N1, N1)).containsExactly(E11);
    assertThat(network.edgesConnecting(N1, N2)).containsExactly(E12);
    assertTrue(networkAsMutableNetwork.removeEdge(E11));
    assertThat(network.edgesConnecting(N1, N1)).isEmpty();
    assertThat(network.edgesConnecting(N1, N2)).containsExactly(E12);
  }

  @Test
  public void concurrentIteration() throws Exception {