public class DefaultLinkageDetails implements Serializable {
    private final LaunchableGradleTask linkTask;
    private final File outputLocation;
    private final List<String> additionalArgs;

    public DefaultLinkageDetails(LaunchableGradleTask linkTask, File outputLocation, List<String> additionalArgs) {
        this.linkTask = linkTask;
        this.outputLocation = outputLocation;
        this.additionalArgs = additionalArgs;
    }

        tasks.install == null
        tasks.run == null
    }

    def "returns link task when defined"() {
        when:
        final linkTask = testUtil.task(LinkExecutable)
        tasks.add(linkTask)

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

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

        linkTask = objectFactory.property(LinkMachOBundle.class);
    }

    @Override
    public Property<LinkMachOBundle> getLinkTask() {
        return linkTask;
    }

        expect:
        tasks.link == null
        tasks.install == null
    }

    def "returns link task when defined"() {
        when:
        final linkTask = testUtil.task(LinkExecutable)
        tasks.add(linkTask)

        then:
        tasks.link == linkTask
    }

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

import javax.inject.Inject;

public class DefaultSwiftXCTestExecutable extends DefaultSwiftXCTestBinary implements SwiftXCTestExecutable, ConfigurableComponentWithExecutable {
    private final Property<LinkExecutable> linkTask;
    private final Property<InstallExecutable> installTask;
    private final Property<Task> executableFileProducer;
    private final ConfigurableFileCollection files;

            }

            [library, xctest]*.binaries*.configureEach {
                if (targetMachine.operatingSystemFamily.macOs) {
                    linkTask.get().linkerArgs.add("-lc++")
                } else if (targetMachine.operatingSystemFamily.linux) {
                    linkTask.get().linkerArgs.add("-lstdc++")
                }
            }

            project(':cppGreeter') {
                apply plugin: 'cpp-library'

                LinkExecutable linkTask = componentWithExecutable.getLinkTask().get();
                LaunchableGradleTask linkTaskModel = buildLaunchableTask(projectIdentifier, componentWithExecutable.getExecutableFileProducer().get());
                DefaultLinkageDetails linkageDetails = new DefaultLinkageDetails(linkTaskModel, componentWithExecutable.getExecutableFile().get().getAsFile(), args(linkTask.getLinkerArgs().get()));

    }

    def "returns link task when defined"() {
        given:
        def binary = sharedLibrary

        when:
        final linkTask = TestUtil.create(tmpDir).task(LinkSharedLibrary)
        binary.tasks.add(linkTask)

        then:
        binary.tasks.link == linkTask
    }

    private def getSharedLibrary() {

            compile.macros == [NDEBUG: null, LEVEL: "1"]
            compile.compilerArgs == ["ARG1", "ARG2"]
        }

        and:
        def linkTask = binary.tasks.link
        linkTask TaskDependencyMatchers.dependsOn("compileTestExecutableTestAnotherOne", "compileTestExecutableTest${StringUtils.capitalize(pluginName)}")
    }


    def touch(String filePath) {

        when:
        project.pluginManager.apply(CppBasePlugin)
        project.components.add(executable)

        then:
        def link = project.tasks[linkTask]
        link instanceof LinkExecutable
        link.linkedFile.get().asFile == projectDir.file("build/exe/$exeDir" + OperatingSystem.current().getExecutableName("test_app"))

        def install = project.tasks[installTask]