/**
     * Invoked when the code starts an external process. The command string with all argument is provided for reporting but its value may not be suitable to actually invoke the command because all
     * arguments are joined together (separated by space) and there is no escaping of special characters.
     *
     * @param command the command used to start the process (with arguments)

    /**
     * Called when the build is started.
     *
     * @return whether watching the file system is currently enabled. This requires that the feature
     * is supported on the current operating system, it is enabled for the build, and has been successfully
     * started.
     */

        0 * _

        when:
        buildFinished(Integer.MAX_VALUE, [unsupportedFileSystemMountPoint])
        then:
        !vfsHasSnapshotsAt(unwatchableContent)
        0 * _
    }

    def "starts watching unsupported file system when watching is enabled"() {
        def unsupportedFileSystemMountPoint = file("unsupported").createDir()
        def unwatchableContent = unsupportedFileSystemMountPoint.file("file.txt").createFile()

    @Rule
    HttpBuildCacheServer httpBuildCacheServer = new HttpBuildCacheServer(testDirectoryProvider)

    def "remote build cache configuration is exposed"() {
        given:
        httpBuildCacheServer.start()
        def url = "${httpBuildCacheServer.uri}/"
        settingsFile << """
            buildCache {
                local {
                    enabled = false
                }

        """

        when:
        // start a build with a IsolationMode.PROCESS worker that will initialize the worker classpath cache and wait until the cache was initialized
        def block = server.expectAndBlock("waiting")
        def build = executer.withTasks("doWork").start()
        block.waitForAllPendingCalls()

    fun blockAnnotations(fragment: ProgramSourceFragment?, allAnnotations: List<IntRange>): List<IntRange> {
        val start = fragment?.let { it.section.firstAnnotationStart }
        val end = fragment?.let { it.section.wholeRange.first }
        if (start != null && end != null) {
            val annotationRangeForBlock = start until end - 1
            return allAnnotations.filter {

        StartScriptTemplateBindingFactory.windows(),
        FileCollectionBackedTextResource(temporaryFileProvider, windowsScriptTemplate, StandardCharsets.UTF_8)
    )

    /**
     * Modifies the start script injecting -javaagent flags. The start script file is updated in-place by appending Java agent switches to 'DEFAULT_JVM_OPTS' variable declaration.
     */
    private
    fun File.injectAgentOptions(separator: String) {

        List<RepoFixture> repos = scenario == DynamicVersionScenario.SINGLE_REPO
            ? [defaultRepo]
            : [defaultRepo, repoWithout('thing', 'lib')]

        server.start()

        remoteRepo.module("thing", "lib", "1.2").publish()
        def v3 = remoteRepo.module("thing", "lib", "1.3").publish()

        taskTypeLogsInputFileCollectionContent()
        buildFile << """

The build session state is managed by the `BuildSessionState` class.
An instance is created at the start of a Gradle invocation and discarded at the end of that invocation.

The build session state also includes "cross session" state that is shared with any "nested" sessions that need to be created.

                "The precompiled plugin (${
                "src/main/kotlin/org.gradle.my-plugin.gradle.kts".replace(
                    "/",
                    File.separator
                )
                }) cannot start with 'org.gradle' or be in the 'org.gradle' package."
            )
            .assertHasResolution(getPrecompiledPluginsLink())
    }

    @Test