given:
        buildKotlinFile '''
            tasks.register("report") {
                extra["outputFile"] = file("$buildDir/output.txt")
                outputs.files(extra["outputFile"])
                doLast {
                    val outputFile: File by extra
                    outputFile.writeText("")
                }
            }
        '''

        when:

        propertyValue = 'modified-value'
        def outputFile = tmpDir.file('output.properties')

        when:
        object.store(outputFile)

        then:
        Matchers.containsLine(outputFile.text, 'prop=modified-value')
    }

    def "can add transform Actions"() {
        object.loadDefaults()
        def outputFile = tmpDir.file('output.properties')

        when:

    @InputFiles
    public abstract ListProperty<RegularFile> getArtifactFiles();

    @OutputFile
    public abstract RegularFileProperty getOutputFile();

    @TaskAction
    public void action() throws IOException {
        File outputFile = getOutputFile().getAsFile().get();
        try (PrintWriter writer = new PrintWriter(new FileWriter(outputFile))) {
            List<ComponentArtifactIdentifier> ids = getArtifactIds().get();

        given:
        def testDir = tmpDirProvider.testDirectory
        def outputFile = testDir.file("output/lib")

        final expectedArgs = [
                "-sys1", "-sys2",
                "-shared",
                getSoNameProp("installName"),
                "-o", outputFile.absolutePath,
                testDir.file("one.o").absolutePath,
                testDir.file("two.o").absolutePath,

     *
     * @return The output file.
     */
    @OutputFile
    public File getOutputFile() {
        return outputFile;
    }

    /**
     * Sets the output file to write the final configuration to.
     *
     * @param outputFile The output file.
     */
    public void setOutputFile(File outputFile) {
        this.outputFile = outputFile;
    }

            FileUtil.deleteInBackground(outputFile);
        }
    }

    protected String getOutputContent(final File outputFile, final String outExt) {
        final Extractor extractor = getExtractor(outExt);
        if (extractor != null) {
            final Map<String, String> params = new HashMap<>();
            params.put(ExtractData.RESOURCE_NAME_KEY, outputFile.getName());

        buildFile << """
            class TestTask extends SourceTask {
                @OutputFile
                File outputFile

                @TaskAction
                def list() {
                    source.visit { fte -> println("visit " + fte.relativePath) }
                    outputFile.text = 'executed'
                }

                @InputFiles
                @SkipWhenEmpty

        executedAndNotSkipped(":zip")
        outputFile.exists()
        outputFile.unzipTo(unpackDir)
        unpackDir.file("README").text == "README"
        unpackDir.file("subdir/A").text == "A"

        when:
        subDir.file("B").text = "B"

        then:
        buildTriggeredAndSucceeded()
        executedAndNotSkipped(":zip")
        outputFile.exists()
        outputFile.unzipTo(unpackDir)

                            parameters.getOutputFile().set(outputFile);
                        }
                    });

                }

                @OutputFile
                RegularFileProperty getOutputFile() {
                    return outputFile;
                }
            }
        """

        boolean windowsPathLimitation = OperatingSystem.current().isWindows();

        File outputFile = compilerOutputFileNamingSchemeFactory.create()
                .withObjectFileNameSuffix(fileSuffix)
                .withOutputBaseFolder(objectFileDir)
                .map(sourceFile);
        File outputDirectory = outputFile.getParentFile();
        if (!outputDirectory.exists()) {
            outputDirectory.mkdirs();
        }