* 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);

        expect:
        !taskClassInfoStore.getTaskClassInfo(MyNonCacheableTask).cacheable
    }


    private static class NonAnnotatedTask extends DefaultTask {
        File inputFile

        @SuppressWarnings("GrMethodMayBeStatic")
        String getValue() {
            "test"
        }
    }

    def "class infos are cached"() {

// A task that generates a source file and writes the result to an output directory
abstract class GenerateSource extends DefaultTask {
    // The configuration file to use to generate the source file
    @InputFile
    abstract RegularFileProperty getConfigFile()

    // The directory to write source files to
    @OutputDirectory
    abstract DirectoryProperty getOutputDir()

    @TaskAction
    def compile() {

import java.io.File;

/**
 * Responsible for reading, configuring and writing a config object of type T to/from a file.
 * @param <T>
 */
public interface Generator<T> {
    T read(File inputFile);

    T defaultInstance();

    void configure(T object);

    void write(T object, File outputFile);

            }
        }
    }

    def "single root file are represented as roots"() {
        given:
        withBuildCache()
        file('inputFile').text = 'inputFile'
        buildScript """
            task copy(type:Copy) {
               from 'inputFile'
               into 'destDir'
            }
        """
        when:
        succeeds("copy")

        then:

                    return "an input to $workDisplayName has changed"
                }
            }
            is ConfigurationCacheFingerprint.InputFile -> input.run {
                return when (checkFileUpToDateStatus(file, hash)) {
                    FileUpToDateStatus.ContentsChanged -> "file '${displayNameOf(file)}' has changed"

sealed class RegisteredProperty {

    data class Input(
        val propertyName: String,
        val propertyValue: PropertyValue,
        val optional: Boolean
    ) : RegisteredProperty()

    data class InputFile(
        val propertyName: String,
        val propertyValue: PropertyValue,
        val optional: Boolean,
        val filePropertyType: InputFilePropertyType,
        val behavior: InputBehavior,

import org.gradle.api.internal.file.copy.DefaultCopySpec;
import org.gradle.api.internal.file.copy.RenamingCopyAction;
import org.gradle.api.model.ObjectFactory;
import org.gradle.api.tasks.Classpath;
import org.gradle.api.tasks.InputFile;
import org.gradle.api.tasks.Internal;
import org.gradle.api.tasks.Optional;
import org.gradle.api.tasks.PathSensitive;
import org.gradle.api.tasks.PathSensitivity;
import org.gradle.internal.Transformers;

            }
        }

        abstract fun write(value: ConfigurationCacheFingerprint, trace: PropertyTrace? = null)

        fun inputFile(file: File) =
            InputFile(
                file,
                host.hashCodeOf(file)
            )

        fun inputFileSystemEntry(file: File) =
            InputFileSystemEntry(file, fileSystemEntryType(file))

                    def inputFiles = parameters.nestedBean.inputFiles
                    def input = inputArtifact.get().asFile
                    println "processing \${input.name} using \${inputFiles*.name}"
                    def output = outputs.file(input.name + ".green")
                    def paramContent = inputFiles.collect { it.file ? it.text : it.list().length }.join("")