// independent executable that happens to have the same name as an
		// executable in ".". If "." is included implicitly, looking up the
		// (unqualified) executable name will return ErrDot; otherwise, the
		// executable in "." should have no effect and the lookup should
		// unambiguously resolve to the directory in PATH.

		dir := t.TempDir()
		executable := "execabs-test"
		if runtime.GOOS == "windows" {

            task runWithJavaExec {
                dependsOn sourceSets.main.runtimeClasspath
                doLast {
                    project.javaexec {
                        if (run.executable) {
                            executable run.executable
                        }
                        classpath = run.classpath
                        mainClass = run.mainClass
                        args run.args
                    }

    }

    def "adds link and install task for executable"() {
        def baseName = project.objects.property(String)
        baseName.set("test_app")
        def executable = Stub(DefaultCppExecutable)
        def executableFile = project.objects.fileProperty()
        executable.name >> name
        executable.names >> Names.of(name)
        executable.baseName >> baseName
        executable.getExecutableFile() >> executableFile

        def javaCompile = project.tasks.create("compileJava", JavaCompile)
        javaCompile.destinationDirectory.set(new File("tmp"))
        def executable = Jvm.current().javacExecutable.absolutePath

        when:
        javaCompile.options.fork = true
        javaCompile.options.forkOptions.executable = executable
        def spec = javaCompile.createSpec()

// executable file
// errWd will be checked later, if we need to use initWd
var initWd, errWd = Getwd()

func executable() (string, error) {
	var exePath string
	if len(Args) == 0 || Args[0] == "" {
		return "", ErrNotExist
	}
	if IsPathSeparator(Args[0][0]) {
		// Args[0] is an absolute path, so it is the executable.
		// Note that we only need to worry about Unix paths here.

        }
    }

    @Override
    ExecutableFixture executable(Object path) {
        ExecutableFixture executable = super.executable(path)
        // Executables synced from a binary repo lose their executable bit
        executable.file.setExecutable(true)
        executable
    }

    Map<String, String> machine(String os, String architecture) {

        then:
        1 * execActionFactory.newExecAction() >> action
        1 * action.executable(Jvm.current().javadocExecutable)
    }

    def testCheckCustomExecutable() {
        String executable = "somepath"
        def action = Mock(ExecAction)

        when:
        javadocExecHandleBuilder.executable = executable
        javadocExecHandleBuilder.execHandle

        then:

        then:
        failureDescriptionStartsWith("Execution failed for task ':javadoc'.")
        failureHasCause("Toolchain from `executable` property does not match toolchain from `javadocTool` property")
    }

    def "fails on toolchain and executable mismatch (without java-base plugin)"() {
        def jdkCurrent = Jvm.current()
        def jdkOther = AvailableJavaHomes.differentVersion

        then:
        failureDescriptionStartsWith("Execution failed for task ':run'.")
        failureHasCause("Toolchain from `executable` property does not match toolchain from `javaLauncher` property")
    }

    def "fails on toolchain and executable mismatch (without application plugin)"() {
        def jdkCurrent = Jvm.current()
        def jdkOther = AvailableJavaHomes.differentVersion

     *
     * @since 5.1
     */
    Provider<? extends Task> getExecutableFileProducer();

    /**
     * Returns the executable file to produce.
     */
    Provider<RegularFile> getExecutableFile();

    /**
     * Returns the link task for the executable.
     */