commands:[{
    executable: gradle
    args: "build -DtestToolchain=knownVendor"
}, {
    executable: gradle
    args: "build -DtestToolchain=matchingVendor"
    expect-failure: true  # The matching vendor uses a dummy vendor string that is never matched
    expected-output-file: matchingVendorWithoutCC.out
    allow-additional-output: true

commands: [{
    executable: gradle
    args: "dependencyInsight --configuration compileClasspath --dependency log4j"
    flags: "--quiet"
    expected-output-file: dependencyReport.out
    expect-failure: false
},{
    executable: gradle
    args: "dependencyInsight --configuration compileClasspath --dependency log4j -Preplace"
    flags: "--quiet"
    expected-output-file: dependencyReportReplaced.out
    expect-failure: false

    public void setExecutable(@Nullable String executable) {
        execSpec.setExecutable(executable);
    }

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

    /**
     * {@inheritDoc}
     */
    @Override
    public T executable(Object executable) {
        execSpec.executable(executable);

        this.file = file;
    }

    /**
     * The Tool Chain that produces the native executable.
     * @since 4.7
     */
    public NativeToolChain getToolChain() {
        return toolChain;
    }

    /**
     * Sets the Tool Chain that produces the native executable.
     * @since 4.7
     */
    public void setToolChain(NativeToolChain toolChain) {
        this.toolChain = toolChain;

    }

    @ToBeFixedForConfigurationCache
    def "can compile but not link when executable depends on api of library required for linking"() {
        given:
        def app = new CppHelloWorldApp()
        app.executable.writeSources(file("src/main"))
        app.library.writeSources(file("src/hello"))

        and:
        buildFile << """
model {

var ErrNotFound = errors.New("executable file not found in $path")

func findExecutable(file string) error {
	d, err := os.Stat(file)
	if err != nil {
		return err
	}
	if m := d.Mode(); !m.IsDir() && m&0111 != 0 {
		return nil
	}
	return fs.ErrPermission
}

// LookPath searches for an executable named file in the

│           └── app  // <2>
└── test
    ├── appTest      // <1>
    └── lib
        └── appTest  // <3>
----
<1> The script for executing the application variant
<2> The main executable binary (debug variant)
<3> The test executable binary

NOTE: When a build has dependencies, the dependent libraries are also copied into the installation folder.
The shell scripts properly configure the library path so the package can be relocated.

        private final File executable;

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

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

      const XlaCompiler::CompilationResult& result) override;

  // Returns a platform-specific serialization of `executable`. The
  // serialization is not guaranteed to be stable over time. `executable` must
  // have been produced by this client.
  absl::StatusOr<std::string> SerializeExecutable(
      const xla::PjRtLoadedExecutable& executable) override;

  // PjRt doesn't support AOT compilation yet. Builds a PjRtLoadedExecutable and

import (
	"errors"
	"internal/syscall/unix"
	"io/fs"
	"os"
	"path/filepath"
	"strings"
	"syscall"
)

// ErrNotFound is the error resulting if a path search failed to find an executable file.
var ErrNotFound = errors.New("executable file not found in $PATH")

func findExecutable(file string) error {
	d, err := os.Stat(file)
	if err != nil {
		return err
	}
	m := d.Mode()
	if m.IsDir() {
		return syscall.EISDIR