!output.contains("profile=myvalue")
    }

    def "can use -- to specify a task option with same name as a built-in option"() {
        when:
        buildScript """
            ${defineTaskWithProfileOption()}

            tasks.register('mytask', MyTask.class)
        """

        then:
        succeeds "--", "mytask", "--profile", "myvalue"
        output.contains "profile=myvalue"

        then:
        assert parameter instanceof ValidParameter

        when:
        parameter.setBooleanValue(true)
        parameter.setValue("myValue")

        then:
        assert parameter.isBooleanValue()
        assert parameter.getValue() == "myValue"
    }

    interface ValidParameter {
        void setValue(String value)
        String getValue()
        void setBooleanValue(boolean booleanValue)

public class JavaMethodTestSubject implements JavaMethodTestSubjectInterface {
    private static String myStaticProperty;

    final IllegalStateException failure = new IllegalStateException();
    private String myProp = "myValue";

    public static String getStaticProperty() {
        return myStaticProperty;
    }

    public static void setStaticProperty(String value) {
        myStaticProperty = value;
    }

        return "project-prop";
    }

    @Override
    protected String getPropertyOptionDescription() {
        return "Set project property for the build script (e.g. -Pmyprop=myvalue).";
    }

    protected String getPropertyOptionDetailed() {
        return "system-prop";
    }

    @Override
    protected String getPropertyOptionDescription() {
        return "Set system property of the JVM (e.g. -Dmyprop=myvalue).";
    }

        def parameterType = ValidParameter
        def parameterInitializer = new Action<ValidParameter>() {
            @Override
            void execute(ValidParameter parameter) {
                parameter.setValue("myValue")
                parameter.setBooleanValue(true)
            }
        }

        when:
        def result = controller.getModel(modelElement, GradleBuild, parameterType, parameterInitializer)

    def "read property"() {
        expect:
        readableProperty(JavaTestSubject, String, "myProperty").getValue(myProperties) == "myValue"
    }

    def "read property using instance"() {
        expect:
        readableProperty(myProperties, String, "myProperty").getValue(myProperties) == "myValue"
    }

    def "write property"() {
        when:

        when:
        visitProperties(task)

        then:
        _ * visitor.visitOutputFilePropertiesOnly() >> false
        1 * visitor.visitInputProperty('myProperty', { it.call() == 'myValue' }, false)
        1 * visitor.visitInputFileProperty('inputFile', _, _, _, _, _, _, InputFilePropertyType.FILE)
        1 * visitor.visitInputFileProperty('inputFiles', _, _, _, _, _, _, InputFilePropertyType.FILES)

import java.util.Collection;
import java.util.Set;

@SuppressWarnings("UnusedDeclaration")
public class JavaTestSubject {

    final IllegalStateException failure = new IllegalStateException();
    private String myProp = "myValue";
    private String myProp2;
    private boolean myBooleanProp = true;
    public String myField = "myFieldValue";
    public boolean myBooleanField = true;
    private static String myStaticProperty;

                                }
                            }
                            properties.set(mapOf(
                                "myProp" to "myValue",
                                "prop.with.dots" to "anotherValue"
                            ))
                            withXml {