TestSuiteComponent unitTestSuite = project.getComponents().withType(TestSuiteComponent.class).findByName(TEST_COMPONENT_NAME);
            if (unitTestSuite != null && unitTestSuite.getTestBinary().isPresent()) {
                return unitTestSuite.getTestBinary().get().getRunTask();
            }
            return null;
        }));

        project.getComponents().withType(TestSuiteComponent.class, testSuiteComponent -> {

     * </ul>
     * @return the set of results for all requested components
     */
    Set<ComponentResult> getComponents();

    /**
     * <p>Return a set of {@link ComponentResult} instances representing all successfully resolved components.
     *
     * <p>Calling this method is the same as calling {@link #getComponents()} and filtering the resulting set for elements of type {@link ComponentArtifactsResult}.
     *

            }
        }
    }

    @Nullable
    private JvmSoftwareComponentInternal getSingleJavaComponent() {
        NamedDomainObjectSet<JvmSoftwareComponentInternal> jvmComponents = project.getComponents().withType(JvmSoftwareComponentInternal.class);
        if (jvmComponents.size() > 1) {
            String componentNames = CollectionUtils.join(", ", jvmComponents.getNames());

        final DirectoryProperty buildDirectory = project.getLayout().getBuildDirectory();

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

			}
		}
	}

	if values.GetGateways().GetIstioIngressgateway().GetAutoscaleEnabled().GetValue() {
		validateGateways(spec.GetComponents().GetIngressGateways(), "ingress")
	}

	if values.GetGateways().GetIstioEgressgateway().GetAutoscaleEnabled().GetValue() {
		validateGateways(spec.GetComponents().GetEgressGateways(), "egress")
	}

	return
}

        DefaultCppComponentModel mainComponent = null;
        CppApplication application = project.getComponents().withType(CppApplication.class).findByName("main");
        if (application != null) {

    private final List<String> components;

    public BundleModel(List<String> components, @Nullable String context) {
        super(context);
        this.components = components;
    }

    public List<String> getComponents() {
        return components;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || getClass() != o.getClass()) {

            SwiftVersion swiftLanguageVersion = null;
            for (Project p : project.getAllprojects()) {
                for (CppApplication application : p.getComponents().withType(CppApplication.class)) {
                    DefaultTarget target = new DefaultTarget(application.getBaseName().get(), p.getProjectDir(), application.getCppSource());

    public DefaultArtifactResolutionResult(Set<ComponentResult> componentResults) {
        this.componentResults = componentResults;
    }

    @Override
    public Set<ComponentResult> getComponents() {
        return componentResults;
    }

    @Override
    public Set<ComponentArtifactsResult> getResolvedComponents() {
        Set<ComponentArtifactsResult> resolvedComponentResults = new LinkedHashSet<>();

                if (first instanceof ExcludeAnyOf) {
                    newBuilder.addAll(((ExcludeAnyOf)first).getComponents());
                } else {
                    builder.add(first);
                }
                if (second instanceof ExcludeAnyOf) {
                    newBuilder.addAll(((ExcludeAnyOf)second).getComponents());
                } else {
                    builder.add(second);
                }