apply {
      assertThat(response!!.code).isEqualTo(expectedCode)
    }

  fun assertSuccessful() =
    apply {
      assertThat(failure).isNull()
      assertThat(response!!.isSuccessful).isTrue()
    }

  fun assertNotSuccessful() =
    apply {
      assertThat(response!!.isSuccessful).isFalse()
    }

  fun assertHeader(
    name: String,
    vararg values: String?,
  ) = apply {

    return Collector.of(
        (Supplier<ImmutableTable.Builder<R, C, V>>) ImmutableTable.Builder::new,
        (builder, t) ->
            builder.put(rowFunction.apply(t), columnFunction.apply(t), valueFunction.apply(t)),
        ImmutableTable.Builder::combine,
        ImmutableTable.Builder::buildOrThrow);
  }

  static <T extends @Nullable Object, R, C, V>

        assertTrue(isNotEmpty.apply("test"));
        assertTrue(isNotEmpty.apply("a"));
        assertFalse(isNotEmpty.apply(""));
        assertFalse(isNotEmpty.apply(null));
    }

    public void test_apply_integer() {
        BooleanFunction<Integer> isPositive = n -> n != null && n > 0;

        assertTrue(isPositive.apply(1));
        assertTrue(isPositive.apply(100));
        assertFalse(isPositive.apply(0));

    T instance = generator.newFreshProxy(interfaceType);
    new EqualsTester()
        .addEqualityGroup(wrapperFunction.apply(instance), wrapperFunction.apply(instance))
        .addEqualityGroup(wrapperFunction.apply(generator.newFreshProxy(interfaceType)))
        // TODO: add an overload to EqualsTester to print custom error message?
        .testEquals();
  }

    assertThat(retryTlsHandshake(exception)).isFalse()
  }

  @Test fun nonRetryableSSLHandshakeException() {
    val exception =
      SSLHandshakeException("Certificate handshake exception").apply {
        initCause(CertificateException())
      }
    assertThat(retryTlsHandshake(exception)).isFalse()
  }

  @Test fun retryableSSLHandshakeException() {

  )

internal fun CacheControl.Builder.commonNoCache() =
  apply {
    this.noCache = true
  }

internal fun CacheControl.Builder.commonNoStore() =
  apply {
    this.noStore = true
  }

internal fun CacheControl.Builder.commonOnlyIfCached() =
  apply {
    this.onlyIfCached = true
  }

internal fun CacheControl.Builder.commonNoTransform() =
  apply {
    this.noTransform = true
  }

  @StartStop val serverA =
    MockWebServer().apply {
      dispatcher = dispatcherA
    }

  private val dispatcherB = ClosableDispatcher()

  @StartStop val serverB =
    MockWebServer().apply {
      dispatcher = dispatcherB
    }

  /** This one won't start because it isn't annotated. */
  private val dispatcherC = ClosableDispatcher()
  val serverC =
    MockWebServer().apply {
      dispatcher = dispatcherC
    }

        else -> "Mock Response"
      }
    return apply { status = "HTTP/1.1 $code $reason" }
  }

  fun clearHeaders() =
    apply {
      headersBuilder = Headers.Builder()
    }

  fun addHeader(header: String) =
    apply {
      headersBuilder.add(header)
    }

  fun addHeader(
    name: String,
    value: Any,
  ) = apply {
    headersBuilder.add(name, value.toString())
  }

            .catching(
                Throwable.class,
                new Function<Throwable, Class<?>>() {
                  @Override
                  public Class<?> apply(Throwable input) {
                    return input.getClass();
                  }
                },
                directExecutor());
    assertThat(f.get()).isEqualTo(CustomRuntimeException.class);
  }

    return Collector.of(
        (Supplier<ImmutableTable.Builder<R, C, V>>) ImmutableTable.Builder::new,
        (builder, t) ->
            builder.put(rowFunction.apply(t), columnFunction.apply(t), valueFunction.apply(t)),
        ImmutableTable.Builder::combine,
        ImmutableTable.Builder::buildOrThrow);
  }

  static <T extends @Nullable Object, R, C, V>