}

    @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

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

        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:

** `Property` extends the `Provider` interface.
** The method link:{javadocPath}/org/gradle/api/provider/Property.html#set-T-[Property.set(T)] specifies a value for the property, overwriting whatever value may have been present.

    /**
     * Creates a shallow copy of this property. Further changes to this property (via {@code set(...)}, or {@code convention(Object...)}) do not
     * change the copy. However, the copy still reflects changes to the underlying providers that constitute this property. Consider the following snippet:
     * <pre>
     *     def upstream = objects.property(String).value("foo")
     *     def property = objects.property(String).value(upstream)

        property.get() == someValue()

        property.set(someOtherValue())
        property.present
        property.get() == someOtherValue()
    }

    def "can use null convention value"() {
        def property = propertyWithNoValue()
        assert property.getOrNull() != someValue()

        expect:
        nullConvention(property)

        !property.present
        property.getOrNull() == null

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

 *     of the Java collection this collection property corresponds to</li>
 *     <li>{@link CollectingSupplier}, when the collection is still being added to - in that case,
 *     the collecting supplier will wrap a {@link Collector} that lazily represents the yet-to-be realized contents of the collection - see below for details</li>
 * </ul>
 *
 * <h3>Collectors</h3>
 * <p>