Properties props = cliRequest.getUserProperties();
        if (cliRequest.getRootDirectory() != null) {
            props = new Properties();
            props.putAll(cliRequest.getUserProperties());
            props.put("session.rootDirectory", cliRequest.getRootDirectory().toString());
        }
        settingsRequest.setUserProperties(props);

        when:
        render conflictingAnnotationsMessage {
            type('Whatever').property('prop')
            inConflict('Input', 'Output')
            includeLink()
        }

        then:
        outputEquals """
Type 'Whatever' property 'prop' has conflicting type annotations declared: @Input, @Output.

            it.parameters.prop = "value 1"
        }
        def parameters = registry.registrations.getByName("service").parameters
        def service = provider.get()

        when:
        parameters.prop = "ignore me 1"

        then:
        service.prop == "value 1"

        when:
        service.parameters.prop = "ignore me 2"

        then:

            version = artifact.getVersionRange().toString();
        }

        Map<String, String> props = null;
        if (org.apache.maven.artifact.Artifact.SCOPE_SYSTEM.equals(artifact.getScope())) {
            String localPath = (artifact.getFile() != null) ? artifact.getFile().getPath() : "";
            props = Collections.singletonMap(MavenArtifactProperties.LOCAL_PATH, localPath);
        }

    @Test
    public void testRecursiveExpressionCycleNPE() throws Exception {
        Map<String, String> props = new HashMap<>();
        props.put("aa", "${bb}");
        props.put("bb", "${aa}");
        DefaultModelBuildingRequest request = new DefaultModelBuildingRequest();

        Model model = Model.newBuilder().properties(props).build();

        SimpleProblemCollector collector = new SimpleProblemCollector();

                @TaskAction
                void go() {
                    println "value: " + prop.get()
                }
            }

            task show(type: SomeTask) {
                def layout = project.layout
                prop = [layout.projectDir.file("in.txt")]
                doFirst {
                    prop.set([layout.projectDir.file("other.txt")])
                }
            }
"""

                String toString() { return "<display name> prop=" + prop }
            }

            def displayName = extensions.create("name", DisplayName)
            println("display name = \${displayName}")
        """

        expect:
        succeeds()
        outputContains("display name = <display name> prop=extension 'name' property 'prop'")
    }

			}
		}
		if (prop.ValueValidation == nil || len(prop.ValueValidation.Enum) == 0) && len(f.EnumValues()) != 0 {
			t.Errorf("field had more enum values than the property. field: %s", f.Name)
		}
		if prop.ValueValidation != nil {
			fevs := f.EnumValues()
			for _, fev := range fevs {
				found := false
				for _, pev := range prop.ValueValidation.Enum {

                String getProp()
                void setProp(String value)
            }

            def t = objects.newInstance(Thing)
            assert t.prop == null
            t.prop = "value"
            assert t.prop == "value"
"""

        expect:
        succeeds()
    }

    def "plugin can create instance of interface with read-only FileCollection property"() {
        buildFile """

                @TaskAction
                void go() {
                    println("beans = \${beans.collect { it.prop.get() } }")
                }
            }

            tasks.create("thing", MyTask) {
                beans {
                    one { prop = '1' }
                    two { prop = '2' }
                }
            }
        """

        when:
        succeeds("thing")