}
                    return new BasicNameValuePair(name, value);
                }).collect(Collectors.toList()));
        if (paramList != null) {
            parameters
                    .addAll(paramList.stream().map(p -> new BasicNameValuePair(p.getFirst(), p.getSecond())).collect(Collectors.toList()));
        }
        final Charset charset = encoding != null ? Charset.forName(encoding) : StandardCharsets.UTF_8;

            poms = Files.walk(userHome.resolve(".m2/repository/org/apache/maven"))
                    .filter(p -> p.getFileName().toString().endsWith(".pom"))
                    .collect(Collectors.toList());
        }
    }

    @Benchmark
    public int readWithStax(AdditionState state) throws IOException, XMLStreamException {
        int i = 0;
        for (Path pom : state.poms) {

   * and returns it.
   */
  fun <T : CallEvent> removeUpToEvent(eventClass: Class<T>): T {
    val fullEventSequence = eventSequence.toList()
    try {
      while (true) {
        val event = takeEvent()
        if (eventClass.isInstance(event)) {
          return eventClass.cast(event)
        }
      }
    } catch (e: NoSuchElementException) {

                extension.getVmEnv().forEach((k, v) -> script.add("$Env:" + k + " = \"" + v + "\""));
                script.addAll(getWindowsScript().stream().map(s -> "    " + s).collect(Collectors.toList()));
                script.addAll(
                    Arrays.asList(
                        "    exit $LASTEXITCODE",
                        "} catch {",

        List<String> failures = getFiles().getFiles()
            .stream()
            .filter(FilePermissionsTask::isExecutableFile)
            .map(file -> "Source file is executable: " + file)
            .collect(Collectors.toList());

        if (failures.isEmpty() == false) {
            throw new GradleException("Found invalid file permissions:\n" + String.join("\n", failures));
        }

        outputMarker.getParentFile().mkdirs();

                        && !rootProject.getDefaultGoal().isEmpty())) {
            tasks = Stream.of(rootProject.getDefaultGoal().split("\\s+"))
                    .filter(g -> !g.isEmpty())
                    .collect(Collectors.toList());
        }

        return calculateTaskSegments(session, tasks);
    }

    @Override
    public List<TaskSegment> calculateTaskSegments(MavenSession session, List<String> tasks)

                        .map(doc -> getStringValue(doc, "doc_id"))
                        .filter(StringUtil::isNotBlank)
                        .collect(Collectors.toList());
                return RelevanceEvaluationResult.fallbackAllRelevant(allDocIds);
            }
            final RelevanceEvaluationResult result = parseEvaluationResponse(response.getContent(), searchResults);

        return allProviders.stream()
                .filter(RdmaProvider::isAvailable)
                .map(RdmaProvider::getProviderName)
                .collect(java.util.stream.Collectors.toList());
    }

        this.setPluginArtifact(null); // TODO: v4
        this.setComponents(original.getMojos().stream()
                .map(m -> new MojoDescriptor(this, m))
                .collect(Collectors.toList()));
        this.setId(original.getId());
        this.setIsolatedRealm(original.isIsolatedRealm());
        this.setSource(null);
        this.setDependencies(Collections.emptyList()); // TODO: v4

    private
    fun getRelocatedPackages(files: Sequence<Path>): List<String> = mutableListOf<String>().apply {
        implementation.collectPackages(files.toList()).dump(false, this::add)
    }

    @Test
    fun `generates a curated list of package prefixes from directories`() {
        assertEquals(EXPECTED_PACKAGE_LIST, getRelocatedPackages(someClasses()))
    }