def threadRange = 1..100

        when:
        def hashes = threadRange.collect {
            supplyAsync({ Hashing.hashString(currentThread().name) }, newFixedThreadPool(threadRange.size()))
        }*.join().toSet()

        then:
        hashes.size() == threadRange.size()
    }

    def 'null does not collide with other values'() {
        expect:
        def hasher = Hashing.newHasher()
        hasher.putNull()

        return Stream.concat(openJdkInstallations, jvms)
            .map(javaHome -> InstallationLocation.autoDetected(new File(javaHome), getSourceName()))
            .collect(Collectors.toSet());
    }

    private List<String> find(String sdkSubkey, String path, String value) {
        try {
            List<String> versions = getVersions(sdkSubkey);

        this.teamCityExecutions = teamCityExecutions
        this.crossBuild = crossBuild
        this.fromCache = fromCache

        Set<String> teamCityBuildIds = teamCityExecutions.collect { it.teamCityBuildId }.toSet()
        this.currentExecutions = historyExecutions.findAll {
            teamCityBuildIds.contains(it.teamCityBuildId)
        }
        this.historyExecutions = historyExecutions
    }

    String getName() {

                .filter(it -> JDK_PATTERN.matcher(it.getKey()).matches())
                .map(entry -> InstallationLocation.userDefined(new File(entry.getValue()), "env var " + entry.getKey()))
                .collect(Collectors.toSet());
        }
    }

    /**
     * On CI we pass -Porg.gradle.java.installations.paths=X,Y,Z to the build, then "forward" it
     * as system property to get deterministic results.
     */

            .filter(sourcePath -> sourcePath.endsWith(".java"))
            .flatMap(sourcePath -> sourceFileClassNameConverter.getClassNames(sourcePath).stream())
            .collect(Collectors.toSet());
        if (!classesWithJavaSource.isEmpty()) {
            // We need to collect just accessible dependents, since it seems
            // private references to classes are not problematic when Groovy compiler loads a class

        }
        return orig
            .stream()
            .map(ElementUtils::getTopLevelType)
            .map(ElementUtils::getElementName)
            .filter(Objects::nonNull)
            .collect(Collectors.toSet());
    }

    @Override
    public void recordGeneratedType(CharSequence name, Element[] originatingElements) {
        result.getGeneratedAggregatingTypes().add(name.toString());
    }

    @Override

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