}
            }

            ${verifyDaemonsTask}
        """

        when:
        inputFile.text = initialSourceContent

        then:
        succeeds(compileTaskName)

        when:
        inputFile.text = changedSourceContent

        then:
        buildTriggeredAndSucceeded()

        and:

    def "should trigger rebuild when java source file is changed during build execution"() {
        given:
        def inputFile = file("src/main/java/Thing.java")
        inputFile << "class Thing {}"
        inputFile.makeOlder()

        when:
        buildFile << """
apply plugin: 'java'

task postCompile {
    doLast {
        if (!file('change-triggered').exists()) {

            xml.attributes().put("name", rootElement)
        }
    }

    def loadsFromXmlFile() {
        def inputFile = tmpDir.file('input.xml')
        inputFile.text = '<root name="some-xml"/>'

        when:
        object.load(inputFile)

        then:
        rootElement == 'some-xml'
    }

    def loadsFromDefaultResource() {
        when:
        object.loadDefaults()

    def "changes are detected when parent of input is symlinked"() {
        def targetDir = file("target")
        def inputFile = targetDir.file("input.txt")
        def linkedDir = file("linked-dir").createLink(targetDir)

        inputFile.text = "original"

        buildFile << """
            task myTask {
                def outputFile = file("build/output.txt")

                File outputFile

                @InputFile
                @PathSensitive(PathSensitivity.NONE)
                File inputFile

                @TaskAction
                public void makeOutput() {
                    outputFile.text = "done"
                }
            }

            task cacheable(type: CustomTask) {
                inputFile = file("input")

package com.example;

import org.gradle.api.DefaultTask;
import org.gradle.api.file.RegularFileProperty;
import org.gradle.api.provider.ListProperty;
import org.gradle.api.tasks.InputFile;
import org.gradle.api.tasks.Internal;
import org.gradle.api.tasks.PathSensitive;
import org.gradle.api.tasks.PathSensitivity;
import org.gradle.api.tasks.TaskAction;

import java.io.IOException;
import java.nio.file.Files;
import java.util.regex.Pattern;

        when:
        run "signJar"

        then:
        skipped(":signJar")
    }

    def "out-of-date when input file changes"() {
        given:
        def inputFile = file("input.txt")
        inputFile.text = "foo"
        buildFile << """
            ${keyInfo.addAsPropertiesScript()}
            signing {
                ${signingConfiguration()}
            }

            filePrefix = filePrefix.replaceAll("\\p{Zs}", "_");
        } else {
            filePrefix = "none";
            extention = "";
        }
        File inputFile = null;
        File outputFile = null;
        try {
            inputFile = File.createTempFile("cmdextin_" + filePrefix + "_", StringUtil.isNotBlank(extention) ? "." + extention : extention,
                    tempDir);
            String ext;

        <title>Properties</title>
        <table>
            <thead>
                <tr>
                    <td>Name</td>
                </tr>
            </thead>
            <tr>
                <td>inputFile</td>
            </tr>
            <tr>
                <td>outputFile</td>
            </tr>
        </table>
    </section>
    <section>
        <title>Methods</title>
        <table>

 */
public abstract class PersistableConfigurationObjectGenerator<T extends PersistableConfigurationObject> implements Generator<T>, Factory<T> {
    @Override
    public T read(File inputFile) {
        T obj = create();
        obj.load(inputFile);
        return obj;
    }

    @Override
    public T defaultInstance() {
        T obj = create();
        obj.loadDefaults();
        return obj;
    }