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:

        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:

        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 ->

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

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

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