commands: [{
    executable: gradle
    args: check
}, {
    executable: gradle
    args: greet -q
    expected-output-file: greet.out
}, {
    executable: gradle
    args: run -q
    expected-output-file: run.out

        private final File executable;

        private DefaultCommandLineJavaSpec(File executable) {
            this.executable = executable;
        }

        @Override
        public File getExecutable() {
            return executable;
        }
    }

        and:
        executable.assertHasChangedSince(snapshot)
    }

    @ToBeFixedForConfigurationCache
    def "relinks binary but does not recompile when linker option changed"() {
        given:
        run "mainExecutable"

        when:
        def executable = executable("build/exe/main/main")
        def snapshot = executable.snapshot()

        and:

        then:
        final debugX86 = executable(variants.dir.file("build/exe/main/x86/debug/main"))
        final releaseX86 = executable(variants.dir.file("build/exe/main/x86/release/main"))
        final debugX64 = executable(variants.dir.file("build/exe/main/x64/debug/main"))
        final releaseX64 = executable(variants.dir.file("build/exe/main/x64/release/main"))

  MockXlaCompilerClient mock_client;
  TF_ASSERT_OK_AND_ASSIGN(auto executable, BuildSampleExecutable());
  TF_EXPECT_OK(persistor.TryToPersistExecutable(
      /*signature_hash=*/123, "signature_string", DefaultXlaOptions(),
      compilation_result_add_, *executable, &mock_client));

  auto key =
      CreateCacheKey(/*signature_hash=*/123, compilation_result_add_,

    };

    private static final OperatingSystem OS = OperatingSystem.current();

    private final String executable;
    private final List<String> arguments;
    private final String extension;

    SymbolExtractorOsConfig(String executable, List<String> arguments, String extension) {
        this.executable = executable;
        this.arguments = arguments;
        this.extension = extension;
    }

// tag::java-executable[]
// tag::java-home[]
def launcher = javaToolchains.launcherFor {
    languageVersion = JavaLanguageVersion.of(11)
}
// end::java-executable[]
// end::java-home[]


// tag::java-executable[]

tasks.named('sampleTask') {
    javaExecutable = launcher.map { it.executablePath }
}
// end::java-executable[]


// tag::java-home[]

        return executable;
    }

    /**
     * Sets the compiler executable to be used.
     * <p>
     * Only takes effect if {@code CompileOptions.fork} is {@code true}. Defaults to {@code null}.
     * <p>
     * Setting the executable disables task output caching.
     */
    public void setExecutable(@Nullable String executable) {
        this.executable = executable;
    }

    /**

        then:
        executable("build/exe/main/x86/main").arch.name == "x86"
        executable("build/exe/main/x86/main").exec().out == "i386 ${os.familyName}" * 2
        binaryInfo(objectFileFor(file("src/main/cpp/main.cpp"), "build/objs/main/x86/mainCpp")).arch.name == "x86"

        executable("build/exe/main/x86_64/main").arch.name == "x86-64"

        cause.message.contains("The configured executable does not exist")
        cause.message.contains(invalidExecutable.absolutePath)
    }

    def 'fails if custom executable is a directory'() {
        def task = project.tasks.create("run", JavaExec)
        def executableDir = temporaryFolder.createDir("javac")

        when:
        task.executable = executableDir.absolutePath
        execute(task)