private final Class<?> targetClass;
        private final String property;

        public DslReference(Class<?> targetClass, String property) {
            this.targetClass = Preconditions.checkNotNull(targetClass);
            this.property = Preconditions.checkNotNull(property);
        }

        @Override
        public String getUrl() {

public abstract class ListBuildOption<T> extends AbstractBuildOption<T, CommandLineOptionConfiguration> {

    public ListBuildOption(String property) {
        super(property);
    }

    public ListBuildOption(String property, CommandLineOptionConfiguration... commandLineOptionConfigurations) {
        super(property, commandLineOptionConfigurations);
    }

    @Override

            import ${TaskAction.name};
            import ${Internal.name};
            import ${Property.name};

            public class CustomTask extends DefaultTask {
                private final Property<String> greeting = getProject().getObjects().property(String.class);

                @Internal
                public Property<String> getGreeting() {
                    return greeting;
                }

) : KtTreeVisitorVoid() {

    override fun visitProperty(property: KtProperty) {
        super.visitProperty(property)
        val isDelegate = property.hasDelegateExpression()
        if (!isDelegate) return

        val bindingContext = analysisContext.analyze(property)
        val descriptor = bindingContext.get(BindingContext.DECLARATION_TO_DESCRIPTOR, property)
        if (descriptor !is VariableDescriptorWithAccessors) return

                someTaskInputs.property = $reference
            }
        """
        when:
        configurationCacheRun "ok"
        configurationCacheRun "ok"

        then:
        outputContains("task.nested.property = $output")

        where:
        type                    | reference            | output
        "Property<String>"      | "'value'"            | "value"

object PropertyTest {
    @Test
    fun `read-only property cannot be written`() {
        val result = schema().resolve("x = y")
        val singleError = result.errors.single().errorReason
        assertIs<ErrorReason.ReadOnlyPropertyAssignment>(singleError)
        assertEquals("x", singleError.property.name)
    }

    @Test
    fun `write-only property cannot be read`() {
        val result = schema().resolve("y = z")

        }

        @Override
        public Property<Long> getRemoveUnusedEntriesOlderThan() {
            return removeUnusedEntriesOlderThan;
        }

        /**
         * @implNote Returns a supplier mapped from the property.  This provides a supplier that is resilient
         * to subsequent changes to the property value as opposed to just calling get() on the property.
         */
        @Override

    <profile>
      <id>dynamic-property-available</id>
      <activation>
        <property>
          <name>${activationProperty}</name>
        </property>
      </activation>
    </profile>

    <profile>
      <id>matches-another-property</id>
      <activation>
        <property>
          <name>foo</name>
          <value>${bar}</value>
        </property>
      </activation>
    </profile>

    }

    interface Dsl {
        val property: Property<String>
    }

    @Test
    fun `can serialize Java lambda with Gradle model`() {
        val stored = newInstance<Dsl>().apply {
            property.set("42")
        }
        val loaded = valueCarriedBy(roundtripOf(isolatedActionLambdaWith(stored)))
        assertThat(
            loaded.property.get(),
            equalTo("42")
        )
    }

                }

                @Restricted
                public abstract Property<String> getName();

                @Restricted
                public abstract Property<Boolean> getRead();

                @Restricted
                public abstract Property<Boolean> getWrite();
            }

            public static class Point {
                public final int xCoord;