def cleanup() {
        factory.stop()
    }

    def createsANonBlockingActorForATargetObject() {
        when:
        def actor = factory.createActor(target)

        then:
        actor != null
    }

    def cachesTheNonBlockingActorForATargetObject() {
        when:
        def actor1 = factory.createActor(target)
        def actor2 = factory.createActor(target)

        then:

    def "appends text to current line"() {
        def output = output()

        when:
        output.text("some text")

        then:
        result.toString() == "[some text]"
    }

    def "append empty lines [#type]"() {
        def output = output()

        when:
        output.text(eol)
        output.text(eol)
        output.text("$eol$eol")

        then:

        "current JVM"    | "when toolchains are not configured" | null     | null           | null              | "current"
        "java extension" | "when configured"                    | null     | null           | "other"           | "other"
        "executable"     | "when configured"                    | null     | "other"        | null              | "other"

            }
        """

        when:
        run "signCustomFile"

        then:
        executedAndNotSkipped(":signCustomFile")
        file("input.txt.asc").exists()

        when:
        inputFile.text = "bar"
        run "signCustomFile"

        then:
        executedAndNotSkipped(":signCustomFile")

        when:
        run "signCustomFile"

        then:

        expect:
        extension.foo == null

        when:
        extension.foo = "bar"

        then:
        extension.foo == "bar"
    }

    def "cannot read or write unregistered property using groovy syntax"() {
        when:
        extension.foo

        then:
        thrown(MissingPropertyException)

        when:
        extension.foo = "bar"

        then:

        "current JVM"    | "when toolchains are not configured" | null     | null           | null              | "current"
        "java extension" | "when configured"                    | null     | null           | "other"           | "other"
        "executable"     | "when configured"                    | null     | "other"        | null              | "other"

        when:
        outputStream.close()

        then:
        action.endOfStream(null)

        when:
        outputStream.write("ignore me".getBytes())

        then:
        thrown(IOException)
    }

    def splitsLongLines() {
        when:

            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()

        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: