})
                }

                @TaskAction
                void zipSources() {
                    ${server.callFromBuild("zipFileSnapshottingFinished")}
                    zipFile.get().asFile.text = "output"
                }
            }

            task srcZip(type: ZipSrc) {
                sources = rootProject.file("lib")
                zipFile = file("build/srcZip.zip")
            }

                sign publishing.publications
            }

            tasks.register("cleanRepo") {
                def m2Repo = layout.buildDirectory.dir("m2Repo").get().asFile
                def ivyRepo = layout.buildDirectory.dir("ivyRepo").get().asFile
                doLast {
                    m2Repo.deleteDir()
                    ivyRepo.deleteDir()
                }
            }

            }

            test {
                dependsOn jar
                systemProperties 'java.system.class.loader':'org.gradle.MySystemClassLoader'
                jvmArgs "-javaagent:\${jar.archiveFile.asFile.get()}"
            }
        """.stripIndent()

        when:
        run 'test'

        then:
        def result = new DefaultTestExecutionResult(testDirectory)

            abstract class Foo extends DefaultTask {
                @OutputDirectory abstract DirectoryProperty getOutDir()
                @TaskAction void foo() {
                    def dir = outDir.get().asFile
                    assert new File(dir, 'baz').createNewFile()
                }
            }
            abstract class Bar extends DefaultTask {
                @InputFile abstract RegularFileProperty getInDir()

                void apply(Project project) {
                    project.apply plugin: 'java'
                    Test test = (Test) project.tasks.getByName("test")
                    if (test.reports.junitXml.outputLocation.asFile.get().exists()) {
                        println 'JUnit XML report exists!'
                    }
                }
            }

            apply plugin: StaticallyCompiledPlugin
        """

        expect:
        def generateManifest = project.tasks['generateSwiftPmManifest']
        generateManifest instanceof GenerateSwiftPackageManagerManifest
        generateManifest.manifestFile.get().asFile == project.file("Package.swift")
    }

    def "attaches a swift pm package model to the generate task"() {
        when:
        project.pluginManager.apply(SwiftPackageManagerExportPlugin)

                        artifact file: ${language.compileTaskName}.destinationDirectory.asFile.get(), builtBy: ${language.compileTaskName}
                        artifact file: emptyDirs.destinationDir, builtBy: emptyDirs
                        artifact file: processResources.destinationDir, builtBy: processResources

    }

    /**
     * The Checkstyle configuration file to use.
     */
    @Internal
    public File getConfigFile() {
        return getConfig() == null ? null : getConfig().asFile();
    }

    /**
     * The Checkstyle configuration file to use.
     */
    public void setConfigFile(File configFile) {
        setConfig(getProject().getResources().getText().fromFile(configFile));
    }

                @Inject abstract ArchiveOperations getArchiveOperations()

                @TaskAction
                void update() {
                    FileTree tree = archiveOperations.${archiveType}Tree(archive.asFile.get())
                    tree.visit(new EditingFileVisitor())
                }

                private final class EditingFileVisitor implements FileVisitor {
                    @Override

                abstract DirectoryProperty getOutputDirectory()

                @TaskAction
                void generate() {
                    def outputFile = outputDirectory.get().file("generated.txt").asFile
                    outputFile.text = "generated file"
                }
            }

            def generateFile = tasks.register('generate', Generate) {