project.getDependencies().getAttributesSchema().attribute(Usage.USAGE_ATTRIBUTE).getCompatibilityRules().add(SwiftCppUsageCompatibilityRule.class);

        project.getComponents().withType(DefaultSwiftBinary.class, binary -> {
            final Names names = binary.getNames();
            TaskProvider<SwiftCompile> compile = tasks.register(names.getCompileTaskName("swift"), SwiftCompile.class, task -> {

        pluginManager.getPluginRealm(session, pluginDescriptor);

        assertEquals(1, pluginDescriptor.getDependencies().size());

        for (ComponentDescriptor<?> descriptor : pluginDescriptor.getComponents()) {
            assertNotNull(descriptor.getRealm());
            assertNotNull(descriptor.getImplementationClass());
        }

        // reload plugin realm from cache

    }

    @Override
    public int hashCode() {
        return hashCode;
    }

    @Override
    public Set<ExcludeSpec> getComponents() {
        return components;
    }

    @Override
    public int size() {
        return size;
    }

    @Override
    public String toString() {

        String bundle = getParameters().getBundleName().get();
        DefaultVersionCatalog config = getParameters().getConfig().get();
        BundleModel bundleModel = config.getBundle(bundle);
        return bundleModel.getComponents().stream()
            .map(config::getDependencyData)
            .collect(Collectors.toList());

    }

    Property<RulesMode> getRulesMode();

    /**
     * Returns the shared component metadata handler
     */
    ComponentMetadataHandler getComponents();

    /**
     * Configures the version catalogs which will be used to generate type safe accessors for dependencies.
     * @param spec the spec to configure the dependencies
     *
     * @since 7.0
     */

        // SoftwareModel
        applyVisualStudioSoftwareModelRules();
    }

    private void applyVisualStudioCurrentModelRules(final VisualStudioExtensionInternal extension) {
        project.getComponents().withType(CppApplication.class).all(cppApplication -> {
            DefaultVisualStudioProject vsProject = extension.getProjectRegistry().createProject(project.getName(), cppApplication.getName());

     *
     * @throws GradleException If the {@code java} component does not exist.
     */
    public static JvmSoftwareComponentInternal getJavaComponent(Project project) {
        SoftwareComponent component = project.getComponents().findByName(JvmConstants.JAVA_MAIN_COMPONENT_NAME);

        if (!(component instanceof JvmSoftwareComponentInternal)) {
            throw new GradleException("The Java plugin must be applied to access the java component.");

        assertMutable();
        componentMetadataRulesActions.add(registration);
    }

    @Override
    public ComponentMetadataHandler getComponents() {
        return registar;
    }

    @Override
    public RepositoryHandler getRepositories() {
        return dependencyResolutionServices.get().getResolveRepositoryHandler();
    }

        realizeModelElement("buildTypes", BuildTypeContainer)
    }

    FlavorContainer getFlavors() {
        realizeModelElement("flavors", FlavorContainer)
    }

    ComponentSpecContainer getComponents() {
        realizeModelElement("components", ComponentSpecContainer)
    }

    def "adds model extensions"() {
        expect:
        toolChains != null
        platforms != null

        }

        @Override
        public ExcludeSpec doIntersect(ExcludeAnyOf left, ExcludeAnyOf right, ExcludeFactory factory) {
            Set<ExcludeSpec> leftComponents = left.getComponents();
            Set<ExcludeSpec> rightComponents = right.getComponents();
            Set<ExcludeSpec> common = Sets.newHashSet(leftComponents);
            common.retainAll(rightComponents);
            if (!common.isEmpty()) {