return (T) value;
            }
            if (clazz.isAssignableFrom(List.class)) {
                final List<String> list = new ArrayList<>();
                Collections.addAll(list, (String[]) value);
                return (T) list;
            }

            if (((String[]) value).length == 0) {
                return null;
            }

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

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

    return newBuilderUsing(delegate, to, from)
        .named(parentBuilder.getName() + " subMap " + from + "-" + to)
        .withFeatures(features)

  }

  private static TestSuite wrappedHashMapTests(
      WrappedHashMapGenerator generator, String name, Feature<?>... features) {
    List<Feature<?>> featuresList = Lists.newArrayList(features);
    Collections.addAll(
        featuresList,
        MapFeature.GENERAL_PURPOSE,
        CollectionFeature.SUPPORTS_ITERATOR_REMOVE,
        CollectionSize.ANY);
    return MapTestSuiteBuilder.using(generator)
        .named(name)

        }
        if (mavenOptions.ignoreTransitiveRepositories().isPresent()) {
            cmdAndArguments.add("--ignore-transitive-repositories");
        }

        // last the goals
        cmdAndArguments.addAll(mavenOptions.goals().orElse(Collections.emptyList()));

        try {
            ProcessBuilder pb = new ProcessBuilder()
                    .directory(invokerRequest.cwd().toFile())

        }

        Set<String> allClasses = new TreeSet<>(existingClasses); // Using TreeSet for natural ordering
        allClasses.addAll(processedClasses);

        StringBuilder newContentBuilder = new StringBuilder();
        for (String className : allClasses) {
            newContentBuilder.append(className).append("\n");
        }

      Headers.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() {

        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) {

                    ScoreFunctionBuilders.fieldValueFactorFunction(ComponentUtil.getFessConfig().getIndexFieldBoost())));
            ComponentUtil.getKeyMatchHelper().buildQuery(queryContext.getDefaultKeyword(), list);
            list.addAll(boostFunctionList);
        });
    }

    public void buildBaseQuery(final QueryContext queryContext, final Consumer<QueryContext> context) {
        try {

    fun redactQueryParams(vararg name: String) {
      val newQueryParamsNameToRedact = TreeSet(String.CASE_INSENSITIVE_ORDER)
      newQueryParamsNameToRedact += queryParamsNameToRedact
      newQueryParamsNameToRedact.addAll(name)
      queryParamsNameToRedact = newQueryParamsNameToRedact
    }

    /**
     * Sets the level and returns this.
     *

                  protected Set<String> create(String[] elements) {
                    Set<String> set = newHashSet(elements);
                    Set<String> other = newHashSet("wz", "xq");
                    set.addAll(other);
                    other.add("pq");
                    return Sets.difference(set, other);
                  }
                })
            .named("set - set")
            .withFeatures(