UnknownHostException(e.message).apply {
                initCause(e)
              },
            )
          }
        },
      )
    } catch (e: Exception) {
      // Handle any errors that might leak out
      // https://issuetracker.google.com/issues/319957694
      callback.onFailure(
        hostname,
        UnknownHostException(e.message).apply {
          initCause(e)
        },
      )

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

            if (userSettingsFileStr != null) {
                userSettingsFile = context.userResolver.apply(userSettingsFileStr);
            }
        }

        Path projectSettingsFile = null;

        if (mavenOptions.altProjectSettings().isPresent()) {
            projectSettingsFile =
                    context.cwdResolver.apply(mavenOptions.altProjectSettings().get());

          C filtered = filter(createUnfiltered(contents), EVEN);
          try {
            assertEquals(expectedResult, filtered.add(toAdd));
            assertTrue(EVEN.apply(toAdd));
          } catch (IllegalArgumentException e) {
            assertFalse(EVEN.apply(toAdd));
          }
        }
      }
    }

    public void testRemove() {
      for (List<Integer> contents : SAMPLE_INPUTS) {

                for (Plugin element : src) {
                    Object key = getPluginKey().apply(element);
                    managedPlugins.put(key, element);
                }

                List<Plugin> newPlugins = new ArrayList<>();
                for (Plugin element : target.getPlugins()) {
                    Object key = getPluginKey().apply(element);
                    Plugin managedPlugin = managedPlugins.get(key);

     */
    fun maxAge(maxAge: Duration) =
      apply {
        val maxAgeSeconds = maxAge.inWholeSeconds
        require(maxAgeSeconds >= 0) { "maxAge < 0: $maxAgeSeconds" }
        this.maxAgeSeconds = maxAgeSeconds.commonClampToInt()
      }

    fun maxStale(maxStale: Duration) =
      apply {
        val maxStaleSeconds = maxStale.inWholeSeconds

  }

  @Override
  protected boolean doEquivalent(F a, F b) {
    return resultEquivalence.equivalent(function.apply(a), function.apply(b));
  }

  @Override
  protected int doHash(F a) {
    return resultEquivalence.hash(function.apply(a));
  }

  @Override
  public boolean equals(@CheckForNull Object obj) {
    if (obj == this) {
      return true;
    }

  @Override
  public ImmutableMap<K, V> getAll(Iterable<? extends K> keys) throws ExecutionException {
    return delegate().getAll(keys);
  }

  @Override
  public V apply(K key) {
    return delegate().apply(key);
  }

  @Override
  public void refresh(K key) {
    delegate().refresh(key);
  }

  /**

public class FilteredMultimapTest extends TestCase {

  private static final Predicate<Entry<String, Integer>> ENTRY_PREDICATE =
      new Predicate<Entry<String, Integer>>() {
        @Override
        public boolean apply(Entry<String, Integer> entry) {
          return !"badkey".equals(entry.getKey()) && !((Integer) 55556).equals(entry.getValue());
        }
      };

  protected Multimap<String, Integer> create() {

              @Override
              public boolean apply(String s) {
                return s.equals("b") || s.equals("d") || s.equals("f");
              }
            }));
    assertEquals(newArrayList("a", "c", "e"), list);
    assertFalse(
        removeIf(
            list,
            new Predicate<String>() {
              @Override
              public boolean apply(String s) {