//
        // Note that we are not capturing this value in the actual inputs of the work; doing so would cause unnecessary cache misses.
        // This is why the hash is captured here and not in visitIdentityInputs().
        FileSystemLocationSnapshot inputArtifactSnapshot = fileSystemAccess.read(inputArtifact.getAbsolutePath());
        HashCode inputArtifactSnapshotHash = inputArtifactSnapshot.getHash();

            configurationTimeBarrier: ConfigurationTimeBarrier,
            modelParameters: BuildModelParameters,
            /** In non-CC builds, [ConfigurationCacheStartParameter] is not registered; accepting a list here is a way to ignore its absence. */
            configurationCacheStartParameter: List<ConfigurationCacheStartParameter>,
            listenerManager: ListenerManager,
            workExecutionTracker: WorkExecutionTracker,

        """

        when:
        succeeds "loadClasses"

        then:
        def lines = output.readLines()
        if (lines.find { it == noInfoHeading }) { return }

        lines.find { it == heading } // here for nicer output if the output isn't what we expect
        def headingIndex = lines.indexOf(heading)
        def classpathSize = Integer.parseInt(lines[headingIndex + 1])
        // The gradle-launcher.jar is mandatory.

    val testTaskOptionsParameterName = "testTaskOptions"
    val daemon = true
    applyDefaultSettings(os, arch, buildJvm = BuildToolBuildJvm, timeout = 0)

    // Show all failed tests here, since that is what we are interested in
    failureConditions.supportTestRetry = false

    val extraParameters = functionalTestExtraParameters("RerunFlakyTest", os, arch, "%$testJvmVersionParameter%", "%$testJvmVendorParameter%")

        }
    }

    // TODO Make AbstractVirtualFileSystem into DefaultVirtualFileSystem, and wrap it with the
    //      watching/non-watching implementations so DefaultVirtualFileSystem can be reused here
    static class CustomVirtualFileSystem extends AbstractVirtualFileSystem {
        protected CustomVirtualFileSystem(SnapshotHierarchy root) {
            super(root);
        }

        @Override

        else -> taggedEncodingFor(value.javaClass).run {
            writeSmallInt(tag)
            withDebugFrame({
                // TODO:configuration-cache evaluate whether we need to unpack the type here
                // GeneratedSubclasses.unpackType(value).typeName
                value.javaClass.typeName
            }) {
                encoding.run { encode(value) }
            }
        }
    }

            else -> null
        }
    }

    private
    fun WriteContext.writeReference(value: Any?) {
        // Cannot warn about a script reference here, because we don't know whether the closure will attempt to use the script object when it executes,
        // and since almost every closure in a Groovy build script legitimately has the script as an owner, this will generate false problems.

        when:
        dir.deleteDir() // directory does not exist
        configurationCacheRun("report")

        then:
        fixture.assertStateStored() // TODO - it would be good to reuse a previous entry here
        outputContains("Calculating task graph as configuration cache cannot be reused because an input to build file 'build.gradle' has changed.")
        outputContains(output1)

        where:

        append(totalProblemCount)
        append(if (totalProblemCount == 1) " problem was found " else " problems were found ")
        append(cacheAction)
        append(" the configuration cache")
        if (overflowed) {
            append(", only the first ")
            append(maxCollectedProblems)
            append(" were considered")
        }
        if (totalProblemCount != uniqueProblemCount) {
            append(", ")

        with(standardError) {
            files.forEach {
                assertContains("API changes in file '${it.name}' should be in alphabetical order (by type and member), yet these changes were not:\n")
            }
            changes?.forEach { assertContains(it.toString()) }
            assertContains(cleanupHint)
        }
    }

    private
    fun StringWriter.assertContains(text: String) {