new ForwardingWrapperTester()
        .testForwarding(
            SetMultimap.class,
            new Function<SetMultimap, SetMultimap<?, ?>>() {
              @Override
              public SetMultimap<?, ?> apply(SetMultimap delegate) {
                return wrap((SetMultimap<?, ?>) delegate);
              }
            });
  }

  public void testEquals() {

        .testForwarding(
            SortedSetMultimap.class,
            new Function<SortedSetMultimap, SortedSetMultimap<?, ?>>() {
              @Override
              public SortedSetMultimap<?, ?> apply(SortedSetMultimap delegate) {
                return wrap((SortedSetMultimap<?, ?>) delegate);
              }
            });
  }

  public void testEquals() {

        this.dir = getProject().file(dir);
    }

    @Input
    public int getDirMode() {
        return dirMode;
    }

    /**
     * @param dirMode The permissions to apply to the new directory
     */
    public void setDirMode(int dirMode) {
        this.dirMode = dirMode;
    }

 *     .addEquivalenceGroup("hello", "h" + "ello")
 *     .addEquivalenceGroup("world", "wor" + "ld")
 *     .test();
 * }
 *
 * <p>Note that testing {@link Object#equals(Object)} is more simply done using the {@link
 * EqualsTester}. It includes an extra test against an instance of an arbitrary class without having
 * to explicitly add another equivalence group.
 *
 * @author Gregory Kick
 * @since 10.0
 */

 *     .addEquivalenceGroup("hello", "h" + "ello")
 *     .addEquivalenceGroup("world", "wor" + "ld")
 *     .test();
 * }
 *
 * <p>Note that testing {@link Object#equals(Object)} is more simply done using the {@link
 * EqualsTester}. It includes an extra test against an instance of an arbitrary class without having
 * to explicitly add another equivalence group.
 *
 * @author Gregory Kick
 * @since 10.0
 */

      assertEquals(0, defaultFunction.apply(null));
    }
  }

  public void testGenericInterfaceDefaultValue() {
    new GenericInterfaceDefaultValueChecker().check();
  }

  private interface NullRejectingFromTo<F, T> extends Function<F, T> {
    @Override
    T apply(F from);
  }

        try {
          return InetAddress.getAllByName(hostname).toList()
        } catch (e: NullPointerException) {
          throw UnknownHostException("Broken system behaviour for dns lookup of $hostname").apply {
            initCause(e)
          }
        }
      }
    }
  }

        Request
          .Builder()
          .url("https://example.com/")
          .build(),
      ).protocol(Protocol.HTTP_1_1)
      .code(code)
      .message("OK")
      .body(responseBody)
      .apply { fn() }
      .build()

  private var authenticator = JavaNetAuthenticator()
  private val fakeDns = FakeDns()
  private val recordingAuthenticator = RecordingAuthenticator()
  private val factory =
    TestValueFactory()
      .apply {
        dns = fakeDns
      }

  @BeforeEach
  fun setup() {
    Authenticator.setDefault(recordingAuthenticator)
  }

  @AfterEach
  fun tearDown() {
    Authenticator.setDefault(null)

    return Collections.singleton(reference);
  }

  @Override
  public <V> Optional<V> transform(Function<? super T, V> function) {
    return new Present<>(
        checkNotNull(
            function.apply(reference),
            "the Function passed to Optional.transform() must not return null."));
  }

  @Override
  public boolean equals(@Nullable Object obj) {
    if (obj instanceof Present) {