def arg = new Object()
        def id
        def decoratedAction

        when:

        context.apply(Stub(UserCodeSource)) {
            id = it
            decoratedAction = decorator.decorate('foo', action)
        }

        then:
        !decoratedAction.is(action)

        when:
        decoratedAction.execute(arg)

        then:
        1 * action.execute(arg)

            public class Main { ToolImpl t = new ToolImpl(); }
        """

        when:
        succeeds ":b:${language.compileTaskName}"

        then:
        executedAndNotSkipped ":a:${language.compileTaskName}"
        executedAndNotSkipped ":b:${language.compileTaskName}"

        when:
        // change signatures
        sourceFile.text = """
            public class ToolImpl {

            0 * ansi._
        }
    }

    def "doesn't do any ansi calls when visibility is set to false before the first redraw"() {
        given:
        fillArea()

        when:
        progressArea.setVisible(false)
        redraw()

        then:
        0 * ansi._
    }

    def "doesn't scroll the area when visibility is set to false"() {
        given:
        fillArea()

            """
        }

        when:
        configurationCacheRun ":a:some"

        then:
        result.groupedOutput.task(":a:some").assertOutputContains("FIRST").assertOutputContains("LAST")

        when:
        configurationCacheRun ":a:some"

        then:
        result.groupedOutput.task(":a:some").assertOutputContains("FIRST").assertOutputContains("LAST")

        """
    }

    def "Appends additional JVM arguments"() {
        when:
        BuildEnvironment env1 = loadBuildEnvironment { builder -> builder.addJvmArguments(JVM_ARG_1) }

        then:
        env1.java.jvmArguments.contains(JVM_ARG_1)

        when:
        BuildEnvironment env2 = loadBuildEnvironment { builder -> builder.addJvmArguments([JVM_ARG_1]) }

        then:

        methods: ["l7-method"]
  # L4 and L7 when
  - when:
    - key: "source.namespace"
      values: ["when-l4-l7-ns"]
    - key: "connection.sni"
      values: [ "when-l4-l7-sni"]
  # L4 only when
  - when:
    - key: "source.namespace"
      values: ["when-l4-ns"]
    - key: "source.ip"
      values: ["10.10.10.10"]
  # L7 only when
  - when:
    - key: "connection.sni"
      values: [ "when-l7-sni"]

    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:

        given:
        file("settings.gradle") << 'rootProject.name="hello-world"'

        when:
        CustomModel customModel = withConnection { it.action(new FetchCustomModel()).run() }

        then:
        customModel.gradle.name == "hello-world"
        customModel.eclipse.gradleProject.name == "hello-world"

        when:
        IdeaProject ideaModel = withConnection { it.action(new FetchIdeaModel()).run() }

class TreeFormatterTest extends Specification {
    def formatter = new TreeFormatter()

    def "formats single node"() {
        when:
        formatter.node("Some thing.")

        then:
        formatter.toString() == "Some thing."
    }

    def "formats root with no children"() {
        when:
        formatter.node("Some thing.")
        formatter.startChildren()
        formatter.endChildren()

        then:

            """
        }

        when:
        result = runWithMostRecentFinalRelease(JAR_TASK_NAME)

        then:
        javaProject.mainClassFile.assertIsFile()
        javaProject.redundantClassFile.assertIsFile()
        javaProject.assertJarHasDescendants(javaProject.mainClassFile.name, javaProject.redundantClassFile.name)

        when:
        forceDelete(javaProject.redundantSourceFile)