"""

        when:
        run("assemble", "--info")
        then:
        outputContains(ENABLED_IF_AVAILABLE_MESSAGE)
        outputContains(ACTIVE_MESSAGE)

        where:
        watchMode << WatchMode.values()
    }

    def "cannot define a custom build scope cache dir when watching is explicitly enabled"() {
        buildFile << """
        """

        setupTest(vfsSpec)

        when:
        def resultRoot = initialRoot.invalidate(searchedPath, CASE_SENSITIVE, diffListener).get()
        then:
        resultRoot.children == childrenWithSelectedChildRemoved()
        isSameNodeType(resultRoot)
        removedNodes == [selectedChild]
        addedNodes.empty
        interaction { noMoreInteractions() }

        where:

    }

    def "returns relative path where file inside of root"() {
        when:
        def file = new File(rootDir, filePath)
        def current = new File(rootDir, "current/dir")

        then:
        transform(current, file) == relativePath

        where:
        filePath                   | relativePath
        "child.txt"                | "../../child.txt"

    }

    def "get(#key) is tracked for non-strings"() {
        when:
        def result = getMapUnderTestToRead().get(key)

        then:
        result == expectedResult
        1 * listener.onAccess(key, expectedResult)

        where:
        key                     | expectedResult
        EXISTING_KEY            | EXISTING_VALUE

    def comparer = ExhaustiveLinesSearcher.useLcsDiff()

    // region: assertLinesContainedIn
    def "neither expected or actual lines can be empty"() {
        when:
        comparer.assertLinesContainedIn([], ["a"])
        then:
        thrown(AssertionError)

        when:
        comparer.assertLinesContainedIn(["a"], [])
        then:
        thrown(AssertionError)
    }

        where:
        category << BuildOperationCategory.values()
    }

    def "can serialize ProgressStartEvent messages with empty fields"() {
        given:
        def event = new ProgressStartEvent(OPERATION_ID, null, TIMESTAMP, CATEGORY, DESCRIPTION, loggingHeader, "", 0, false, null, BuildOperationCategory.UNCATEGORIZED)

        when:
        def result = serialize(event, serializer)

                from 'parent'
            }
            """
        when:
        run "pack"
        file(archName).usingNativeTools()."$unpackMethod"(file("build"))
        then:
        file("build/child").mode == 0777
        file("build/child/reference.txt").mode == 0746
        where:
        taskName | unpackMethod
        "Zip"    | "unzipTo"
        "Tar"    | "untarTo"
    }

            }
            """

        when:
        succeeds taskName

        def archive = file("build/test.${fileExtension}")
        then:
        def firstFileHash = archive.md5Hash

        when:
        file('dir1/file11.txt').makeOlder()
        archive.delete()
        succeeds taskName

        then:
        archive.md5Hash == firstFileHash

        where:
        taskName << ['tar', 'zip']

        when:
        fails 'checkDeps'

        then:
        failure.assertHasCause("Could not resolve all files for configuration ':lockedConf'.")
        failure.assertHasCause("Resolved 'org:bar:1.0' which is not part of the dependency lock state")

        where:
        unique << [true, false]
    }

        given:
        doConfigureSettingsPlugin()
        file("settings$settingScriptExtension") << use

        when:
        succeeds 'customTask'

        then:
        outputContains("Executing task added by a 'Settings' plugin")

        where:
        settingScriptExtension | use
        '.gradle.kts'          | USE_KOTLIN
        '.gradle'              | USE
    }