(TestSortedMapGenerator<K, V>) parentBuilder.getSubjectGenerator().getInnerGenerator();

    List<Feature<?>> features = new ArrayList<>();
    features.add(NoRecurse.DESCENDING);
    features.addAll(parentBuilder.getFeatures());

    return subSuiteUsing(new DescendingTestMapGenerator<K, V>(delegate))
        .named(parentBuilder.getName() + " descending")
        .withFeatures(features)

    ms.add(Color.BLUE, 3);
    ms.add(Color.YELLOW, 1);
    ms.add(Color.RED, 2);

    Set<Object> uniqueEntries = Sets.newIdentityHashSet();
    uniqueEntries.addAll(ms.entrySet());
    assertEquals(3, uniqueEntries.size());
  }

  // Wrapper of EnumMultiset factory methods, because we need to skip create(Class).

    assertTrue(multimap().containsEntry(k0(), v3()));
  }

  @MapFeature.Require(SUPPORTS_PUT)
  public void testPropagatesAddAllToMultimap() {
    Collection<V> result = multimap().get(k0());
    assertTrue(result.addAll(singletonList(v3())));
    assertTrue(multimap().containsKey(k0()));
    assertEquals(getNumElements() + 1, multimap().size());
    assertTrue(multimap().containsEntry(k0(), v3()));
  }

        Collection<String> versions = new LinkedHashSet<>();

        if ((repoMetadata != null) && (repoMetadata.getVersioning() != null)) {
            versions.addAll(repoMetadata.getVersioning().getVersions());
        }

        versions.addAll(availableVersions);

        List<ArtifactVersion> artifactVersions = new ArrayList<>(versions.size());

        for (String version : versions) {

                }
            });
        }

        final CrawlingConfigHelper crawlingConfigHelper = ComponentUtil.getCrawlingConfigHelper();
        final BulkResponse response = searchEngineClient.addAll(fessConfig.getIndexDocumentUpdateIndex(), docList, (doc, builder) -> {
            if (doc.get(fessConfig.getIndexFieldConfigId()) instanceof final String configId) {

      } else {
        if (extras.isEmpty()) {
          // Replace immutable empty list with mutable list.
          extras = new ArrayList<>();
        }
        extras.add(other.element);
        extras.addAll(other.extras);
        if (extras.size() > MAX_EXTRAS) {
          extras.subList(MAX_EXTRAS, extras.size()).clear();
          throw multiples(true);
        }
        return this;
      }
    }

    List<String> misses = new ArrayList<>();
    for (int i = 0; i < 256 - hits.size(); ++i) {
      misses.add("INVALID");
    }

    List<String> sampleDataList = new ArrayList<>();
    sampleDataList.addAll(hits);
    sampleDataList.addAll(misses);
    Collections.shuffle(sampleDataList);
    sampleData = sampleDataList.toArray(new String[sampleDataList.size()]);
  }

            final String[] values = form.fields.get(LABEL_FIELD);
            final List<String> labelList = new ArrayList<>();
            if (values != null) {
                Collections.addAll(labelList, values);
            }
            for (final String labelTypeValue : labelList) {
                for (final Map<String, String> map : labelTypeItems) {

                    for (final StringBuilder buf : tmpBufList) {
                        buf.append(alphabets[j]);
                    }
                    bufList.addAll(tmpBufList);
                }
            }
        }

        for (final StringBuilder buf : bufList) {
            String s = fullWidthHalfWidth.transliterate(buf.toString());

        .Builder()
        .add("A", "aa")
        .add("a", "aa")
        .add("B", "bb")
        .build()
    val headers =
      Headers
        .Builder()
        .add("A", "a")
        .addAll(sourceHeaders)
        .add("C", "c")
        .build()
    assertThat(headers.toString()).isEqualTo("A: a\nA: aa\na: aa\nB: bb\nC: c\n")
  }

  @Test fun nameIndexesAreStrict() {