def setup() {
        sourceFolder = Files.createTempDirectory(temporaryFolder.toPath(), null).toFile()
    }

    List<File> toSourceFiles(List<String> bodies) {
        return bodies.collect { toSourceFile(it) }.flatten()
    }

    List<File> toSourceFile(String body) {
        def packageGroup = (body =~ /(?s).*?(?:package) (\w+).*/)
        String packageName = packageGroup.size() > 0 ? packageGroup[0][1] : ""

		e := d.Cache[id]
		if len(e.Children) > 0 {
			e = d.flatten(e)
		}
		m[id] = e
	}
	return m
}

// flatten all children of the root into the root element and return it.
func (d *dataUsageCache) flatten(root dataUsageEntry) dataUsageEntry {
	for id := range root.Children {
		e := d.Cache[id]
		if len(e.Children) > 0 {
			e = d.flatten(e)
		}
		root.merge(e)
	}
	root.Children = nil

        collectProblems(childMetadata).empty

        where:
        [parentAnnotation, childAnnotation] << [PROCESSED_PROPERTY_TYPE_ANNOTATIONS, PROCESSED_PROPERTY_TYPE_ANNOTATIONS].combinations()*.flatten()
    }

    def "can override @#processedAnnotation.simpleName property type with @#unprocessedAnnotation.simpleName"() {
        def parentTask = groovyClassLoader.parseClass """

                @TaskAction
                void go() {
                    def file = outputFile.asFile.get()
                    file.text = inputDirs.get()*.asFile*.listFiles().text.flatten().join(',')
                }
            }

            task createDir1(type: DirOutputTask)
            task createDir2(type: DirOutputTask)
            task merge(type: MergeTask) {

        mainTestedVersions = testedVersions.map { VersionNumber.parse(it.gradleVersion().version) }
            .groupBy { it.major }
            .map { (_, v) -> listOf(v.minOrNull()!!.format(), v.maxOrNull()!!.format()) }.flatten()
    }

    private
    fun VersionNumber.format() =
        // reformat according to our versioning scheme, since toString() would typically convert 1.0 to 1.0.0

        if (specOfFeature.parent instanceof SpecInfo) {
            predicateClassNames += (specOfFeature.parent as SpecInfo).getAnnotationsByType(Requires)
                .collect { (it as Requires).value() }
                .flatten() as List<Class>
        }

        PredicatesFile.checkValidCombinations(predicateClassNames, acceptedCombinations)
        // If all preconditions are met, we DON'T skip the tests

            return transformStepNodeIdentities
        }
        def targetColors = (identities.collect { it*.targetAttributes.color }.flatten() as Set<String>)
        return targetColors.collectEntries { color ->
            [(color): identities.collect {plannedTransformSteps ->

        return [true, false]
    }

    final def testCasesWithIndyModes() {
        // Combine each test case with enableIndy=true and/or enableIndy=false
        return [testCases(), indyModes()].combinations().collect { it.flatten() }
    }

    def "#title is intercepted in groovy build script #indyStatus"(VarInitializer varInitializer) {
        given:
        def cwd = testDirectory.file(expectedPwdSuffix)
        withPluginCode("""

        return new AnyOrderSpec(Arrays.asList(constraints));
    }

    public static TaskOrderSpec exact(Object[] constraints) {
        List<Object> flattenedConstraints = GUtil.flatten(constraints, new ArrayList<Object>());
        return new ExactOrderSpec(flattenedConstraints);
    }

    private static abstract class RecursiveOrderSpec implements TaskOrderSpec {

     *
     * @return the id of the path scope
     */
    String pathScope() default "";

    /**
     * The request type, in case the default one is not correct.
     * Valid values are {@code collect}, {@code flatten}, or {@code resolve}.
     *
     * @return the request type
     */
    String requestType() default "";