new TestStringMapGenerator() {
              @Override
              protected Map<String, String> create(Entry<String, String>[] entries) {
                return singletonMap(entries[0].getKey(), entries[0].getValue());
              }
            })
        .named("singletonMap")
        .withFeatures(
            MapFeature.ALLOWS_NULL_KEYS,
            MapFeature.ALLOWS_NULL_VALUES,

                        final Entry<String, String> entry = keyIterator.next();
                        return new Entry<String, String>() {
                            public String getKey() {
                                return entry.getKey();
                            }

                            public String getValue() {
                                return entry.getValue();
                            }

   */
  public char[] @Nullable [] toArray() {
    char[][] result = new char[max + 1][];
    for (Entry<Character, String> entry : map.entrySet()) {
      result[entry.getKey()] = entry.getValue().toCharArray();
    }
    return result;
  }

  /**
   * Convert this builder into a char escaper which is just a decorator around the underlying array
   * of replacement char[]s.

    }

    Entry<K, V> getEntry(final int index) {
      checkElementIndex(index, size());
      return new AbstractMapEntry<K, V>() {
        @Override
        public K getKey() {
          return ArrayMap.this.getKey(index);
        }

        @Override
        @ParametricNullness
        public V getValue() {
          return ArrayMap.this.getValue(index);
        }

        @Override

    assertNull("put(null, null) should return null", put(nullKeyValueEntry));
    expectAdded(nullKeyValueEntry);
  }

  @CanIgnoreReturnValue
  private V put(Entry<K, V> entry) {
    return getMap().put(entry.getKey(), entry.getValue());
  }

  /**
   * Returns the {@link Method} instance for {@link #testPut_nullKeyUnsupported()} so that tests of
   * {@link java.util.TreeMap} can suppress it with {@code

    public <T extends B> Builder<B> putAll(Map<? extends Class<? extends T>, ? extends T> map) {
      for (Entry<? extends Class<? extends T>, ? extends T> entry : map.entrySet()) {
        Class<? extends T> type = entry.getKey();
        T value = entry.getValue();
        mapBuilder.put(type, cast(type, value));
      }
      return this;
    }

    private static <T> T cast(Class<T> type, Object value) {

                                                                logger.debug("Skipping interpolation of field: " + field
                                                                        + " (key: " + entry.getKey() + ") in: "
                                                                        + cls.getName()
                                                                        + "; it is an unmodifiable collection.");

        private BiEntry<K, V> delegate;

        MapEntry(BiEntry<K, V> entry) {
          this.delegate = entry;
        }

        @Override
        @ParametricNullness
        public K getKey() {
          return delegate.key;
        }

        @Override
        @ParametricNullness
        public V getValue() {
          return delegate.value;
        }

        @Override

        for ( Entry<String, Map<String, CacheEntry<DfsReferralDataInternal>>> entry : domains.entrySet() ) {
            log.trace("Domain " + entry.getKey());
            for ( Entry<String, CacheEntry<DfsReferralDataInternal>> entry2 : entry.getValue().entrySet() ) {
                log.trace("  Root " + entry2.getKey());
                if ( entry2.getValue().map != null ) {

          .containsAtLeastElementsIn(EnumSet.complementOf(EnumSet.of(UNNECESSARY)));
      for (Map.Entry<RoundingMode, Double> entry : expectedValues.entrySet()) {
        RoundingMode mode = entry.getKey();
        Double expectation = entry.getValue();
        assertWithMessage("roundToDouble(" + input + ", " + mode + ")")
            .that(BigDecimalMath.roundToDouble(input, mode))
            .isEqualTo(expectation);