collectOutputs(builder)
            builder.run()
        }

        then:
        eclipseModels.collect {
            collectProjects(it)
        }.flatten().collect {
            it.name
        }.containsAll([
            'root', 'root-root-a', 'explicitName',
            'includedBuild1', 'includedBuild1-a', 'includedBuild1-includedBuild1-b', 'includedBuild1-c',

        }
        assert matches.size() == 1
        buildResult(matches.first())
    }

    List<Exception> getFailures() {
        List.cast(buildResults.values().collect() {
            it.exception
        }.flatten().findAll())
    }

) {
  val commonName: Any?
    get() {
      return tbsCertificate.subject
        .flatten()
        .firstOrNull { it.type == ObjectIdentifiers.COMMON_NAME }
        ?.value
    }

  val organizationalUnitName: Any?
    get() {
      return tbsCertificate.subject
        .flatten()
        .firstOrNull { it.type == ObjectIdentifiers.ORGANIZATIONAL_UNIT_NAME }
        ?.value
    }

        val subprojectRoots = platformsFolder.asFile.listFiles(File::isDirectory).plus(subprojectsFolder.asFile).plus(testingFolder.asFile)
        return subprojectRoots.map { it.listFiles(File::isDirectory).asList() }.flatten()
    }

    private
    fun generateSubprojects(): List<GradleSubproject> {
        return generateSubprojectsDirectories()
            .filter {
                File(it, "build.gradle.kts").exists() ||

        // Output may come in different orders, so we just check that all the expected messages are there.
        def text = outputProgress*.details.spans*.text.flatten().join()
        text.count("Unrecognized option: --not-a-real-argument") == 1
        text.count("Error: Could not create the Java Virtual Machine.") == 1

            "org/acme/test/TestLexer.java",
            "org/acme/test/TestParser.java",
        ]
            .collect { projectDir.file("build/generated-src/antlr/main/$it").text.split(/\n/) }
            .flatten()
            .findAll { !(it =~ "// \\\$ANTLR") }
            .join("\n")
    }

			continue
		}
		pseudoFilename := fmt.Sprintf("%d: generated from %s", i, "default")

		reader := strings.NewReader(string(rj))
		builder = builder.Stream(reader, pseudoFilename)
	}
	r := builder.Flatten().Do()
	if r.Err() != nil {
		return r.Err()
	}
	visitor := genericclioptions.ResourceFinderForResult(r).Do()
	generatedCrds, generatedDeployments, generatedDaemonSets, err := v.verifyPostInstall(
		visitor,

        // Output may come in different orders, so we just check that all the expected messages are there.
        def text = outputProgress*.details.spans*.text.flatten().join()
        text.count("Unrecognized option: --not-a-real-argument") == 1
        text.count("Error: Could not create the Java Virtual Machine.") == 1

    }

    override val allSourceFiles: List<PsiFileSystemItem> by lazy {
        buildList {
            val files = allKtModules.mapNotNull { (it as? KtSourceModuleImpl)?.sourceRoots }.flatten()
            addAll(files)
            addAll(findJvmRootsForJavaFiles(files.filterIsInstance<PsiJavaFile>()))
        }
    }

            def init = AGP_VERSIONS.createAgpNightlyRepositoryInitScript()
            extraArgs += ["-I", init.canonicalPath]
        }
        return runner.withArguments([runner.arguments, extraArgs].flatten())
            .ignoreDeprecationWarningsIf(AGP_VERSIONS.isOld(agpVersion), "Old AGP version")
    }

    private SmokeTestGradleRunner newKotlinRunner(boolean parallel, VersionNumber kotlinVersion, List<String> tasks) {