given:
        def value = StaticValue.of(property)
        value.call() == property
        value.taskDependencies == property

        when:
        value.attachProducer(task)

        then:
        1 * property.attachProducer(task)

        when:
        value.maybeFinalizeValue()

        then:
        1 * property.implicitFinalizeValue()
    }

    def "creates value for null value"() {

            return context -> context.add(value);
        }
        return TaskDependencyContainer.EMPTY;
    }

    public void attachProducer(Task producer) {
        if (value instanceof PropertyInternal) {
            ((PropertyInternal<?>) value).attachProducer((ModelObject) producer);
        }
    }

    @Override
    public void maybeFinalizeValue() {
        if (value instanceof HasConfigurableValue) {

        def task = Stub(Task)
        def owner = Stub(ModelObject)
        owner.taskThatOwnsThisObject >> task
        def action = Mock(Action)

        when:
        var.attachProducer(owner)
        def producer = var.producer

        then:
        producer.known

        when:
        producer.visitProducerTasks(action)

        then:
        1 * action.execute(task)

        given:
        def task = Stub(Task)
        def prop = propertyWithNoValue()
        def location = prop.locationOnly
        prop.attachProducer(owner(task))
        assertHasProducer(prop, task)

        expect:
        assertHasNoProducer(location)
    }

    def "location provider does not check producer when source property is strict"() {

        _ * owner.taskThatOwnsThisObject >> task
        def property = TestUtil.objectFactory().property(String)
        property.attachOwner(owner, Describables.of("<prop>"))
        property.attachProducer(owner)
        property.set("12")
        return property
    }

    Property<String> propertyWithCompletedProducer() {
        def task = Mock(Task)
        def state = Mock(TaskState)

        return annotations;
    }

    @Override
    public void applyRoleTo(ModelObject owner, Object target) {
        if (target instanceof PropertyInternal) {
            ((PropertyInternal<?>) target).attachProducer(owner);
        }
    }

    /**
     * Associates this property with the task that produces its value.
     */
    void attachProducer(ModelObject owner);

    /**
     * A simple getter that checks if this property has been finalized.
     *
     * @return {@code true} if this property has been finalized, {@code false} otherwise
     */

        _ * owner.taskThatOwnsThisObject >> task
        def property = TestUtil.objectFactory().property(String)
        property.attachOwner(owner, Describables.of("<prop>"))
        property.attachProducer(owner)
        property.set("12")
        return property
    }

    Property<String> propertyWithCompletedProducer() {
        def task = Mock(Task)
        def state = Mock(TaskState)

        return taskMutator.mutate("TaskOutputs.file(Object)", (Callable<TaskOutputFilePropertyBuilder>) () -> {
            StaticValue value = new StaticValue(path);
            value.attachProducer(task);
            TaskOutputFilePropertyRegistration registration = new DefaultTaskOutputFilePropertyRegistration(value, OutputFilePropertyType.FILE);
            registeredFileProperties.add(registration);

        def owner2 = owner()
        owner2.modelIdentityDisplayName >> displayName("<owner 2>")

        given:
        def property = propertyWithNoValue()
        property.attachProducer(owner1)

        when:
        property.attachProducer(owner2)

        then:
        def e = thrown(IllegalStateException)