public void execute(S binary) {
                final NativeTestSuiteBinarySpecInternal testBinary = (NativeTestSuiteBinarySpecInternal) binary;
                testBinary.setTestedBinary((NativeBinarySpecInternal) testedBinary);
                testBinary.setNamingScheme(namingScheme);
                testBinary.setResolver(resolver);
                testBinary.setToolChain(testedBinary.getToolChain());

 */
public class DefaultSwiftXCTestSuite extends DefaultSwiftComponent<SwiftXCTestBinary> implements SwiftXCTestSuite {
    private final ObjectFactory objectFactory;
    private final Property<SwiftXCTestBinary> testBinary;
    private final Property<SwiftComponent> testedComponent;
    private final DefaultComponentDependencies dependencies;

    @Inject
    public DefaultSwiftXCTestSuite(String name, ObjectFactory objectFactory) {

        CppTestExecutable testBinary = objectFactory.newInstance(DefaultCppTestExecutable.class, executableNames, getBaseName(), getCppSource(), getPrivateHeaderDirs(), getImplementationDependencies(), getTestedComponent(), targetPlatform, toolChain, platformToolProvider, identity);
        getBinaries().add(testBinary);
        return testBinary;
    }

    @Override
    public DisplayName getDisplayName() {

        given:
        def binary = new TestBinary("binary", project.objects, implementation)

        expect:
        binary.implementationDependencies == project.configurations.binaryImplementation
        binary.implementationDependencies.extendsFrom == [implementation] as Set
    }

    def "can add implementation dependency"() {
        given:
        def binary = new TestBinary("binary", project.objects, implementation)

        project.testComponent.binaries.size() == 1
        def testBinary = project.testComponent.binaries[0]
        testBinary instanceof CppExecutable
        testBinary.name == 'testExecutable'
        testBinary.variantName == 'debug'
        testBinary.baseName == 'coreTest'
        testBinary.compilationDetails.sources.sourceFile as Set == [src1, src2] as Set
        testBinary.compilationDetails.headerDirs == [headerDir] as Set

    }
    def buildType1 = Stub(BuildType) {
        getName() >> "BuildType1"
    }
    def resolver = Mock(NativeDependencyResolver)

    def "uses resolver to resolve lib to dependency"() {
        def binary = testBinary(component, flavor1)
        def lib = new Object()
        def dependency = Stub(NativeDependencySet)

        when:
        binary.lib(lib)

        and:

        <title>Properties</title>
        <table>
            <thead>
                <tr>
                    <td>Name</td>
                </tr>
            </thead>
            <tr>
                <td>testBinary</td>
            </tr>
        </table>
    </section>
    <section>
        <title>Methods</title>
        <table>
            <thead>
                <tr>
                    <td>Name</td>

        <title>Properties</title>
        <table>
            <thead>
                <tr>
                    <td>Name</td>
                </tr>
            </thead>
            <tr>
                <td>testBinary</td>
            </tr>
        </table>
    </section>
    <section>
        <title>Methods</title>
        <table>
            <thead>
                <tr>
                    <td>Name</td>

        binaries.size() == 1
        binaries.findAll { it.debuggable && !it.optimized && it instanceof SwiftXCTestBundle }.size() == 1

        and:
        project.xctest.testBinary.get() == binaries.first()
    }

    @Requires(UnitTestPreconditions.NotMacOs)
    def "registers a test executable for the test suite"() {
        when:
        project.pluginManager.apply(XCTestConventionPlugin)

        binaries.size() == 1
        binaries.findAll { it.debuggable && !it.optimized && it instanceof CppTestExecutable }.size() == 1

        and:
        project.unitTest.testBinary.get() == binaries.first()
    }

    def "adds compile, link and install tasks"() {
        given:
        def src = projectDir.file("src/test/cpp/test.cpp").createFile()

        when: