interaction { noMoreInteractions() }

        where:
        vfsSpec << onlyDirectChildren(NO_COMMON_PREFIX)
    }

    def "invalidate a single child creates a partial directory node without the child (#vfsSpec)"() {
        setupTest(vfsSpec)

        when:
        def resultRoot = initialRoot.invalidate(searchedPath, CASE_SENSITIVE, diffListener).get()
        then:

        interaction { noMoreInteractions() }

        where:
        vfsSpec << COMMON_PREFIX
    }

    def "store child with no common prefix adds it (#vfsSpec)"() {
        setupTest(vfsSpec)
        def snapshot = Mock(MetadataSnapshot)
        def newChildPath = searchedPath.asString
        def newChild = mockChild()

        when:

        assert spec.getTasks() == [':a', ':b', ':c', ':d'] as Set

        when:
        spec.assertMatches(-1, [':a', ':b', ':c', ':d'])

        then:
        noExceptionThrown()

        when:
        spec.assertMatches(-1, [':b', ':a', ':c', ':d'])

        then:
        noExceptionThrown()

        when:
        spec.assertMatches(-1, [':b', ':d', ':a', ':c'])

        then:

    }

    def "isTraceEnabled returns false when level is #level"() {
        when:
        globalLevel = level

        then:
        !logger().traceEnabled
        !logger().isTraceEnabled(null)

        where:
        level << LogLevel.values()
    }

    def "isDebugEnabled returns #enabled when level is #level"() {
        when:
        globalLevel = level

        then:

        def evaluation = Mock(TestEvaluation)

        when:
        def result = context().tryEvaluate(owner, "fallback", evaluation)

        then:
        1 * evaluation.evaluate() >> "result"
        result == "result"
    }

    def "fallback value is used when circular evaluation detected"() {
        given:
        def evaluation = Mock(TestEvaluation)

        when:
        def result = context().evaluate(owner) {

    def "create a cursor at (0,0) when using factory method 'newBottomLeft'"() {
        when:
        Cursor cursor = Cursor.newBottomLeft()

        then:
        cursor.row == 0
        cursor.col == 0
    }

    def "create a cursor at (#row, #col) when using factory method 'at'"() {
        when:
        Cursor cursor = Cursor.at(row, col)

        then:

        then:
        found == ['test1', 'test2', 'test3', 'test4',
                  'system1', 'system2', 'system3', 'system4']

        where:
        directive << ["include", "import"]
    }

    def "finds #directive where whitespace surrounds the # character"() {
        when:
        sourceFile << """
  #  include   "test1"
\t#\tinclude "test2"
\u0000#include "test3"

  #  include   <system1>

        given:
        def dslDir = sample.dir.file(dsl)
        executer.inDirectory(dslDir)

        when:
        succeeds('copyReport2')

        then:
        dslDir.file('build/toArchive/my-report.pdf').isFile()

        where:
        dsl << ['groovy', 'kotlin']
    }

    @UsesSample("files/copy")
    def "can copy a single file using the file method with #dsl dsl"() {

                parameters {
                    testParam = namedParam
                }
            }
        """

        when:
        succeeds("runWork")

        then:
        outputContains("bar")

        where:
        isolationMode << ISOLATION_MODES
    }

    def "can provide property parameters with isolation mode #isolationMode"() {
        buildFile << """

        when:
        run("build")

        then:
        assertTestPassed("my.lib.LibraryTest", "someLibraryMethod returns true")

        where:
        scriptDsl << ScriptDslFixture.SCRIPT_DSLS
    }

    def "creates with gradle.properties when using #scriptDsl build scripts with --incubating"() {
        when: