}

    @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

    <property15>${property14}</property15>
    <property13>${property12}</property13>
    <property11>${property10}</property11>
    <property09>${property08}</property09>
    <property07>${property06}</property07>
    <property05>${property04}</property05>
    <property03>${property02}</property03>
    <property01>${property00}</property01>
    <property00>PASSED</property00>

     */
    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

        firstScope                                         | secondScope
        InterceptScope.readsOfPropertiesNamed("property1") | InterceptScope.readsOfPropertiesNamed("property2")
        InterceptScope.methodsNamed("method1")             | InterceptScope.methodsNamed("method2")
    }

    def "method and property scopes with the same name are not equal"() {
        when:
        InterceptScope methodScope = InterceptScope.methodsNamed("name")

        given:
        property.set(notDefined())
        and:
        property.put('k1', 'v1')
        property.put('k2', Providers.of('v2'))
        property.putAll(['k3': 'v3'])
        property.putAll(Providers.of(['k4': 'v4']))

        expect:
        !property.present
        property.getOrNull() == null
        property.getOrElse(['kk': 'vv']) == ['kk': 'vv']

        when:
        property.get()
        then:

 *
 * <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).
     *