}

    ExecutableFixture executable(Object path) {
        return toolChain.executable(file(path))
    }

    LinkerOptionsFixture linkerOptionsFor(String taskName, TestFile projectDir = testDirectory) {
        return toolChain.linkerOptionsFor(projectDir.file("build/tmp/$taskName/options.txt"))
    }

    TestFile objectFile(Object path) {
        return toolChain.objectFile(file(path))
    }

        run taskName

        then:
        executed ":lib", ":child:jar", ":child:lib", ":$taskName"

        where:
        taskName               | _
        "direct"               | _
        "fileCollection"       | _
        "ownDependencies"      | _
        "allDependencies"      | _

                super.connect(snk)
                write(message.bytes)
                close()
            }
        })
    }

    String makeTask(Map<String, String> args, String taskName) {
        return "${taskName}Task"(args)
    }

    @SuppressWarnings('unused')
    // called by string
    def execTask(Map<String, String> args) {
        """
            tasks.register("run", Exec) {

                target(name: 'target2')
                target(name: 'target3')
            }
        }

        when:
        ant.importBuild(buildFile) { taskName ->
            'a-' + taskName
        }

        then:
        def task = project.tasks.'a-target1'
        task instanceof AntTarget
        task.target.name == 'target1'

        def coordinates = [idSegments.dropRight(1).join('.'), idSegments.last(), "1.0"].join(':')

        def message = "from ${idSegments.last()} fetched from ${repository.uri}/"
        def taskName = idSegments.last()
        pluginBuilder.addPluginWithPrintlnTask(taskName, message, pluginId, idSegments.last().capitalize())
        pluginBuilder.publishAs(coordinates, repository, executer)
    }

    private def use(Repository... repositories) {

            }
            """
        )

        val taskName = ":writeInputToFile"

        build(taskName, "-PinputString=string1").assertTasksExecutedAndNotSkipped(taskName)

        build(taskName, "-PinputString=string1").assertTasksSkipped(taskName)

        build(taskName, "-PinputString=string2").assertTasksExecutedAndNotSkipped(taskName)
    }

    @Test

    private publishTestPlugin(String repoType) {
        def pluginBuilder = new PluginBuilder(testDirectory.file("plugin"))

        def message = "from plugin"
        def taskName = "pluginTask"

        pluginBuilder.addPluginWithPrintlnTask(taskName, message, "org.example.plugin")

        if (repoType == IVY) {
            repo = ivyRepo
        } else if (repoType == MAVEN) {
            repo = mavenRepo
        }

        return resolverArtifactCache.file("commons-io/commons-io/")
    }

    private def testBuild(String taskName, String expected, String... args) {
        executer.inDirectory(projectDir).withTasks(taskName).withArguments(args).run()
        assertEquals(expected, projectDir.file(TEST_FILE).text)
        updateCaches()
        classFile.assertIsFile()

import org.gradle.integtests.fixtures.AbstractProjectRelocationIntegrationTest
import org.gradle.test.fixtures.file.TestFile

class JavaGradlePluginRelocationTest extends AbstractProjectRelocationIntegrationTest {
    String taskName = ":test"

    @Override
    protected void setupProjectIn(TestFile projectDir) {
        projectDir.with {
            file("src/main/groovy/CustomTask.groovy") << """
                import org.gradle.api.*

        return lifecycleTask;
    }

    public TaskProvider<? extends Task> getCleanTask() {
        return cleanTask;
    }

    protected String cleanName(String taskName) {
        return String.format("clean%s", StringUtils.capitalize(taskName));
    }

    public void addWorker(Task worker) {
        addWorker(project.getTasks().named(worker.getName()), worker.getName());
    }