A mutable managed property is declared using an abstract getter method of type `Property<T>`, where `T` can be any serializable type or a <<#managed_types,fully managed Gradle type>>.
The property must not have any setter methods.

Here is an example of a task type with an `uri` property of type `URI`:

[source,java]
.Download.java
----

import static org.gradle.internal.instrumentation.api.annotations.ReplacedAccessor.AccessorType.GETTER;
import static org.gradle.internal.instrumentation.api.annotations.ReplacedAccessor.AccessorType.SETTER;
import static org.gradle.internal.instrumentation.api.annotations.ReplacesEagerProperty.BinaryCompatibility.ACCESSORS_KEPT;
import static org.gradle.util.internal.CollectionUtils.collect;

/**

        result instanceof ExecuteBuildAction
        result.startParameter."${buildOptionName}" == expectedValue

        where:
        // Check all mutable boolean properties (must manually check for setters as many of them return StartParameter)
        buildOptionName << Introspector.getBeanInfo(StartParameterInternal).propertyDescriptors
            .findAll { it.propertyType == boolean }

  }

  // setFuture and cancel() interact in more complicated ways than the other setters.
  public void testSetFutureCancelBash() {
    if (isWindows()) {
      return; // TODO: b/136041958 - Running very slowly on Windows CI.
    }
    final int size = 50;
    final CyclicBarrier barrier =
        new CyclicBarrier(
            2 // for the setter threads
                + size // for the listeners

        @Override
        @SuppressWarnings("deprecation") // StartParameter.setSettingsFile()
        public void applyTo(StartParameterInternal startParameter) {
            // Note that order is important here, as the setters have some side effects
            if (buildLayout.getProjectDir() != null) {
                startParameter.setProjectDir(buildLayout.getProjectDir());
            }

        this.sortOrder = value;
    }

    public String getTerm() {
        checkSpecifiedProperty("term");
        return convertEmptyToNull(term);
    }

    public void setTerm(String value) {
        registerModifiedProperty("term");
        this.term = value;
    }

    public String getUpdatedBy() {
        checkSpecifiedProperty("updatedBy");

     * ListProperty[T] -> original type becomes List[T]
     * ConfigurableFileCollection -> original type becomes FileCollection
     */
    Class<?> originalType() default DefaultValue.class;

    /**
     * Whether the setter accessor for property was fluent
     */
    boolean fluentSetter() default false;

    /**
     * Configuration for binary compatibility check, see {@link BinaryCompatibility}
     */

 * types declaring the struct only specify the property via a getter, then the managed property will be read-only. However, if
 * even one of the view types declare a setter for the property, it will be a read-write property. </p>
 *
 * <p>Different views can declare the same getter with different return types. In such a case the type of the managed property

        override val analysisContext: Fe10AnalysisContext
    ) : KaValueParameterSymbol(), KaFe10Symbol {
        val descriptor: ValueParameterDescriptor?
            get() = propertyDescriptor.setter?.valueParameters?.singleOrNull()

        override val hasDefaultValue: Boolean
            get() = withValidityAssertion { false }

        override val isVararg: Boolean

			if len(expectedOut) == 0 {
				t.Fatal("expected output is empty")
			}

			var out bytes.Buffer
			rootCmd := Cmd(ctx)
			rootCmd.SetArgs(tt.args)
			rootCmd.SetOut(&out)
			rootCmd.SetErr(&out)

			fErr := rootCmd.Execute()
			if fErr != nil {
				t.Fatal(fErr)
			}
			output := out.String()
			if output != expectedOut {
				t.Fatalf("expected %s, got %s", expectedOut, output)
			}