FirDeclarationOrigin.Source -> {
        when (source?.kind) {
            KtFakeSourceElementKind.ImplicitConstructor,
            KtFakeSourceElementKind.DataClassGeneratedMembers, /* Valid for copy() / componentX(), should we change it? */
            KtFakeSourceElementKind.EnumGeneratedDeclaration,
            KtFakeSourceElementKind.ItLambdaParameter -> KaSymbolOrigin.SOURCE_MEMBER_GENERATED

            else -> KaSymbolOrigin.SOURCE

        when:
        component1.add("c")
        component1.add("l")
        component2.add("d")
        component2.add("m")

        then:
        filtered.toList() == ["j", "l", "k", "m"]

        when:
        component1.remove("c")
        component1.remove("l")
        component2.remove("d")
        component2.remove("m")

        then:

	// ResourceName returns the name of the resources of the component.
	ResourceName() string
	// Namespace returns the namespace for the component.
	Namespace() string
	// Enabled reports whether the component is enabled.
	Enabled() bool
	// Run starts the component. Must be called before the component is used.
	Run() error
	// RenderManifest returns a string with the rendered manifest for the component.
	RenderManifest() (string, error)
}

        }
        def component2 = Stub(ComponentSpec) {
            getDisplayName() >> "<component 2>"
        }

        when:
        renderer.startProject(project)
        renderer.renderComponents([component1, component2])
        renderer.completeProject(project)
        renderer.complete()

        then:
        output.value.contains("""
{header}<component 1>
""")
        output.value.contains("""

	Close()
	HasSynced() bool
}

type Component[T ComponentConstraint] struct {
	mu          sync.RWMutex
	constructor func(cluster *Cluster) T
	clusters    map[cluster.ID]T
}

func (m *Component[T]) ForCluster(clusterID cluster.ID) *T {
	m.mu.RLock()
	defer m.mu.RUnlock()
	t, f := m.clusters[clusterID]
	if !f {
		return nil
	}
	return &t
}

func (m *Component[T]) All() []T {
	m.mu.RLock()

specific language governing permissions and limitations
under the License.
-->
<component xmlns="http://maven.apache.org/ASSEMBLY-COMPONENT/2.1.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/ASSEMBLY-COMPONENT/2.1.0 http://maven.apache.org/xsd/assembly-component-2.1.0.xsd">
  <dependencySets>
    <dependencySet>
      <useProjectArtifact>false</useProjectArtifact>

    def "resolve fails when target project has multiple component publications with different coordinates"() {
        given:
        def component1 = Stub(SoftwareComponentInternal)
        def component2 = Stub(SoftwareComponentInternal)
        def component3 = Stub(TestComponent)

        when:
        def publication = pub('mock', "pub-group", "pub-name", "pub-version", component1)

namespace mlir::quant::stablehlo {

// Component is a public abstraction for StableHLO Quantizer that represents the
// most basic unit of action applied to the StableHLO graph. Derived classes
// should override the `Run` method to implement the action.
class Component {
 public:
  virtual ~Component() = default;

  // Runs the action to the StableHLO graph, passed by the `module_op`. `config`

package integration

import (
	"io"

	"istio.io/istio/pkg/test/framework/resource"
)

var _ io.Closer = &component{}

type component struct {
	name        string
	id          resource.ID
	handleClose func(*component)
}

func (c *component) ID() resource.ID {
	return c.id
}

func (c *component) Close() error {
	if c.handleClose != nil {
		c.handleClose(c)
	}
	return nil
}

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.gradle.api.component;

/**
 * A software component that can be queried via the Artifact Query API.
 *
 * @since 2.0
 */
public interface Component {