}

    @Override
    List<XCTestCaseElement> getTestCases() {
        return [
            testCase("testOnlyOneEntryWithSpecificFirstAndLastName",
            """// Assume only one entry
                getNames().forEach({ name in
                    XCTAssertEqual(name.firstName, "Bart")
                    XCTAssertEqual(name.lastName, "den Hollander")
                })"""),

        this.dependencies = objectFactory.newInstance(DefaultComponentDependencies.class, getNames().withSuffix("implementation"));
    }

    @Override
    public DisplayName getDisplayName() {
        return Describables.withTypeAndName("XCTest suite", getName());
    }

    }

    @Override
    List<SourceFile> getFiles() {
        return [sourceFile("swift", "swift4-code.swift", '''
            public typealias Name = (firstName: String, lastName: String)

            public func getNames() -> [Name] {
                return [("Bart", "den Hollander")]
            }

            public func getLastNameOfFirstEntry(names: [Name]) -> String {
                var result: String = ""

        this.targetMachines = objectFactory.setProperty(TargetMachine.class);
    }

    @Override
    public String getName() {
        return name;
    }

    @Override
    public Names getNames() {
        return names;
    }

    @Override
    public Property<String> getModule() {
        return module;
    }

    @Override

    }

    private static List<LaunchableGradleProjectTask> collectTasks(DefaultGradleProject owner, TaskContainerInternal tasks) {
        tasks.discoverTasks();
        tasks.realize();

        return tasks.getNames().stream()
            .map(tasks::findByName)
            .filter(Objects::nonNull)
            .map(task -> buildTask(owner, task))
            .collect(toList());
    }

     */
    @Internal
    NamedDomainObjectSet<T> getEnabled();

    @Override
    @Internal
    Namer<T> getNamer();

    @Override
    @Internal
    SortedMap<String, T> getAsMap();

    @Override
    @Internal
    SortedSet<String> getNames();

    @Override
    @Internal
    List<Rule> getRules();

    @Override
    @Internal
    boolean isEmpty();

    /**

        container.add(a)
        when:
        def result = container.named("a")
        then:
        result.present
        result.get() == a
    }

    def "getNames"() {
        expect:
        container.getNames().isEmpty()

        when:
        container.add(new Bean("bean1"))
        container.add(new Bean("bean2"))
        container.add(new Bean("bean3"))
        then:

                        }
                    });

            library.getBinaries().whenElementKnown(SwiftSharedLibrary.class, sharedLibrary -> {
                Names names = ((ComponentWithNames) sharedLibrary).getNames();
                Configuration apiElements = configurations.migratingUnlocked(names.withSuffix("SwiftApiElements"), ConfigurationRolesForMigration.CONSUMABLE_DEPENDENCY_SCOPE_TO_CONSUMABLE);

		}
		return true
	})

	// Check for more than one selector-less telemetry instance, per namespace
	for ns, sList := range nsToTelemetries {
		if len(sList) > 1 {
			sNames := getNames(sList)
			for _, r := range sList {
				c.Report(gvk.Telemetry, msg.NewMultipleTelemetriesWithoutWorkloadSelectors(r, sNames, string(ns)))
			}
		}
	}

    }

    public CppTestExecutable addExecutable(String variantName, NativeVariantIdentity identity, CppPlatform targetPlatform, NativeToolChainInternal toolChain, PlatformToolProvider platformToolProvider) {
        Names executableNames = Names.of(getName() + variantName + "Executable", getName() + variantName);