AsyncFunction<? super I, ? extends O> function, @ParametricNullness I input)
        throws Exception {
      ListenableFuture<? extends O> output = function.apply(input);
      checkNotNull(
          output,
          "AsyncFunction.apply returned null instead of a Future. "
              + "Did you mean to return immediateFuture(null)? %s",
          function);
      return output;
    }

    @Override

        boolean useAll = options.all().orElse(false);
        if (useAll) {
            return true;
        }

        // Apply default behavior: if no specific options are provided, enable --model
        // OR if all options are explicitly disabled, still apply default behavior
        boolean noOptionsSpecified = options.all().isEmpty()
                && options.infer().isEmpty()

 *  GraphConflictResolver by being injected into it
 *
 *
 */
@Deprecated
public interface GraphConflictResolutionPolicy {
    String ROLE = GraphConflictResolutionPolicy.class.getName();

    MetadataGraphEdge apply(MetadataGraphEdge e1, MetadataGraphEdge e2);

import org.junit.jupiter.api.extension.RegisterExtension

class CompressionInterceptorTest {
  @RegisterExtension
  val clientTestRule = OkHttpClientTestRule()

  val source =
    Buffer().apply {
      write("Hello World".encodeUtf8())
    } as Source

  @Test
  fun emptyDoesntChangeRequestOrResponse() {
    val empty = CompressionInterceptor()
    val client =
      clientTestRule

        if (request.header("Accept") == null) {
          request.newBuilder().addHeader("Accept", "text/event-stream").build()
        } else {
          request
        }

      RealEventSource(actualRequest, listener).apply {
        connect(callFactory)
      }
    }

  @JvmStatic
  fun processResponse(
    response: Response,
    listener: EventSourceListener,
  ) {

  }

  @Override
  protected String getSuccessfulResult() {
    return RESULT_DATA;
  }

  private class ComposeFunction implements Function<Integer, String> {
    @Override
    public String apply(Integer input) {
      if (input.intValue() == VALID_INPUT_DATA) {
        return RESULT_DATA;
      } else {
        throw WRAPPED_EXCEPTION;
      }
    }
  }

  public void testPredicateMethods() {
    Range<Integer> predicate = Range.closed(2, 3);

    assertFalse(predicate.apply(1));
    assertTrue(predicate.apply(2));
    assertTrue(predicate.apply(3));
    assertFalse(predicate.apply(4));
  }

  public void testEquals() {
    new EqualsTester()
        .addEqualityGroup(Range.open(1, 5), Range.range(1, OPEN, 5, OPEN))

        return !changed || ComponentUtil.getFessConfig().isLdapAdminSyncPassword();
    }

    @Override
    public User load(final User user) {
        ComponentUtil.getLdapManager().apply(user);
        return user;
    }

import okhttp3.tls.HandshakeCertificates
import okhttp3.tls.internal.TlsUtil

class DevServer {
  val handshakeCertificates = TlsUtil.localhost()

  val server =
    MockWebServer().apply {
      useHttps(handshakeCertificates.sslSocketFactory(), false)

      enqueue(
        MockResponse()
          .setResponseCode(HTTP_MOVED_TEMP)
          .setHeader("Location", "https://www.google.com/robots.txt"),

import org.junit.runners.model.Statement

class MockWebServerRuleTest {
  @Test fun statementStartsAndStops() {
    val rule = MockWebServerRule()
    val called = AtomicBoolean()
    val statement: Statement =
      rule.apply(
        object : Statement() {
          override fun evaluate() {
            called.set(true)
            rule.server
              .url("/")
              .toUrl()
              .openConnection()