}
            return finalizeOnNextGet || consumer == ValueSupplier.ValueConsumer.DisallowUnsafeRead;
        }

        @Override
        public ValueSupplier.ValueConsumer forUpstream(ValueSupplier.ValueConsumer consumer) {
            if (disallowUnsafeRead) {
                return ValueSupplier.ValueConsumer.DisallowUnsafeRead;
            } else {
                return consumer;
            }
        }

        taskTypeWithOutputFileProperty()
        settingsFile << "rootProject.name = 'broken'"
        buildFile """
            task producer(type: FileProducer) {
                output.disallowUnsafeRead()
                output = layout.buildDir.file("text.out")
                def other = file('ignore')
                doFirst {
                    try {
                        output = other

            interface ProjectModel {
                ConfigurableFileCollection getProp()
            }

            project.extensions.create('thing', ProjectModel.class)
            thing.prop.disallowUnsafeRead()
            thing.prop.from(layout.buildDirectory)

            try {
                thing.prop.files
            } catch(IllegalStateException e) {

        def property = propertyWithNoValue()

        property.set(b)
        property.disallowUnsafeRead()

        b.set(c)
        b.attachOwner(owner(), displayName("<b>"))

        c.set(someValue())
        c.attachOwner(owner(), displayName("<c>"))
        c.disallowUnsafeRead()

        given:
        property."$method"()

        when:
        b.set(someOtherValue())

        buildFile """
            interface ProjectModel {
                Property<String> getProp()
            }

            project.extensions.create('thing', ProjectModel.class)
            thing.prop.disallowUnsafeRead()
            thing.prop.set("value one")

            try {
                thing.prop.get()
            } catch(IllegalStateException e) {
                println("get failed with: " + e.message)

     * the value may be read. The property is also finalized on read.
     *
     * @since 6.4
     */
    void disallowUnsafeRead();

    }

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

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

    protected abstract S finalValue(EvaluationContext.ScopeContext context, S value, ValueConsumer consumer);

    protected void setSupplier(S supplier) {

        def task = Stub(Task)
        def prop = propertyWithNoValue()
        def location = prop.locationOnly
        prop.fileValue(file)
        prop.attachProducer(owner(task))
        prop.disallowUnsafeRead()

        when:
        def result = location.present

        then:
        result
        1 * host.beforeRead(null) >> null
    }

        where:
        description            | propertyConfig
        "default behaviour"    | ""
        "finalize on read"     | "it.finalizeValueOnRead()"
        "disallow unsafe read" | "it.disallowUnsafeRead()"
    }

    def "task input collection property can consume the mapped output of another task"() {
        taskTypeWithInputFileProperty()
        taskTypeWithInputListProperty()

    }

    def "cannot query files when unsafe reads disallowed and host is not ready"() {
        given:
        def file = new File('one')
        collection.from('a')
        collection.disallowUnsafeRead()

        when:
        collection.files

        then:
        def e = thrown(IllegalStateException)
        e.message == "Cannot query the value of <display> because <reason>."