return targetMachines.stream().map(TargetMachine::getOperatingSystemFamily).collect(Collectors.toSet());
    }

    private static Set<MachineArchitecture> targetMachinesToArchitectures(Collection<TargetMachine> targetMachines) {
        return targetMachines.stream().map(TargetMachine::getArchitecture).collect(Collectors.toSet());
    }

            throw new RuntimeException(e);
        }
    }

    private Set<TimestampedFile> getTimestampedFiles(List<File> fs) {
        return fs.stream().map(TimestampedFile::new).collect(Collectors.toSet());
    }

    @Override
    public void close() throws IOException {
        cache.clear();
        commonParent.close();
    }

                parameters.monitoredTaskPaths = allTasks.filter(taskFilter).map { if (isInBuildLogic) ":build-logic${it.path}" else it.path }.toSet()
            }
            gradle.serviceOf<BuildEventsListenerRegistry>().onTaskCompletion(buildService)

        Set<String> prefixes = directoriesToClean.stream()
            .map(directoryToClean -> directoryToClean.getAbsolutePath() + File.separator)
            .collect(Collectors.toSet());

        OutputsCleaner outputsCleaner = new OutputsCleaner(
            deleter,
            file -> {
                String absolutePath = file.getAbsolutePath();
                return prefixes.stream()

        def keyringsAscii = SecuritySupport.loadKeyRingFile(exportedKeyRingAscii)
        keyringsAscii.size() == 2
        keyringsAscii.collect { it.publicKey.keyID }.toSet() == [keyring.publicKey.keyID, keyring2.publicKey.keyID].toSet()
    }

    @Issue(["https://github.com/gradle/gradle/issues/24822", "https://github.com/gradle/gradle/issues/26289"])

        return getModelId() + " " + getLocation();
    }

    public static InputSource merge(InputSource src1, InputSource src2) {
        return new InputSource(Stream.concat(src1.sources(), src2.sources()).collect(Collectors.toSet()));
    }

        if (gitignoreFile.exists()) {
            try (BufferedReader reader = new BufferedReader(new FileReader(gitignoreFile))){
                result.removeAll(reader.lines().filter(it -> result.contains(it)).collect(Collectors.toSet()));
            } catch (IOException e) {
                throw new UncheckedIOException(e);
            }
        }
        return result;
    }

    private static List<String> withComment(String entry) {

            if (matcher.matches()) {
                String javaHome = matcher.group(1);
                return Stream.of(javaHome);
            }
            return Stream.empty();
        }).map(File::new).collect(Collectors.toSet());
    }

    @Override
    public Set<File> findJavaHomes() {
        try {
            final Reader output = executeJavaHome();
            return parse(output);
        } catch (ExecException e) {

     */
    public Set<NodeIdentity.NodeType> getConvertedNodeTypes() {
        return converters.stream()
            .map(ToPlannedNodeConverter::getConvertedNodeType)
            .collect(Collectors.toSet());
    }

    /**
     * Returns a converter for the given node, or null if there is no converter for the node.
     */
    @Nullable
    public ToPlannedNodeConverter getConverter(Node node) {

            val splitSubProjectNames = functionalTests.map { it.getSubProjectSplitName() }.toSet()
            val expectedProjectNames = (1..functionalTests.size).map { "${subProjectName}_$it" }.toSet()
            assertEquals(expectedProjectNames, splitSubProjectNames)
        }