#include "tensorflow/core/platform/status.h"

namespace tensorflow {

// Compiles a `function` to PjRtLoadedExecutable `executable` with `ctx`.
// The compilation result is output in `compilation_result`. The PJRT client
// used for compilation is output in `client`. The PJRT executable is output in
// `executable`.
Status CompileToPjRtLoadedExecutable(
    const OpKernelContext& ctx, const XlaPlatformInfo& platform_info,

class DefaultNativeExecutableSpecTest extends Specification {
    def executable = BaseComponentFixtures.create(NativeExecutableSpec, DefaultNativeExecutableSpec, new DefaultComponentSpecIdentifier("project-path", "someExe"))

    def "has useful string representation"() {
        expect:
        executable.toString() == "native executable 'someExe'"
        executable.displayName == "native executable 'someExe'"
    }

	"fmt"
	"os"
)

func main() {
	before, err := os.Executable()
	if err != nil {
		fmt.Fprintf(os.Stderr, "failed to read executable name before deletion: %v\n", err)
		os.Exit(1)
	}

	err = os.Remove(before)
	if err != nil {
		fmt.Fprintf(os.Stderr, "failed to remove executable: %v\n", err)
		os.Exit(1)
	}

	after, err := os.Executable()
	if err != nil {

        where:
        when                                  | tool    | javaHome  | executable | errorFor
        "java home disagrees with executable" | null    | "other"   | "current"  | "executable"
        "tool disagrees with executable"      | "other" | null      | "current"  | "executable"
        "tool disagrees with java home"       | "other" | "current" | null       | "javaHome"

    private final String title;
    private final Describable executable;

    public PropertyChanges(
        ImmutableSortedSet<String> previous,
        ImmutableSortedSet<String> current,
        String title,
        Describable executable
    ) {
        this.previous = previous;
        this.current = current;
        this.title = title;
        this.executable = executable;
    }

    @Override

        if (OperatingSystem.current().isWindows()) {
            def theArgs = ['/d', '/c', executable.replace('/', File.separator)] + getArgs()
            setArgs(theArgs) //split purposefully to avoid weird windows CI issue
            executable = 'cmd.exe'
        } else {
            executable = "${workingDir}/${executable}"
        }
        builder.environment("JAVA_HOME", System.getProperty("java.home"))

    snapshot_ptrs.emplace(p.first,
                          p.second.has_value() ? &p.second.value() : nullptr);
  }

  const xla::HloInputOutputAliasConfig& input_output_alias =
      executable->executable()->module().input_output_alias_config();
  absl::StatusOr<std::vector<xla::ExecutionInput>> execution_inputs =
      launch_context.PopulateInputs(ctx, result, snapshot_ptrs,

            assert platformToolChain.assembler.executable == 'gcc'
            assert platformToolChain.cCompiler.executable == 'gcc'
            assert platformToolChain.cppCompiler.executable == 'g++'
            assert platformToolChain.objcCompiler.executable == 'gcc'
            assert platformToolChain.objcppCompiler.executable == 'g++'
            assert platformToolChain.linker.executable == 'g++'

        tool chain: Tool chain 'clang' (Clang)
        static library file: build/libs/hello/static/libhello.a

Native executable 'main'
------------------------

Source sets
    C++ source 'main:cpp'
        srcDir: src/main/cpp

Binaries
    Executable 'main:executable'
        build using task: :mainExecutable
        install using task: :installMainExecutable
        build type: build type 'debug'

        public File executable;

        @Override
        public CompilerExecSpec environment(String key, String value) {
            environments.put(key, value);
            return this;
        }

        @Override
        public CompilerExecSpec executable(File executable) {
            this.executable = executable;
            return this;
        }