try {
      result = supplier.get();
    } catch (Throwable t) {
      if (predicate.apply(t)) {
        // We are careful to set up INSTANCE_OF to match each Predicate to its target Class.
        @SuppressWarnings("unchecked")
        T caught = (T) t;
        return caught;
      }
      throw new AssertionError(
          "expected to throw " + expectedThrowable.getSimpleName() + " but threw " + t, t);
    }

            .withFeatures(CollectionSize.ANY, CollectionFeature.ALLOWS_NULL_QUERIES)
            .createTestSuite());

    return suite;
  }

  @SuppressWarnings({"rawtypes", "unchecked"})
  public void testForwarding() {
    new ForwardingWrapperTester()
        .testForwarding(
            List.class,
            new Function<List, List>() {
              @Override

                CollectionFeature.GENERAL_PURPOSE,
                CollectionFeature.ALLOWS_NULL_QUERIES)
            .createTestSuite());

    return suite;
  }

  @SuppressWarnings({"rawtypes", "unchecked"})
  public void testForwarding() {
    new ForwardingWrapperTester()
        .testForwarding(
            SortedMultiset.class,
            new Function<SortedMultiset, SortedMultiset>() {
              @Override

    try {
      result = supplier.get();
    } catch (Throwable t) {
      if (predicate.apply(t)) {
        // We are careful to set up INSTANCE_OF to match each Predicate to its target Class.
        @SuppressWarnings("unchecked")
        T caught = (T) t;
        return caught;
      }
      throw new AssertionError(
          "expected to throw " + expectedThrowable.getSimpleName() + " but threw " + t, t);
    }

    try {
      result = supplier.get();
    } catch (Throwable t) {
      if (predicate.apply(t)) {
        // We are careful to set up INSTANCE_OF to match each Predicate to its target Class.
        @SuppressWarnings("unchecked")
        T caught = (T) t;
        return caught;
      }
      throw new AssertionError(
          "expected to throw " + expectedThrowable.getSimpleName() + " but threw " + t, t);
    }

    try {
      result = supplier.get();
    } catch (Throwable t) {
      if (predicate.apply(t)) {
        // We are careful to set up INSTANCE_OF to match each Predicate to its target Class.
        @SuppressWarnings("unchecked")
        T caught = (T) t;
        return caught;
      }
      throw new AssertionError(
          "expected to throw " + expectedThrowable.getSimpleName() + " but threw " + t, t);
    }

 * way to check an object at runtime to be an instance of a {@link TypeToken}. Instead, caller
 * should use the type safe {@link #putInstance}.
 *
 * <p>Also, if caller suppresses unchecked warnings and passes in an {@code Iterable<String>} for
 * type {@code Iterable<Integer>}, the map won't be able to detect and throw type error.
 *

    verify(primitiveSink).putLong(1234);
  }

  public void testForLongs_null() {
    assertNullsThrowException(Funnels.longFunnel());
  }

  public void testSequential() {
    @SuppressWarnings({"unchecked", "DoNotMock"})
    Funnel<Object> elementFunnel = mock(Funnel.class);
    PrimitiveSink primitiveSink = mock(PrimitiveSink.class);
    Funnel<Iterable<?>> sequential = Funnels.sequentialFunnel(elementFunnel);

 * way to check an object at runtime to be an instance of a {@link TypeToken}. Instead, caller
 * should use the type safe {@link #putInstance}.
 *
 * <p>Also, if caller suppresses unchecked warnings and passes in an {@code Iterable<String>} for
 * type {@code Iterable<Integer>}, the map won't be able to detect and throw type error.
 *

                  // Other tests will verify what real, warning-free usage looks like
                  // but here we have to do some serious fudging
                  @Override
                  @SuppressWarnings({"unchecked", "rawtypes"})
                  public Map<Class, Impl> create(Object... elements) {
                    MutableClassToInstanceMap<Impl> map = MutableClassToInstanceMap.create();
                    for (Object object : elements) {