def args = parser.parse("--some-option", "abc", "--some-flag")
        def bean = converter.convert(args, new Bean())

        then:
        bean.flag
        bean.prop == "abc"
    }

    def "can convert properties"() {
        def converter = set.propertiesConverter()

        when:
        def bean = converter.convert(["some.option": "abc", "some.flag": "true"], new Bean())

        then:

            execute("some string", ["array"], file("test"))

            execute(["some", "string"] as String[])
            execute(["some", "string"] as String[], ["array"] as String[], file("test"))
            execute(["some", "string"] as String[], ["array"], file("test"))

            execute(["some", "string"])
            execute(["some", "string"], ["array"] as String[], file("test"))

        given:
        idGenerator.generateId() >> 1
        timeProvider.currentTime >> 1200

        when:
        processor.testClassStarted("some-test")

        then:
        1 * target.started({it.id == 1 && it.className == 'some-test'}, {it.startTime == 1200})
        0 * target._
    }

    def "fires event on test class finish"() {
        given:
        idGenerator.generateId() >> 1

        result.add(new TestMethodResult(1, "some test", "some test displayName", SUCCESS, 15, startTime + 25))
        result.add(new TestMethodResult(2, "some test two", "some test two displayName", SUCCESS, 15, startTime + 30))

        message.contains('some.GradleScript.foo')

        message.contains('SimulatedJavaCallLocation.create')
        message.count('java.lang.reflect.Method.invoke') == 3
        message.contains('some.Class.withoutSource')
        message.contains('some.Class.withNativeMethod')
        message.contains('some.KotlinGradleScript')

        where:
        fakeStackTrace = [

            }
        """

        when:
        configurationCacheRun "some"

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

        when:
        configurationCacheRun "some"

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

        when:

        ProcessGroovyMethodsExecute.execute(listOf("some", "string"))
        ProcessGroovyMethodsExecute.execute(listOf("some", "string"), arrayOf("string"), file("test"))
        ProcessGroovyMethodsExecute.execute(listOf("some", "string"), listOf("array"), file("test"))

        val e = RuntimeExec()
        e.exec("some string")
        e.exec("some string", arrayOf("string"))

            </activation>
            <properties>
                <some.group>group-two</some.group>
                <some.artifact>artifact-two</some.artifact>
                <some.version>version-two</some.version>
            </properties>
        </profile>
    </profiles>
</project>
"""

        when:
        parsePom()

        then:

        annotation.value() as Set == ["some-type", Transformer.name, Runnable.name] as Set
        annotation.classes() == [] as Class[]
    }

    static class Transformer {
    }
}

@GroovyASTTransformationClass("some-type")
@interface WithNameSpecified {
}

@GroovyASTTransformationClass(["some-type", "some-other-type"])
@interface WithNamesSpecified {
}

        0 * _

        !outputs.file.exists()
        outputs.dir.assertHasDescendants("some/notOutput1.txt", "some/notOutput2")
        !outputs.dir.file("some/dir").exists()
        !outputs.dir.file("some/lonelyDir").exists()
        !outputs.dir.file("some/another").exists()
        outputs.dir.file("some/notOutput2").isDirectory()
    }

    def "does not clean prepared directories"() {