result.assertTasksNotSkipped(assembleAppTasks)
        executable("build/exe/main/debug/App").exec().out == app.expectedOutput

        when:
        app.applyChangesToProject(testDirectory)
        succeeds "assemble"

        then:
        result.assertTasksExecuted(assembleAppTasks)
        result.assertTasksNotSkipped(assembleAppTasks)
        executable("build/exe/main/debug/App").exec().out == app.expectedAlternateOutput

        then:
        executed(":app:test")

        and:
        executable("${subprojectName()}/build/exe/main/debug/app").exec().out ==  "Hola, Mundo!\n"

        where:
        scriptDsl << ScriptDslFixture.SCRIPT_DSLS
    }

    ExecutableFixture executable(String path) {
        AvailableToolChains.defaultToolChain.executable(targetDir.file(path))
    }

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

//go:build wasm

package os

import (
	"errors"
	"runtime"
)

func executable() (string, error) {
	return "", errors.New("Executable not implemented for " + runtime.GOOS)

		}
		if err := f.Close(); err != nil {
			log.Fatal(err)
		}
		log.Fatalf("saved crash report at %s", f.Name())
	}

	// This is the application process.
	// Fork+exec the same executable in monitor mode.
	exe, err := os.Executable()
	if err != nil {
		log.Fatal(err)
	}
	cmd := exec.Command(exe, "-test.run=ExampleSetCrashOutput_monitor")
	cmd.Env = append(os.Environ(), monitorVar+"=1")
	cmd.Stderr = os.Stderr

    def "produces correct spec type" () {
        CompileOptions options = TestUtil.newInstance(CompileOptions.class, TestUtil.objectFactory())
        options.fork = fork
        options.forkOptions.executable = executable ? Jvm.current().javacExecutable.absolutePath : null
        DefaultGroovyJavaJointCompileSpecFactory factory = new DefaultGroovyJavaJointCompileSpecFactory(options, null)

        when:
        def spec = factory.create()

All C++ testing revolves around a single task type: link:{groovyDslPath}/org.gradle.nativeplatform.test.tasks.RunTestExecutable.html[RunTestExecutable].
This runs a single test executable built with any testing framework and asserts the execution was successful using the exit code of the executable.
The test case results aren’t collected and no reports are generated.

                testBinary.setToolChain(testedBinary.getToolChain());
                NativeExecutableFileSpec executable = testBinary.getExecutable();
                NativeInstallationSpec installation = testBinary.getInstallation();
                executable.setToolChain(testedBinary.getToolChain());
                executable.setFile(executableFileFor(testBinary, buildDir));

        then:
        executed(":app:test")

        and:
        executable("${subprojectName()}/build/exe/main/debug/App").exec().out ==  "Hola, Mundo!\n"

        where:
        scriptDsl << ScriptDslFixture.SCRIPT_DSLS
    }

    ExecutableFixture executable(String path) {
        AvailableToolChains.getToolChain(ToolChainRequirement.SWIFTC).executable(targetDir.file(path))
    }

        """
    }

    def "emits deprecation warning if executable specified as relative path"() {
        given:
        def executable = TextUtil.normaliseFileSeparators(Jvm.current().javaExecutable.toString())

        buildFile << """
            tasks.withType(JavaExec) {
                executable = new File(".").getCanonicalFile().toPath().relativize(new File("${executable}").toPath()).toString()
            }
        """

        cause.message.contains("The configured executable does not exist")
        cause.message.contains(invalidExecutable.absolutePath)
    }

    def "fails if custom executable is a directory"() {
        def testTask = project.tasks.create("test", Test)
        def executableDir = temporaryFolder.createDir("javac")

        when:
        testTask.executable = executableDir.absolutePath
        testTask.javaVersion