1 * worker.execute(_, _) >> { spec, buildOperation ->
            assert spec.implementationClass == TestExecutable.class
            return new DefaultWorkResult(true, null)
        }
    }

    def "executor executes a given runnable in-process"() {
        when:
        workerExecutor.classLoaderIsolation().submit(TestExecutable.class, Actions.doNothing())

        then:
        1 * workerThreadRegistry.workerThread >> true

        then:
        def testExecutable = binaries.testExecutable
        with(project.tasks.linkTestExecutable) {
            it instanceof LinkExecutable
            it == testExecutable.tasks.link
            it.toolChain.get() == testExecutable.toolChain
            it.targetPlatform.get() == testExecutable.targetPlatform
            it.linkerArgs.get() == testExecutable.linker.args
        }

        and:

            }
            Dependency linkDependency = project.getDependencies().create(testableObjects);
            testExecutable.getLinkConfiguration().getDependencies().add(linkDependency);
        });
    }

    private boolean isTestedBinary(DefaultCppTestExecutable testExecutable, ProductionCppComponent mainComponent, CppBinary testedBinary) {

        def platformToolProvider = Stub(PlatformToolProvider)

        expect:
        def exe = testSuite.addExecutable(identity, targetPlatform, toolChain, platformToolProvider)
        exe.name == 'testExecutable'
        exe.targetPlatform == targetPlatform
        exe.toolChain == toolChain
        exe.platformToolProvider == platformToolProvider
    }

    def "can add a test bundle"() {
        expect:

    private final ShellScript testExecutable = ShellScript.builder()
        .printText("Hello from script")
        .writeTo(testDirectory, "test")

    ExternalProcessFixture(TestFile testDirectory) {
        this.testDirectory = testDirectory
    }

    private String getCommandLineAsVarargLiterals() {
        return ShellScript.cmdToVarargLiterals(testExecutable.commandLine)
    }

    interface Snippets {

            testExecutable.getImplementationDependencies().extendsFrom(((DefaultSwiftBinary) testedBinary).getImplementationDependencies());

            // Configure test binary to compile against binary under test
            Dependency compileDependency = project.getDependencies().create(project.files(testedBinary.getModuleFile()));

        when:
        project.pluginManager.apply(XCTestConventionPlugin)
        project.evaluate()

        then:
        project.components.test == project.xctest
        project.xctest.binaries.get().name == ['testExecutable']
        project.components.containsAll(project.xctest.binaries.get())

        and:
        def binaries = project.xctest.binaries.get()
        binaries.size() == 1

package os_test

import (
	"fmt"
	"internal/testenv"
	"os"
	"path/filepath"
	"runtime"
	"testing"
)

const executable_EnvVar = "OSTEST_OUTPUT_EXECPATH"

func TestExecutable(t *testing.T) {
	testenv.MustHaveExec(t)
	t.Parallel()

	ep, err := os.Executable()
	if err != nil {
		t.Fatalf("Executable failed: %v", err)
	}
	// we want fn to be of the form "dir/prog"

                        }
                    }
                }
            }
        }

        then:
        NativeExecutableBinarySpec binary = realizeBinaries().testExecutable
        binary.tasks.withType(compileTaskClass)*.name as Set == ["compileTestExecutableTestAnotherOne", "compileTestExecutableTest${StringUtils.capitalize(pluginName)}"] as Set

        and:

                        }
                    }
                }
            }
        }

        then:
        NativeExecutableBinarySpec binary = realizeBinaries().testExecutable
        binary.tasks.withType(Assemble)*.name == ["assembleTestExecutableTestAnotherOne", "assembleTestExecutableTestAsm"]

        and:
        binary.tasks.withType(Assemble).each { compile ->