}

  public <T> void testWhere_incompatibleGenericArrayMapping() {
    assertThrows(
        IllegalArgumentException.class,
        () -> new TypeResolver().where(new TypeCapture<T[]>() {}.capture(), String.class));
  }

  public <T> void testWhere_incompatibleParameterizedTypeMapping() {
    assertThrows(
        IllegalArgumentException.class,

      assertThrows(IllegalArgumentException.class, () -> IntMath.gcd(a, 3));
      assertThrows(IllegalArgumentException.class, () -> IntMath.gcd(3, a));
    }
  }

  public void testGCDNegativeZeroThrows() {
    for (int a : NEGATIVE_INTEGER_CANDIDATES) {
      assertThrows(IllegalArgumentException.class, () -> IntMath.gcd(a, 0));

    for (long x : NEGATIVE_LONG_CANDIDATES) {
      assertThrows(IllegalArgumentException.class, () -> LongMath.ceilingPowerOfTwo(x));
    }
  }

  public void testFloorPowerOfTwoNegative() {
    for (long x : NEGATIVE_LONG_CANDIDATES) {
      assertThrows(IllegalArgumentException.class, () -> LongMath.floorPowerOfTwo(x));
    }
  }

  public void testCeilingPowerOfTwoZero() {

import static com.google.common.truth.Truth.assertThat;
import static java.lang.annotation.RetentionPolicy.RUNTIME;
import static org.junit.Assert.assertThrows;

import com.google.common.collect.ImmutableSet;
import com.google.common.collect.testing.features.FeatureUtilTest.ExampleFeature.NotTesterAnnotation;

  public final void testClear() {
    for (Table<Character, Integer, String> testInstance : getTestInstances()) {
      assertThrows(UnsupportedOperationException.class, () -> testInstance.clear());
    }
  }

  public final void testPut() {
    for (Table<Character, Integer, String> testInstance : getTestInstances()) {
      assertThrows(UnsupportedOperationException.class, () -> testInstance.put('a', 1, "blah"));
    }
  }

    assertThat(
      assertThrows<IllegalStateException> {
        checkDuration("timeout", -1, TimeUnit.MILLISECONDS)
      },
    ).hasMessage("timeout < 0")
    assertThat(
      assertThrows<IllegalArgumentException> {
        checkDuration("timeout", 1, TimeUnit.NANOSECONDS)
      },
    ).hasMessage("timeout too small")
    assertThat(
      assertThrows<IllegalArgumentException> {
        checkDuration(

    assertThrows(IllegalArgumentException.class, () -> range.gap(Range.closed(2, 3)));
  }

  public void testGap_invalidRangesWithInfinity() {
    assertThrows(IllegalArgumentException.class, () -> Range.atLeast(1).gap(Range.atLeast(2)));

    assertThrows(IllegalArgumentException.class, () -> Range.atLeast(2).gap(Range.atLeast(1)));

        assertThrows(IllegalStateException.class, n1AdjacentNodes::size));
    assertNodeRemovedFromGraphErrorMessage(
        assertThrows(IllegalStateException.class, n1Predecessors::size));
    assertNodeRemovedFromGraphErrorMessage(
        assertThrows(IllegalStateException.class, n1Successors::size));
    assertNodeRemovedFromGraphErrorMessage(

      Set<Object> keys = cache.asMap().keySet();
      assertThrows(NullPointerException.class, () -> keys.toArray((Object[]) null));
      checkEmpty(cache);
    }
  }

  public void testKeySet_addNotSupported() {
    for (LoadingCache<Object, Object> cache : caches()) {
      assertThrows(UnsupportedOperationException.class, () -> cache.asMap().keySet().add(1));

      assertThrows(

      Set<Object> keys = cache.asMap().keySet();
      assertThrows(NullPointerException.class, () -> keys.toArray((Object[]) null));
      checkEmpty(cache);
    }
  }

  public void testKeySet_addNotSupported() {
    for (LoadingCache<Object, Object> cache : caches()) {
      assertThrows(UnsupportedOperationException.class, () -> cache.asMap().keySet().add(1));

      assertThrows(