linkTask.linkedFile.get().asFile == projectDir.file("build/exe/windows/debug/test_app.exe")

        def installTask = project.tasks['installWindowsDebug']
        installTask instanceof InstallExecutable
        installTask.executableFile.get().asFile == linkTask.linkedFile.get().asFile
        installTask.installDirectory.get().asFile == projectDir.file("build/install/windows/debug")

        and:

            public void execute(InstallExecutable installTask) {
                installTask.setDescription("Installs a development image of " + binary.getDisplayName());
                installTask.setGroup(LifecycleBasePlugin.BUILD_GROUP);
                installTask.getToolChain().set(executable.getToolChain());
                installTask.getTargetPlatform().set(binary.getTargetPlatform());
                installTask.getExecutableFile().set(executable.getFile());

        tasks.run == null
    }

    def "returns install task when defined"() {
        when:
        final installTask = testUtil.task(InstallExecutable)
        tasks.add(installTask)

        then:
        tasks.link == null
        tasks.install == installTask
        tasks.run == null
    }

    def "returns run task when defined"() {
        when:

        when:
        withBuildCache().run compileTask(buildType)

        then:
        executedAndNotSkipped allCompileTasks

        when:
        withBuildCache().run 'clean', installTask(buildType)

        then:
        skipped allCompileTasks
        installation(installDir(buildType)).exec().out == app.expectedOutput

        where:
        buildType << ['Debug', 'Release']
    }

        project.getTasks().register(taskName, Sync.class, installTask -> {
            installTask.setDescription("Installs the project as a distribution as-is.");
            installTask.setGroup(DISTRIBUTION_GROUP);
            installTask.with(distribution.getContents());
            final Provider<String> installDirectoryName = project.provider(() -> {

    private final Property<LinkExecutable> linkTask;
    private final Property<InstallExecutable> installTask;
    private final Property<Task> executableFileProducer;
    private final ConfigurableFileCollection files;
    private final RegularFileProperty debuggerExecutableFile;

    @Inject

            InstallExecutable installTask = (InstallExecutable) tasks.getInstall();
            RunTestExecutable runTask = (RunTestExecutable) tasks.getRun();
            runTask.getInputs().files(installTask.getOutputs().getFiles()).withPropertyName("installTask.outputs").withPathSensitivity(PathSensitivity.RELATIVE);
            runTask.setExecutable(installTask.getRunScriptFile().get().getAsFile().getPath());

    }

    @Override
    public File getOutputFile() {
        if (isExecutable()) {
            InstallExecutable installTask = getInstallTask();
            return new File(installTask.getInstallDirectory().get().getAsFile(), "lib/" + installTask.getExecutableFile().get().getAsFile().getName());
        } else {
            return binary.getPrimaryOutput();
        }
    }

    @Override

        def install = project.tasks[installTask]
        install instanceof InstallExecutable
        install.installDirectory.get().asFile == projectDir.file("build/install/$exeDir")

        where:
        name        | linkTask        | installTask        | exeDir
        "main"      | "link"          | "install"          | "main/"

    }

    private void configureInstallTask(ProviderFactory providers, TaskProvider<Sync> installTask, JavaApplication pluginExtension) {
        installTask.configure(task -> task.doFirst(
            "don't overwrite existing directories",
            new PreventDestinationOverwrite(
                providers.provider(pluginExtension::getApplicationName),