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

import static com.tngtech.archunit.core.domain.properties.HasName.Predicates.nameMatching;
import static com.tngtech.archunit.core.domain.properties.HasType.Functions.GET_RAW_TYPE;
import static java.util.stream.Collectors.toSet;

public interface ArchUnitFixture {
    DescribedPredicate<JavaClass> classes_not_written_in_kotlin = resideOutsideOfPackages(
        "org.gradle.internal.cc..",
        "org.gradle.configurationcache..",

            // and does not appear in search results by default
            excludeDirs = listOf(".gradle", "build", "intTestHomeDir")
                .map { repoRoot().dir(it).asFile }
                .toSet()
        }
        project {
            settings {
                configureCopyright()
                configureRunConfigurations()
                doNotDetectFrameworks("android", "web", "12wq")
            }

    def setup() throws Exception {
        task = TestUtil.createTask(TestReportTask.class, project)
        task.setGenerator(generator)
        task.setRenderer(renderer)
        task.setProjects(WrapUtil.<Project>toSet(project))
    }

    def completesRendererAtEndOfGeneration() {
        when:
        task.generate()

        then:
        1 * renderer.setClientMetaData(_)

        if (config.getIgnoredKeys().isEmpty()) {
            return artifactSpecificKeys.stream().map(IgnoredKey::getKeyId).collect(Collectors.toSet());
        } else {
            if (artifactSpecificKeys.isEmpty()) {
                return config.getIgnoredKeys().stream().map(IgnoredKey::getKeyId).collect(Collectors.toSet());
            }
            Set<String> allKeys = new HashSet<>();
            artifactSpecificKeys.stream()