when:
        property.prepareValue()

        then:
        1 * value.prepareValue()
        0 * value._

        when:
        property.cleanupValue()

        then:
        1 * value.cleanupValue()
        0 * value._
    }

    def "does not notify null property value"() {
        def valueWrapper = Stub(PropertyValue)

        then:
        1 * input1.prepareValue()
        1 * input3.prepareValue()

        when:
        fileCollection.cleanupValue()

        then:
        1 * input1.cleanupValue()
        1 * input3.cleanupValue()
    }

    def "notifies calculated files of task start and complete"() {
        def calculated = Mock(TestCollection)

        for (LifecycleAwareValue target : targets) {
            target.prepareValue();
        }
    }

    @Override
    public void cleanupValue() {
        taskIsExecuting = false;
        cachedFiles = null;
        for (LifecycleAwareValue target : targets) {
            target.cleanupValue();
        }
        targets = null;
        // Discard the calculated files collection too, but need to retain the display name for it
    }

            lifecycleAware = (LifecycleAwareValue) obj;
            lifecycleAware.prepareValue();
        }
    }

    @Override
    public void cleanupValue() {
        if (lifecycleAware != null) {
            lifecycleAware.cleanupValue();
        }
    }

        }
        try {
            return taskExecuter.execute(task, state, context);
        } finally {
            for (LifecycleAwareValue value : properties.getLifecycleAwareValues()) {
                value.cleanupValue();
            }
        }
    }

    void prepareValue();

    /**
     * Called after the completion of the unit of work, regardless of the outcome. The property implementation can release any state that was cached during execution.
     */
    void cleanupValue();

        def f1 = tmpDir.file("f1")
        def f2 = tmpDir.file("f2")
        collection.from(files)

        given:
        collection.prepareValue()
        collection.files
        collection.cleanupValue()

        expect:
        collection.files.empty

        files << f1
        collection.files as List == [f1]

        files << f2
        collection.files as List == [f1, f2]
    }

        } else {
            super.visitChildren(visitor);
        }
    }

    @Override
    public void prepareValue() {
        canCache = true;
    }

    @Override
    public void cleanupValue() {
        // Keep the files and discard the origin values instead?
        canCache = false;
        cachedValue = null;
    }

    }

    @Override
    public void prepareValue() {
        value.maybeFinalizeValue();
    }

    @Override
    public void cleanupValue() {
    }

        }

        @Override
        public void prepareValue() {
        }

        @Override
        public void cleanupValue() {
            compileStateCache = null;
            incrementalCompilation = null;
        }

        @Override
        public String getDisplayName() {
            return "header files for " + taskPath;