expectContents(expected);
  }

  @MapFeature.Require(value = SUPPORTS_PUT, absent = ALLOWS_NULL_KEYS)
  public void testPut_nullKeyUnsupported() {
    assertThrows(NullPointerException.class, () -> put(nullKeyEntry));
    expectUnchanged();
    expectNullKeyMissingWhenNullKeysUnsupported(
        "Should not contain null key after unsupported put(null, value)");
  }

  public void testContainsEntryNullDisallowedBecauseKeyQueriesDisallowed() {
    assertThrows(NullPointerException.class, () -> multimap().containsEntry(null, v3()));
  }

  @MapFeature.Require(absent = ALLOWS_NULL_VALUE_QUERIES)
  public void testContainsEntryNullDisallowedBecauseValueQueriesDisallowed() {
    assertThrows(NullPointerException.class, () -> multimap().containsEntry(k3(), null));
  }

        final VaMessenger<FessMessages> messageCode = messages -> messages.addErrorsInvalidQueryUnknown(UserMessages.GLOBAL_PROPERTY_KEY);

        final NullPointerException npeCause = new NullPointerException("Null query parameter");
        final IllegalStateException iseCause = new IllegalStateException("Invalid parser state");
        final OutOfMemoryError oomCause = new OutOfMemoryError("Query too large");

  public void testNullListener() {
    assertThrows(NullPointerException.class, () -> future.addListener(null, directExecutor()));
  }

  public void testNullExecutor() {
    assertThrows(NullPointerException.class, () -> future.addListener(doNothing(), null));
  }

  public void testNullTimeUnit() throws Exception {
    future.set(1);
    assertThrows(NullPointerException.class, () -> future.get(0, null));
  }

    assertEquals("multiset.count(null) didn't return 0", 0, getMultiset().count(null));
  }

  @CollectionFeature.Require(absent = ALLOWS_NULL_QUERIES)
  public void testCount_null_forbidden() {
    assertThrows(NullPointerException.class, () -> getMultiset().count(null));
  }

  @CollectionSize.Require(absent = ZERO)
  @CollectionFeature.Require(ALLOWS_NULL_VALUES)
  public void testCount_nullPresent() {
    initCollectionWithNullElement();

@GwtCompatible
final class CollectPreconditions {

  static void checkEntryNotNull(Object key, Object value) {
    if (key == null) {
      throw new NullPointerException("null key in entry: null=" + value);
    } else if (value == null) {
      throw new NullPointerException("null value in entry: " + key + "=null");
    }
  }

  @CanIgnoreReturnValue
  static int checkNonnegative(int value, String name) {
    if (value < 0) {

    assertThrows(NullPointerException.class, () -> multimap().putAll(source));
    expectUnchanged();
  }

  @MapFeature.Require(value = SUPPORTS_PUT, absent = ALLOWS_NULL_KEYS)
  public void testPutAllRejectsNullKey() {
    Multimap<K, V> source = getSubjectGenerator().create(mapEntry(null, v0()));
    assertThrows(NullPointerException.class, () -> multimap().putAll(source));
    expectUnchanged();

    this(new TreeMap<K, V>(map));
  }

  private SafeTreeMap(NavigableMap<K, V> delegate) {
    this.delegate = delegate;
    if (delegate == null) {
      throw new NullPointerException();
    }
    for (K k : keySet()) {
      checkValid(k);
    }
  }

  @Override
  public @Nullable Entry<K, V> ceilingEntry(K key) {
    return delegate.ceilingEntry(checkValid(key));
  }

      // Returning successfully is not ideal, but tolerated.
    } catch (NullPointerException tolerated) {
    }
  }

  @CollectionFeature.Require(SUPPORTS_REMOVE)
  @CollectionSize.Require(absent = ZERO)
  public void testRemoveAll_nullCollectionReferenceNonEmptySubject() {
    assertThrows(NullPointerException.class, () -> collection.removeAll(null));
  }

  }

  @MapFeature.Require(value = SUPPORTS_REMOVE, absent = ALLOWS_NULL_KEY_QUERIES)
  public void testRemove_nullKeyQueriesUnsupported() {
    try {
      assertFalse(getMap().remove(null, v3()));
    } catch (NullPointerException tolerated) {
      // since the operation would be a no-op, the exception is not required
    }
    expectUnchanged();
  }

  @MapFeature.Require(value = SUPPORTS_REMOVE, absent = ALLOWS_NULL_VALUE_QUERIES)