return suite;
  }

  protected Collection<Method> suppressForEmptyList() {
    return emptySet();
  }

  protected Collection<Method> suppressForSingletonList() {
    return emptySet();
  }

  protected Collection<Method> suppressForArraysAsList() {
    return emptySet();
  }

  protected Collection<Method> suppressForArrayList() {
    return emptySet();
  }

      for (Method method : RawTypeConsistencyTester.class.getDeclaredMethods()) {
        assertEquals(
            method.getReturnType(), TypeToken.of(method.getGenericReturnType()).getRawType());
        for (int i = 0; i < method.getParameterTypes().length; i++) {
          assertEquals(
              method.getParameterTypes()[i],
              TypeToken.of(method.getGenericParameterTypes()[i]).getRawType());

Benchmarks can use the new [B.Loop] method in `for b.Loop() { ... }` loops to determine if iteration should continue....

  public void testAllOverloads_checkArgument() throws Exception {
    for (ImmutableList<Class<?>> sig : allSignatures(boolean.class)) {
      Method checkArgumentMethod =
          Preconditions.class.getMethod("checkArgument", sig.toArray(new Class<?>[] {}));
      checkArgumentMethod.invoke(null /* static method */, getParametersForSignature(true, sig));

      Object[] failingParams = getParametersForSignature(false, sig);

 * provided {@code standardAddAll} method.
 *
 * <p><b>{@code default} method warning:</b> This class does <i>not</i> forward calls to {@code
 * default} methods. Instead, it inherits their default implementations. When those implementations
 * invoke methods, they invoke methods on the {@code ForwardingSet}.
 *
 * <p>The {@code standard} methods are not guaranteed to be thread-safe, even when all of the

 * limitations under the License.
 */

package com.google.common.eventbus;

import com.google.common.testing.AbstractPackageSanityTests;
import java.lang.reflect.Method;
import org.checkerframework.checker.nullness.qual.Nullable;

/**
 * Basic sanity tests for the entire package.
 *
 * @author Ben Yu
 */

public class PackageSanityTests extends AbstractPackageSanityTests {

 * Annotated fields must not be null after construction has completed.
 * <p>
 * When this annotation is applied to a method it applies to the method return value.
 *
 * @see Nullable
 * @since 4.0.0
 */
@Experimental
@Documented
@Retention(RetentionPolicy.CLASS)
@Target({ElementType.FIELD, ElementType.PARAMETER, ElementType.METHOD})

import com.google.common.testing.ForwardingWrapperTester;
import java.lang.reflect.Method;
import java.util.Arrays;

/**
 * Tester for typical subclass of {@link ForwardingObject} by using Mockito.
 *
 * @author Ben Yu
 */
final class ForwardingObjectTester {

  private static final Method DELEGATE_METHOD;

  static {
    try {

 * provided {@code standardOffer} method.
 *
 * <p><b>{@code default} method warning:</b> This class does <i>not</i> forward calls to {@code
 * default} methods. Instead, it inherits their default implementations. When those implementations
 * invoke methods, they invoke methods on the {@code ForwardingQueue}.
 *
 * <p>The {@code standard} methods are not guaranteed to be thread-safe, even when all of the

    for (String propertyName : new String[] {"value", "absent"}) {
      Method method = null;
      try {
        method = annotationClass.getMethod(propertyName);
      } catch (NoSuchMethodException e) {
        throw new AssertionError("Annotation is missing required method", e);
      }
      final Class<?> returnType = method.getReturnType();
      assertTrue(