package exec

import (
	"errors"
	"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 chkStat(file string) error {
	d, err := os.Stat(file)
	if err != nil {
		return err
	}
	if d.IsDir() {
		return fs.ErrPermission
	}
	return nil

    CompilerType getCompilerType();

    interface CompilerExecSpec {
        CompilerExecSpec environment(String key, String value);
        CompilerExecSpec executable(File executable);
        CompilerExecSpec args(Iterable<String> args);
    }

        JavaForkOptions forkOptions = forkOptionsFactory.newJavaForkOptions();
        task.copyTo(forkOptions);
        String executable = forkOptions.getExecutable();
        return new DefaultTestTaskForkOptions(
            forkOptions.getWorkingDir(),
            executable,
            detectJavaVersion(executable),
            javaModuleDetector.inferClasspath(testIsModule, task.getClasspath()),

            </tr>
            <tr>
                <td>argumentProviders</td>
            </tr>
            <tr>
                <td>commandLine</td>
            </tr>
            <tr>
                <td>executable</td>
            </tr>
            <tr>
                <td>workingDir</td>
            </tr>
            <tr>
                <td>environment</td>
            </tr>
            <tr>

            </tr>
            <tr>
                <td>classpath</td>
                <td><literal>null</literal></td>
            </tr>
            <tr>
                <td>executable</td>
                <td><filename>java</filename> executable for current JVM</td>
            </tr>
            <tr>
                <td>workingDir</td>
                <td><literal>project.projectDir</literal></td>
            </tr>

    }

    @Override
    TestFile getVariantSourceFile(String module, VariantContext variantContext) {
        def executable = executable("build/exe/main/${variantContext.asPath}${module}")
        return variantContext.buildType.name == 'release' ? executable.strippedRuntimeFile : executable.file
    }

    @Override

//
// This set includes all of the conditions in script.DefaultConds,
// as well as:
//
//   - Conditions of the form "exec:foo" are active when the executable "foo" is
//     found in the test process's PATH, and inactive when the executable is
//     not found.
//
//   - "short" is active when testing.Short() is true.
//
//   - "verbose" is active when testing.Verbose() is true.

// to the function with the same name in the main
// executable. As these two functions may be compiled
// differently as plugin needs to be PIC, this causes
// crash.

package main

import (
	"plugin"

	"testplugin/issue53989/p"
)

func main() {
	p.Square(7) // call the function in main executable

	p, err := plugin.Open("issue53989.so")
	if err != nil {
		panic(err)
	}

            model {
                components {
                    main(NativeExecutableSpec)
                }
            }
         """

        expect:
        succeeds "mainExecutable"
        executable("build/exe/main/main").exec().out == app.expectedOutput(toolChain)
    }

    @ToBeFixedForConfigurationCache
    def "can manually define C source sets"() {
        given:

class CppIncrementalCompileIntegrationTest extends AbstractInstalledToolChainIntegrationSpec implements CppTaskNames {

    @ToBeFixedForConfigurationCache
    def "skips compile and link tasks for executable when source doesn't change"() {
        def app = new CppApp()
        settingsFile << "rootProject.name = 'app'"

        given:
        app.writeToProject(testDirectory)

        and:
        buildFile << """