}

    @Test
    fun `can serialize Kotlin action with Property`() {
        val loaded = valueCarriedBy(roundtripOf(isolatedActionCarrying(propertyOf("42"))))
        assertThat(
            loaded.get(),
            equalTo("42")
        )
    }

    @Test
    fun `can serialize Java lambda with Property`() {
        assertProviderRoundtrip(
            propertyOf("42"),
            "42"
        )
    }

    @Test

            }
            // TODO - should preserve the property type (which may be different to the provider type)
            ProviderInternal<S> provider = Cast.uncheckedNonnullCast(state);
            return type.cast(propertyOf(provider.getType(), provider));
        }

        <V> Property<V> propertyOf(Class<V> type, Provider<V> value) {
            return propertyFactory.property(type).value(value);
        }

        @Override

     */
    Property<T> value(@Nullable T value);

    /**
     * Sets the property to have the same value as the given provider, replacing whatever value the property already had.
     * This property will track the value of the provider and query its value each time the value of the property is queried.
     * When the provider has no value, this property will also have no value. This is the same as {@link #set(Provider)}

  <packaging>pom</packaging>

  <profiles>

    <profile>
      <id>property-name-project-version</id>
      <activation>
        <property>
          <name>${project.version}</name>
        </property>
      </activation>
    </profile>
    <profile>
      <id>property-value-project-version</id>
      <activation>
        <property>
          <name>project.version</name>
          <value>${project.version}</value>

Laura Kassovic <******@****.***> 1712936267 -0700

 *
 * <p>The managed property represents a property that is able to serve all its declaring view methods. For example, if the view
 * 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>
 *

    /**
     * A factory method for a walker that can visit the property hierarchy of an instance.
     *
     * When visiting a nested property, child properties are discovered using the type of the
     * return property value. This can be a more specific type than the return type of the property's
     * getter method (and can declare additional child properties).
     *

     *
     * @see #properties(Map)
     * @see #property(String, Object)
     */
    public void setProperties(Map<String, Object> properties) {
        this.properties.clear();
        properties(properties);
    }

    /**
     * Adds a property to be written to the properties file.
     * <p>
     * A property's value will be coerced to a <code>String</code> with <code>String#valueOf(Object)</code> or a

     */
    @Nonnull
    Map<String, String> getProperties(@Nonnull Project project);

    /**
     * Set a given project property.
     *
     * @param project the project to modify
     * @param key they property's key
     * @param value the value or {@code null} to unset the property
     */
    void setProperty(@Nonnull Project project, @Nonnull String key, @Nullable String value);

    @Nonnull

    }

    def "list property has empty list as value"() {
        expect:
        def property = factory.listProperty(String)
        property.present
        property.get().empty
    }

    def "can create list property with primitive type"() {
        given:
        def property = factory.listProperty(type)

        expect:
        property.elementType == boxedType

        where: