def identities = ops.collect { op ->
            def plannedNodes = op.result.executionPlan as List<Map<String, ?>>
            def transformStepNodeIdentities = plannedNodes*.nodeIdentity.findAll { it.nodeType == NodeIdentity.NodeType.TRANSFORM_STEP.name() }
            return transformStepNodeIdentities
        }
        def targetColors = (identities.collect { it*.targetAttributes.color }.flatten() as Set<String>)

        return allDefinitions
    }

    static List<Spec> specsWithoutSystemPropertyAccess() {
        specs().findAll { spec -> spec.systemPropertyAccess == SystemPropertyAccess.NO_ACCESS }
    }

    static List<Spec> specsWithSystemPropertyAccess() {
        specs().findAll { spec -> spec.systemPropertyAccess != SystemPropertyAccess.NO_ACCESS }
    }

    static List<Spec> specs() {
        [

        !accessorsClassPath.isEmpty()
    }

    private List<File> accessorsClassPathFor(File buildFile) {
        return classPathFor(projectDir, buildFile)
            .tap { println(it) }
            .findAll { isAccessorsDir(it) }
    }

    private static boolean isAccessorsDir(File dir) {
        return dir.isDirectory() && dir.path.contains("accessors")
    }

    @TaskAction
    void clean() {
        def jsonFileManager = new AcceptedApiChangesJsonFileManager()
        jsonFileDirectory.asFile.get().listFiles()
            ?.findAll { it.name.endsWith(".json") }
            ?.each { jsonFileManager.emptyAcceptedApiChanges(it) }
    }

    }

    private Collection<Map<String, Object>> collectOutputEvents() {
        def pattern = /\{"profile":"(.*?)","type":"(O|C)","frame":"(.*?)","at":\d+\,"sn":\d+\}/
        (output =~ pattern)
            .findAll()
            .collect { matchResult ->
                //noinspection GroovyUnusedAssignment
                def (ignored, profile, type, frame) = matchResult
                [profile: profile, type: type, frame: frame]

        assert !scripts.empty
        def sortedScripts = scripts.toSorted { it -> it.startTime }
        assert sortedScripts.first().details.targetType == "settings"
        def nonSettingsScripts = scripts.findAll { it.details.targetType != "settings" }
        def nonSettingsScriptTargets = nonSettingsScripts.collect { fullPath(it.details.buildPath, it.details.targetPath) }.toSet()

        file("files/dir2/file2.txt") << ""

        and:
        buildFile """
            def files = files("files/file0.txt", "files/dir1", "files/dir2", "files/dir3").elements.map {
                it.findAll { file ->
                    file.asFile.isDirectory()
                }
            }
            tasks.register("sync", Sync) {
                from files
                into "output"
            }

def mainApiChangesJsonFile = apiChangesJsonDirectory.file("accepted-public-api-changes.json")
def acceptedViolations = AcceptedApiChanges.parse(apiChangesJsonDirectory.asFile.listFiles()
    .findAll { it.name.endsWith(".json") }
    .collect { providers.fileContents(apiChangesJsonDirectory.file(it.name)).asText.get() }
)

def compatibilityBaselineVersion = moduleIdentity.releasedVersions.get().mostRecentRelease.version

        def confCacheDir = file("./app/.gradle/configuration-cache")
        confCacheDir.isDirectory()
        def confCacheFiles = confCacheDir.allDescendants().findAll { it != 'configuration-cache.lock' && it != 'gc.properties' }
        confCacheFiles.size() == 5 // header, 2 * fingerprint, root build state file, included build state file
        if (!OperatingSystem.current().isWindows()) {

        hasItem("buildSrc.jar")
    }

    protected static Matcher<Iterable<? super File>> matchesProjectsSourceRoots(ProjectSourceRoots... projectSourceRoots) {
        return allOf(projectSourceRoots.findAll { !it.languages.isEmpty() }.collectMany { sourceRoots ->

            def languageDirs =
                sourceRoots.sourceSets.collectMany { sourceSet ->
                    ["java", "kotlin"].collect { language ->