fun consume() {
        logger.quiet(message.get())
    }
}

val producer = tasks.register<Producer>("producer") {
    // Set values for the producer lazily
    // Don't need to update the consumer.inputFile property. This is automatically updated as producer.outputFile changes
    outputFile = layout.buildDirectory.file("file.txt")
}
tasks.register<Consumer>("consumer") {

        def input = file('input.txt').createFile()
        buildFile << """
            class IncrementalTask extends DefaultTask {
                @InputFile File input

                @TaskAction execute(InputChanges inputChanges) {
                }
            }

            task noOutput(type: IncrementalTask) {
                input = file('${input.name}')

                        assert canBeConsumed
                    }
                }
            }

            class ShowFileCollection extends DefaultTask {
                @InputFiles
                final ConfigurableFileCollection files = project.objects.fileCollection()

                ShowFileCollection() {
                    outputs.upToDateWhen { false }
                }

 * limitations under the License.
 */
package org.gradle.plugins.ide.internal.generator.generator;

import java.io.File;

public interface PersistableConfigurationObject {
    void load(File inputFile);

    void loadDefaults();

    void store(File outputFile);

import org.junit.rules.TemporaryFolder;

/**
 * @author wyukawa
 *
 */
public class PropertiesUtilTest {

    URL url = ResourceUtil.getResource(getClass().getName().replace('.', '/') + ".txt");

    File inputFile = URLUtil.toFile(url);

    /**
     *
     */
    @Rule
    public TemporaryFolder tempFolder = new TemporaryFolder();

    /**
     * @see org.junit.rules.ExpectedException
     */
    @Rule

        dir.file("build.gradle") << """
            @CacheableTask
            class Broken extends DefaultTask {
                FileCollection processorListFile = project.layout.files("input.txt")

                @InputFiles
                @PathSensitive(PathSensitivity.NONE)
                FileCollection getProcessorListFile() {
                    this.processorListFile
                }

                @OutputFile

                implementation 'non:existent:1.0'
            }

            repositories {
                maven { url = uri('${emptyRepo.uri}') }
            }

            class Bean {
                @InputFiles FileCollection files
            }

            abstract class Test extends DefaultTask {
                @Nested abstract Property<Bean> getBean()
                @TaskAction def test() { assert false }
            }

import org.gradle.api.model.ObjectFactory;
import org.gradle.api.provider.Property;
import org.gradle.api.provider.Provider;
import org.gradle.api.tasks.InputFiles;
import org.gradle.api.tasks.Internal;
import org.gradle.api.tasks.PathSensitive;
import org.gradle.api.tasks.PathSensitivity;
import org.gradle.internal.classpath.types.InstrumentationTypeRegistry;

                    assert source as List == sourceSet.groovy  as List
                    assert codenarcClasspath == project.configurations.codenarc
                    assert config.inputFiles.singleFile == project.file("config/codenarc/codenarc.xml")
                    assert configFile == project.file("config/codenarc/codenarc.xml")
                    assert maxPriority1Violations == 0

                def fileFactory = gradle.services.get(org.gradle.api.internal.file.FileFactory)
                def inputFile = fileFactory.file(file('${normaliseFileSeparators(buildLogicInput.absolutePath)}'))
                def text = providers.fileContents(inputFile).asText.get()
                println text
            """
        }

        when: