t.Fatal(err)
		}
		if err := w.Sync(); err != nil {
			w.Close()
			t.Fatal(err)
		}
		if err = w.Close(); err != nil {
			t.Fatal(err)
		}
	}
	// Then run each executable and remove its directory.
	// Run each executable in a separate goroutine to add some load
	// and increase the chance of triggering the bug.
	var wg sync.WaitGroup
	wg.Add(n)
	for i := 0; i < n; i++ {
		go func(i int) {
			defer wg.Done()

        executable("build/exe/main/debug/app").assertExists()
        executable("build/exe/main/debug/app").assertHasDebugSymbolsFor(app.sourceFileNamesWithoutHeaders)
        installation("build/install/main/debug").exec().out == app.withFeatureDisabled().expectedOutput
    }

    @ToBeFixedForConfigurationCache
    def "can use executable file as task dependency"() {

        given:
        def target = Mock(ProcessForkOptions)

        when:
        options.executable('executable')
        options.environment('key', 12)
        options.copyTo(target)

        then:
        1 * target.setWorkingDir(baseDir)
        1 * target.setExecutable('executable')
        1 * target.setEnvironment({ !it.empty })
    }

if errorlevel 1 goto x86
set EXECUTABLE=%FESS_HOME%\bin\fess-service-x64.exe
set SERVICE_ID=fess-service-x64
set ARCH=64-bit
goto checkExe

:x86
set EXECUTABLE=%FESS_HOME%\bin\fess-service-x86.exe
set SERVICE_ID=fess-service-x86
set ARCH=32-bit

:checkExe
if EXIST "%EXECUTABLE%" goto okExe
echo fess-service-(x86|x64).exe was not found...

:okExe

        when:
        succeeds "mainExecutable"

        then:
        executable("build/exe/main/main").exec().out == app.englishOutput
    }

    @ToBeFixedForConfigurationCache
    def "can use map notation to reference library in different project"() {
        given:
        def app = new CppHelloWorldApp()
        app.executable.writeSources(file("exe/src/main"))
        app.library.writeSources(file("lib/src/hello"))

        return new GnupgSignatory(project, name, readSettings(project, propertyPrefix));
    }

    private GnupgSettings readSettings(Project project, String propertyPrefix) {
        Object executable = project.findProperty(buildQualifiedProperty(propertyPrefix, "executable"));
        Object useLegacyGpg = project.findProperty(buildQualifiedProperty(propertyPrefix, "useLegacyGpg"));

        executedAndNotSkipped(":mainExecutable")
        executable("build/exe/main/main").exec().out == helloWorldApp.frenchOutput
    }

    @Requires(UnitTestPreconditions.CanInstallExecutable)
    @ToBeFixedForConfigurationCache
    def "executable with build type depends on library with matching build type"() {
        when:
        helloWorldApp.executable.writeSources(file("src/main"))

    }

    @Requires(IntegTestPreconditions.HasMsBuild)
    @ToBeFixedForConfigurationCache
    def "can build executable from visual studio"() {
        useMsbuildTool()
        def debugBinary = executable("build/exe/main/win32/debug/main")

        given:
        app.writeSources(file("src/main"))
        buildFile << """
            model {

                    }
                }
            }
        """
    }

    @ToBeFixedForConfigurationCache
    def "create visual studio solution for executable that depends on a library in another project"() {
        when:
        app.executable.writeSources(file("exe/src/main"))
        app.library.writeSources(file("lib/src/hello"))

        createDirs("exe", "lib")
        settingsFile << """

    @Override
    public void setExecutable(String executable) {
        javaExecSpec.setExecutable(executable);
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public void setExecutable(Object executable) {
        javaExecSpec.setExecutable(executable);
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public JavaExec executable(Object executable) {