Entry<String, Collection<Integer>> entry = iterator.next();
    assertThat(entry.getKey()).isNull();
    assertThat(entry.getValue()).containsExactly(7, 3, 1);
    entry = iterator.next();
    assertThat(entry.getKey()).isEqualTo("tree");
    assertThat(entry.getValue()).containsExactly(null, 0);
    entry = iterator.next();
    assertThat(entry.getKey()).isEqualTo("google");
    assertThat(entry.getValue()).containsExactly(6, 2);
  }

          reverse(samples.e3()),
          reverse(samples.e4()));
    }

    private Entry<V, K> reverse(Entry<K, V> entry) {
      checkNotNull(entry);
      return mapEntry(entry.getValue(), entry.getKey());
    }

    @SuppressWarnings("unchecked")
    @Override
    public BiMap<V, K> create(Object... elements) {
      Entry<?, ?>[] entries = new Entry<?, ?>[elements.length];

                case 0:
                    return emptyMap();
                case 1:
                    Map.Entry<K, V> entry = map.entrySet().iterator().next();
                    return singletonMap(entry.getKey(), entry.getValue());
                default:
                    return new MapN<>(map);
            }
        }
    }

    @SuppressWarnings("unchecked")
    static <K, V> Map<K, V> emptyMap() {

 * stream was closed. Intended for use in a test where only a single stream should be opened and
 * possibly closed.
 *
 * @author Colin Decker
 */
@NullUnmarked
public interface TestStreamSupplier {

  /** Returns whether or not a new stream was opened. */
  boolean wasStreamOpened();

  /** Returns whether or not an open stream was closed. */

 * stream was closed. Intended for use in a test where only a single stream should be opened and
 * possibly closed.
 *
 * @author Colin Decker
 */
@NullUnmarked
public interface TestStreamSupplier {

  /** Returns whether or not a new stream was opened. */
  boolean wasStreamOpened();

  /** Returns whether or not an open stream was closed. */

    if (entry == null) {
      throw new NoSuchElementException();
    } else {
      return entry.getKey();
    }
  }

  @Override
  @ParametricNullness
  public K lastKey() {
    Entry<K, V> entry = lastEntry();
    if (entry == null) {
      throw new NoSuchElementException();
    } else {
      return entry.getKey();
    }
  }

  @Override
  public @Nullable Entry<K, V> lowerEntry(@ParametricNullness K key) {

            getWebConfig().getConfigParameterMap(ConfigName.CONFIG)
                    .entrySet()
                    .stream()
                    .filter(e -> e.getKey().startsWith(Config.JCIFS_PREFIX))
                    .forEach(e -> jcifsParams.put(e.getKey(), e.getValue()));
            if (!jcifsParams.isEmpty()) {
                config.setNtlmParameters(jcifsParams);
            }

    Iterator<Entry<K, V>> iterator = multimap().entries().iterator();
    Entry<K, V> entry = iterator.next();
    K key = entry.getKey();
    V value = entry.getValue();
    multimap().removeAll(key);
    assertEquals(key, entry.getKey());
    assertEquals(value, entry.getValue());
  }

import java.io.IOException;
import java.io.InputStreamReader;
import java.io.Reader;
import org.jspecify.annotations.NullUnmarked;

/**
 * A char source for testing that has configurable options.
 *
 * @author Colin Decker
 */
@NullUnmarked
public class TestCharSource extends CharSource implements TestStreamSupplier {

  private final TestByteSource byteSource;

  public TestCharSource(String content, TestOption... options) {

                    Map<String, String> map = CompactHashMap.create();
                    for (Entry<String, String> entry : entries) {
                      map.put(entry.getKey(), entry.getValue());
                    }
                    return map;
                  }
                })
            .named("CompactHashMap")
            .withFeatures(
                CollectionSize.ANY,