given:
        property.finalizeValue()

        when:
        upstream1.set(someOtherValue())
        upstream2.set(someOtherValue())

        then:
        property.get() == someValue()
        upstream1.get() == someOtherValue()
        upstream2.get() == someOtherValue()
    }

    def "replaces provider with fixed value on next query of value when value implicitly finalized"() {

        1 * transform.transform(someValue()) >> someOtherValue()
        0 * transform._

        when:
        def result = mapped.get()

        then:
        result == someOtherValue()

        and:
        1 * transform.transform(someValue()) >> someOtherValue()
        0 * transform._

        when:
        assert mapped.getOrNull() == someOtherValue()

        given:
        def property = propertyWithValue(someValue())

        expect:
        property.isPresent()
        !property.isFinalized()

        when:
        property.set(someOtherValue())

        then:
        !property.isFinalized()

        when:
        property.finalizeValue()

        then:
        property.isFinalized()
    }

        when:
        property.replace { it.map { someOtherValue() } }

        then:
        property.get() == someOtherValue()
    }

    def "replace can modify property with convention"() {
        given:
        def property = property().convention(someValue())

        when:
        property.replace { it.map { someOtherValue() } }

        then:
        property.get() == someOtherValue()

        when:
        property.replace { it.map { someOtherValue() } }

        then:
        property.get() == someOtherValue()
    }

    def "replace can modify property with convention"() {
        given:
        property.convention(someValue())

        when:
        property.replace { it.map { someOtherValue() } }

        then:
        property.get() == someOtherValue()

    }

    @Override
    Class<Integer> type() {
        return Integer
    }

    @Override
    Integer someValue() {
        return 12
    }

    @Override
    Integer someOtherValue() {
        return 123
    }

    @Override
    Integer someOtherValue2() {
        return 1234
    }

    @Override
    Integer someOtherValue3() {
        return 12345
    }

    Class<RegularFile> type() {
        return RegularFile.class
    }

    @Override
    RegularFile someValue() {
        return baseDirectory.file("dir1").get()
    }

    @Override
    RegularFile someOtherValue() {
        return baseDirectory.file("other1").get()
    }

    @Override
    RegularFile someOtherValue2() {
        return baseDirectory.file("other2").get()
    }

    @Override

    Class<Directory> type() {
        return Directory.class
    }

    @Override
    Directory someValue() {
        return baseDirectory.dir("dir1").get()
    }

    @Override
    Directory someOtherValue() {
        return baseDirectory.dir("other1").get()
    }

    @Override
    Directory someOtherValue2() {
        return baseDirectory.dir("other2").get()
    }

    @Override

        when:
        property.replace { it.map { someOtherValue() } }

        then:
        property.get() == someOtherValue()
    }

    def "replace can modify property with convention"() {
        given:
        property.convention(someValue())

        when:
        property.replace { it.map { someOtherValue() } }

        then:
        property.get() == someOtherValue()

    }

    @Override
    Class<String> type() {
        return String
    }

    @Override
    String someValue() {
        "{s1}"
    }

    @Override
    String someOtherValue() {
        "{other1}"
    }

    @Override
    String someOtherValue2() {
        "{other2}"
    }

    @Override
    String someOtherValue3() {
        "{other3}"
    }

    @Override