}

  public void testNullListener() {
    try {
      future.addListener(null, directExecutor());
      fail();
    } catch (NullPointerException expected) {
    }
  }

  public void testNullExecutor() {
    try {
      future.addListener(doNothing(), null);
      fail();
    } catch (NullPointerException expected) {
    }
  }

  public void testNullTimeUnit() throws Exception {

    try {
      getList().addAll(0, null);
      fail("addAll(n, null) should throw");
    } catch (NullPointerException expected) {
    }
    expectUnchanged();
  }

  @ListFeature.Require(SUPPORTS_ADD_WITH_INDEX)
  public void testAddAllAtIndex_negative() {
    try {
      getList().addAll(-1, MinimalCollection.of(e3()));
      fail("addAll(-1, e) should throw");

  public void testCopyOf_nullArray() {
    try {
      copyOf((String[]) null);
      fail();
    } catch (NullPointerException expected) {
    }
  }

  public void testCopyOf_arrayContainingOnlyNull() {
    @Nullable String[] array = new @Nullable String[] {null};
    try {
      copyOf((String[]) array);
      fail();
    } catch (NullPointerException expected) {
    }
  }

  public void testCopyOf_nullArray() {
    try {
      copyOf((String[]) null);
      fail();
    } catch (NullPointerException expected) {
    }
  }

  public void testCopyOf_arrayContainingOnlyNull() {
    @Nullable String[] array = new @Nullable String[] {null};
    try {
      copyOf((String[]) array);
      fail();
    } catch (NullPointerException expected) {
    }
  }

    try {
      ImmutableSortedMap.of(n, 1);
      fail();
    } catch (NullPointerException expected) {
    }

    try {
      ImmutableSortedMap.of("one", 1, null, 2);
      fail();
    } catch (NullPointerException expected) {
    }
  }

  public void testOfNullValue() {
    try {
      ImmutableSortedMap.of("one", null);
      fail();
    } catch (NullPointerException expected) {
    }

      iterator.next();
      fail("Expected ConcurrentModificationException");
    } catch (ConcurrentModificationException expected) {
      // success
    }
  }

  @MapFeature.Require(absent = SUPPORTS_PUT)
  @CollectionSize.Require(absent = ZERO)
  public void testPutAll_unsupportedSomePresent() {
    try {
      putAll(MinimalCollection.of(e3(), e0()));
      fail("putAll(somePresent) should throw");

    table = create("foo", 1, 'a', "bar", 1, 'b', "foo", 3, 'c');
    assertSize(3);
    try {
      table.put(null, 2, cellValue('d'));
      fail();
    } catch (NullPointerException expected) {
    }
    try {
      table.put("cat", null, cellValue('d'));
      fail();
    } catch (NullPointerException expected) {
    }
    if (supportsNullValues()) {
      assertNull(table.put("cat", 2, null));

  }

  /**
   * Just like fail(reason), but additionally recording (using threadRecordFailure) any
   * AssertionFailedError thrown, so that the current testcase will fail.
   */
  public void threadFail(String reason) {
    try {
      fail(reason);
    } catch (AssertionFailedError t) {
      threadRecordFailure(t);
      fail(reason);
    }
  }

  /**

    try {
      getMultiset().add(e0(), 2);
      fail("unsupported multiset.add(E, int) didn't throw exception");
    } catch (UnsupportedOperationException required) {
    }
  }

  @CollectionFeature.Require(SUPPORTS_ADD)
  public void testAddOccurrencesNegative() {
    try {
      getMultiset().add(e0(), -1);
      fail("multiset.add(E, -1) didn't throw an exception");

      try {
        BigIntegerMath.ceilingPowerOfTwo(x);
        fail("Expected IllegalArgumentException");
      } catch (IllegalArgumentException expected) {
      }
    }
  }

  public void testFloorPowerOfTwoNegative() {
    for (BigInteger x : NEGATIVE_BIGINTEGER_CANDIDATES) {
      try {
        BigIntegerMath.floorPowerOfTwo(x);
        fail("Expected IllegalArgumentException");