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"() {

            apply plugin: 'java'

            task execTask(type: Exec) {
                dependsOn sourceSets.main.runtimeClasspath
                def testFile = file("${'$'}buildDir/${'$'}name")
                executable = Jvm.current().getJavaExecutable()
                args '-cp', sourceSets.main.runtimeClasspath.asPath, 'org.gradle.TestMain', projectDir, testFile
                doLast {
                    assert testFile.exists()

                };
            }
        };
    }

    public static Key<?>[] toDependencies(@Nullable Type container, Executable executable) {
        Key<?>[] keys = toArgDependencies(container, executable);
        if (executable instanceof Constructor || Modifier.isStatic(executable.getModifiers())) {
            return keys;
        } else {
            Key<?>[] nkeys = new Key[keys.length + 1];

            }
        }

        then:
        NativeExecutableSpec executable = single(components.values()) as NativeExecutableSpec
        NativeExecutableBinarySpec executableBinary = single(binaries) as NativeExecutableBinarySpec
        with(executableBinary) {
            name == 'executable'
            component == executable
            toolChain.name == "tc"
            targetPlatform.name == "platform"

        mainSolution.assertReferencesProject(twoProject, projectConfigurations)
    }

    @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/main"))

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

//
// Caches the compiled XlaCompilationResult and Executable using a
// DeviceCompilationCache. Compilation is done only when there's a cache miss.
//
// Uses the DeviceExecutablePersistor class for persistence and tries to load a
// serialized executable from disk upon a request for compilation. If the
// appropriate executable isn't found on disk, compiles the given Tensorflow

  xla::LocalExecutable* xla_executable = nullptr;

  // Persist an executable.
  TF_EXPECT_OK(xla_device_compiler->CompileIfNeeded(
      options, fn, args, XlaCompiler::CompileOptions{},
      DeviceCompileMode::kStrict, profiler_, &compilation_result,
      &xla_executable));

  // Corrupt the file which contains the serialized executable.
  std::vector<string> files;

        }
    }
}
'''

        when:
        run 'installDist'

        def builder = new ScriptExecuter()
        builder.workingDir file('build/install/application/bin')
        builder.executable "application"
        if (OperatingSystem.current().windows) {
            builder.environment('APPLICATION_OPTS', '-DtestValue=value -DtestValue2="some value" -DtestValue3="some value"')
        } else {

DeviceType GetDeviceType(OpKernelContext* ctx);

// Runs `executable` and populates the outputs in `ctx`. `inputs` and
// `variables` are the input arguments to the computation, usually read from the
// OpKernelContext, `ctx`. Requires the device-appropriate `pjrt_client` and the
// `compilation_result` used to build the `executable`.
Status RunPjRtExecutable(
    const std::vector<const Tensor*>& inputs,

		return 0, nil
	}

	switch fh.Type {
	case elf.ET_EXEC:
		if loadSegment == nil {
			// Assume fixed-address executable and so no adjustment.
			return 0, nil
		}
		if stextOffset == nil && start > 0 && start < 0x8000000000000000 {
			// A regular user-mode executable. Compute the base offset using same
			// arithmetics as in ET_DYN case below, see the explanation there.