def overlappingDir = file("${getOverlappingOutputDir()}")
                doLast {
                    overlappingDir.mkdirs()
                    new File(overlappingDir, "new-output.txt").text = "new output"
                }
            }

        """.stripIndent()
        }
    }

        wrapper.setWrapperVersionsResources(new DefaultWrapperVersionsResources(latest, releaseCandidate, nightly, releaseNightly))
        wrapper.setGradleVersion("1.0")
        expectedTargetWrapperJar = new TestFile(getProject().getProjectDir(),
                TARGET_WRAPPER_FINAL + "/gradle-wrapper.jar")
        expectedTargetWrapperProperties = new File(getProject().getProjectDir(),

    @Rule
    public final TestNameTestDirectoryProvider tmpDir = new TestNameTestDirectoryProvider(getClass())

    def fileHasher = new TestFileHasher()
    def statisticsCollector = Stub(DirectorySnapshotterStatistics.Collector)
    def directorySnapshotter = new DirectorySnapshotter(fileHasher, new StringInterner(), [], statisticsCollector)
    List<FileSystemLocationSnapshot> unfilteredSubsnapshots = []

            [
                new MissingBuild(),
                new MissingSettings(),
                new MissingBuildInBuildSrc(),
                new MissingSettingsInBuildSrc(),
                new MissingBuildInIncluded(),
                new MissingSettingsInIncluded()
            ]
        ].combinations().collect { ScriptLanguage scriptLanguage, Scenario scenario ->
            new Spec(scriptLanguage, scenario)
        }

        "HashMap<String, Integer>"           | "new HashMap([a: 1, b: 2])"               | "[a:1, b:2]"
        "LinkedHashMap<String, Integer>"     | "new LinkedHashMap([a: 1, b: 2])"         | "[a:1, b:2]"
        "TreeMap<String, Integer>"           | "new TreeMap([a: 1, b: 2])"               | "[a:1, b:2]"

        assertMetadataIsMissing()
        verificationFile.parentFile.mkdirs()
        def builder = new Builder()
        config.resolveStrategy = Closure.DELEGATE_FIRST
        config.delegate = builder
        config()
        DependencyVerificationsXmlWriter.serialize(builder.build(), new FileOutputStream(verificationFile))
    }

        def createFailureWithNCauses = { n ->
            def rootCause = new Exception("lastLine")
            n == 0
                ? rootCause :
                (1..n).inject(new Exception("lastLine")) { acc, it -> new Exception("line${n - it}", acc) }
        }

        def jdkPath = testLocation("path")
        defineJdks(

    ConfigurationCacheFixture(AbstractIntegrationSpec spec) {
        this.spec = spec
        buildOperations = new BuildOperationsFixture(spec.executer, spec.temporaryFolder)
        configurationCacheBuildOperations = new ConfigurationCacheBuildOperationsFixture(buildOperations)
        problems = new ConfigurationCacheProblemsFixture(spec.testDirectory)
    }

    /**
     * Asserts that the configuration cache was not enabled.

    }

    def serialize(Object model) {
        def serialized = new ByteArrayOutputStream()
        Message.send(model, serialized)
        return Message.receive(new ByteArrayInputStream(serialized.toByteArray()), getClass().classLoader)
    }

    def "unpacks source object from view"() {
        def source = new Object()

        given:
        def view = adapter.adapt(TestProject.class, source)

import org.gradle.test.fixtures.file.TestFile
import org.gradle.util.GradleVersion

class ConfigurationCacheBuildOperationsIntegrationTest extends AbstractConfigurationCacheIntegrationTest {

    def operations = new BuildOperationsFixture(executer, temporaryFolder)

    def "emits no load/store build operations when configuration cache is not used"() {
        given:
        withLibBuild()
        withAppBuild()

        when: