privateHeaders.from = ['include']
                binaries.configureEach {
                    compileTask.get().includes.from("other")
                    compileTask.get().compilerArgs.add("--compile=\$name")
                    compileTask.get().macros = [VARIANT: name]
                    linkTask.get().linkerArgs.add("--link=\$name")
                }
            }
        """

            #include MACRO
"""

        and:
        outputs.snapshot { run "mainExecutable" }

        when:
        run "mainExecutable"

        then:
        executed compileTask
        skipped compileTask
    }

    @ToBeFixedForConfigurationCache
    def "recompiles when included header has the same name as a directory and the directory becomes a file"() {
        given:
        buildFile << """

        debugX86Binary.compilationDetails.compileWorkingDir == projectDir.file("build/obj/main/debug/x86")
        debugX86Binary.compilationDetails.compileTask.path == ":compileDebugX86Cpp"
        debugX86Binary.compilationDetails.compileTask.name == "compileDebugX86Cpp"
        debugX86Binary.linkageDetails.outputLocation == toolchain.executable(file("build/exe/main/debug/x86/app")).file

        // TODO: `classes` should be a little more tied to the classesDirs for a SourceSet so every plugin
        // doesn't need to do this.
        project.getTasks().named(sourceSet.getClassesTaskName(), task -> task.dependsOn(compileTask));

        return compileTask;
    }

        buildFile << """
            apply plugin: 'cpp-application'

            application {
                binaries.configureEach { binary ->
                    binary.compileTask.get().macros["TEST"] = null
                    binary.compileTask.get().macros["foo"] = "bar"
                }
            }
        """

        and:
        run "visualStudio"

        then:

    }

    /**
     * Configures {@code compileTask} to compile against {@code sourceSet}'s compile classpath
     * in addition to the outputs of the java compilation, as specified by {@link SourceSet#getJava()}
     *
     * @param compileTask The task to configure.
     * @param sourceSet The source set whose output contains the java classes to compile against.

                                    task.dependsOn compileTask
                                    task.dependsOn mergeResourcesTask
                                    task.archiveBaseName = "${p.name}-${f}${bt}"
                                    task.archiveExtension = 'aar'
                                    task.from compileTask.destinationDirectory

            TaskProvider<JavaCompile> compileTask = createCompileJavaTask(sourceSet, sourceSet.getJava(), project);
            createClassesTask(sourceSet, project);

            configureLibraryElements(compileTask, sourceSet, configurations, objectFactory);
            configureTargetPlatform(compileTask, sourceSet, configurations);
        });
    }

        });
        JvmPluginsHelper.configureOutputDirectoryForSourceSet(sourceSet, scalaSource, project, compileTask, compileTask.map(AbstractScalaCompile::getOptions));

        project.getTasks().named(sourceSet.getClassesTaskName(), task -> task.dependsOn(compileTask));
    }

        and:
        buildFile << """
            apply plugin: 'swift-application'

            application.binaries.configureEach {
                compileTask.get().objectFileDir = layout.buildDirectory.dir("object-files")
                compileTask.get().moduleFile = layout.buildDirectory.file("some-app.swiftmodule")
                linkTask.get().linkedFile = layout.buildDirectory.file("exe/some-app.exe")