// Create the tasks for each C++ binary that is registered
        project.getComponents().withType(DefaultCppBinary.class, binary -> {
            final Names names = binary.getNames();
            String language = "cpp";

            TaskProvider<CppCompile> compile = tasks.register(names.getCompileTaskName(language), CppCompile.class, task -> {

        }

        return gradleProject;
    }

    private static List<LaunchableGradleTask> buildTasks(IsolatedGradleProjectInternal owner, TaskContainer tasks) {
        return tasks.getNames().stream()
            .map(tasks::findByName)
            .filter(Objects::nonNull)
            .map(task -> buildTask(owner, task))
            .collect(toList());
    }

				m.Line = line
			}

			c.Report(gvk.Telemetry, m)
		}

		return true
	})

	for p, sList := range podsToTelemetries {
		if len(sList) == 1 {
			continue
		}

		sNames := getNames(sList)
		for _, rs := range sList {
			m := msg.NewConflictingTelemetryWorkloadSelectors(rs, sNames, p.Namespace.String(), p.Name.String())

			if line, ok := util.ErrorLine(rs, fmt.Sprintf(util.MetadataName)); ok {

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

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

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

    protected FileCollection createDirView(final ConfigurableFileCollection dirs, final String conventionLocation) {

    }

    def "cannot configure a scalar list property using nested closure"() {
        buildFile << '''
@Managed interface Person {
    List<String> getNames()
}

model {
    barry(Person)
    barry {
        names {
            add 'barry'
            add 'baz'
        }
    }
}
'''

        when:
        fails "model"

        @Override
        public void execute(CompatibilityCheckDetails<Usage> details) {
            if (Usage.SWIFT_API.equals(details.getConsumerValue().getName())
                    && Usage.C_PLUS_PLUS_API.equals(details.getProducerValue().getName())) {
                details.compatible();
            }
        }
    }

    boolean addAll(Collection<? extends T> c) {
        return false
    }

    @Override
    Namer<T> getNamer() {
        return null
    }

    @Override
    SortedMap<String, T> getAsMap() {
        return null
    }

    @Override
    SortedSet<String> getNames() {
        return null
    }

    @Nullable
    @Override
    T findByName(String name) {

    }

    def addsZincConfigurationToTheProject() {
        when:
        def configuration = project.configurations.getByName(ScalaBasePlugin.ZINC_CONFIGURATION_NAME)

        then:
        Configurations.getNames(configuration.extendsFrom).empty
        !configuration.visible
        configuration.transitive
    }

    def preconfiguresZincClasspathForCompileTasksThatUseZinc() {
        when:

        if (binary instanceof SwiftXCTestBundle) {
            TaskContainer tasks = project.getTasks();
            final Names names = binary.getNames();

            // TODO - creating a bundle should be done by some general purpose plugin

            // TODO - make this lazy

        delegate.isEmpty()

    override fun remove(element: T): Boolean =
        delegate.remove(element)

    override fun getAsMap(): SortedMap<String, T> =
        delegate.asMap

    override fun getNames(): SortedSet<String> =
        delegate.names

    override fun getByName(name: String): T =
        delegate.getByName(name)

    override fun getByName(name: String, configureClosure: Closure<Any>): T =