then:
        1 * function.call() >> someValue()
        0 * _

        when:
        property.finalizeValue()
        property.implicitFinalizeValue()
        property.implicitFinalizeValue()
        property.disallowChanges()

        then:
        0 * _
    }

    def "can finalize after changes disallowed"() {

     * Implementations may then fail on subsequent changes, or generate a deprecation warning and ignore changes.
     */
    void implicitFinalizeValue();

        when:
        value.attachProducer(task)

        then:
        1 * property.attachProducer(task)

        when:
        value.maybeFinalizeValue()

        then:
        1 * property.implicitFinalizeValue()
    }

    def "creates value for null value"() {
        expect:
        def value = StaticValue.of(null)
        value.call() == null
        value.taskDependencies == TaskDependencyContainer.EMPTY

        when:
        collection.implicitFinalizeValue()

        then:
        0 * fileResolver._
    }

    def "can finalize when already implicitly finalized but not queried"() {
        given:
        def file = new File('one')
        collection.from('a')

        when:
        collection.implicitFinalizeValue()

        then:
        0 * fileResolver._

        }
    }

    @Override
    public void maybeFinalizeValue() {
        if (value instanceof HasConfigurableValue) {
            ((HasConfigurableValueInternal) value).implicitFinalizeValue();
        }
    }

    @Nullable
    @Override
    public Object call() {
        return value;
    }

    @Override
    public String toString() {
        return "Static: " + value;

        @Override
        public void maybeFinalizeValue() {
            if (isConfigurable()) {
                Object value = cachedInvoker.get();
                ((HasConfigurableValueInternal) value).implicitFinalizeValue();
            }
        }

        private boolean isProvider() {
            return Provider.class.isAssignableFrom(declaredType);
        }

        private boolean isConfigurable() {

    }

    def "cannot set to empty map after value finalized implicitly"() {
        given:
        property.set(someValue())
        property.implicitFinalizeValue()

        when:
        property.empty()


        then:
        def e = thrown IllegalStateException
        e.message == 'The value for this property cannot be changed any further.'
    }

        state.disallowChanges();
    }

    @Override
    public void finalizeValueOnRead() {
        state.finalizeOnNextGet();
    }

    @Override
    public void implicitFinalizeValue() {
        state.disallowChangesAndFinalizeOnNextGet();
    }

    @Override
    public void disallowUnsafeRead() {
        state.disallowUnsafeRead();
    }

    }

    def "cannot set to empty list after value finalized implicitly"() {
        given:
        def property = property()
        property.set(someValue())
        property.implicitFinalizeValue()

        when:
        property.empty()


        then:
        def e = thrown(IllegalStateException)
        e.message == 'The value for this property cannot be changed any further.'
    }

        valueState.disallowChanges();
    }

    @Override
    public void finalizeValueOnRead() {
        valueState.finalizeOnNextGet();
    }

    @Override
    public void implicitFinalizeValue() {
        // Property prevents reads *and* mutations,
        // however CFCs only want automatic finalization on query,
        // so we do not #disallowChanges().
        valueState.finalizeOnNextGet();
    }