package org.gradle.model;

import org.gradle.api.Incubating;
import org.gradle.api.Named;

/**
 * Represents an element in a model. Elements are arranged in a hierarchy.
 */
@Incubating
public interface ModelElement extends Named {
    /**
     * Returns the name of this element. Each element has a name associated with it, that uniquely identifies the element amongst its siblings.

Laura Kassovic <******@****.***> 1701107622 -0800

package org.gradle.platform.base;

import org.gradle.api.Incubating;
import org.gradle.internal.HasInternalProtocol;
import org.gradle.model.ModelElement;

/**
 * A software component that is built by Gradle.
 */
@Incubating
@HasInternalProtocol
public interface ComponentSpec extends ModelElement {
    /**
     * The path to the project containing this component.
     */
    String getProjectPath();

import org.gradle.model.internal.type.ModelType;

public class ModelElementProjection extends TypeCompatibilityModelProjectionSupport<ModelElement> {
    private static final ModelType<ModelElement> MODEL_ELEMENT_MODEL_TYPE = ModelType.of(ModelElement.class);
    private final ModelType<?> publicType;

    public ModelElementProjection(ModelType<?> publicType) {
        super(MODEL_ELEMENT_MODEL_TYPE);

        def model = new Object()
        def targetElement = new Object()
        def modelElement = Stub(Element)
        def modelView = Stub(GradleBuild)

        when:
        def result = controller.getModel(modelElement, GradleBuild, null, null)

        then:
        result == modelView

        and:
        1 * adapter.unpack(modelElement) >> targetElement

        Collection<ComponentSpec> components = new ArrayList<>();
        ComponentSpecContainer componentSpecs = modelElement("components", ComponentSpecContainer.class);
        if (componentSpecs != null) {
            components.addAll(componentSpecs.values());
        }

        ModelMap<ComponentSpec> testSuites = modelElement("testSuites", modelMap(ComponentSpec.class));
        if (testSuites != null) {

 * limitations under the License.
 */

package org.gradle.platform.base;

import org.gradle.api.Incubating;
import org.gradle.model.ModelElement;

/**
 * A component that has one or more mutually exclusive variants.
 */
@Incubating
public interface VariantComponent extends ModelElement {
    /**
     * The variants of this component.
     */
    Iterable<? extends Binary> getVariants();
    @Override

        ModelMap<ComponentSpec> testSuites = modelElement(registry, "testSuites", modelMap(ComponentSpec.class));
        if (testSuites != null) {
            components.addAll(testSuites.values());
        }
        return components;
    }

    @Nullable
    private static <T> T modelElement(ModelRegistry registry, String path, Class<T> clazz) {
        return registry.find(path, clazz);

        where:
        type << [Set, List]
    }

    def "can view #{type.name} as ModelElement"() {
        given:
        buildFile << """
class Rules extends RuleSource {
    @Model
    void strings(${type.name}<String> s) {
    }

    @Mutate
    void tasks(ModelMap<Task> tasks, @Path("strings") ModelElement strings) {
        tasks.create("show") {
            doLast {

    def "can view unmanaged element as ModelElement"() {
        given:
        buildFile << '''
class Thing { }

class Rules extends RuleSource {
    @Model
    Thing thing() {
        return new Thing()
    }

    @Mutate
    void tasks(ModelMap<Task> tasks, @Path("thing") ModelElement thing) {
        tasks.create("show") {
            doLast {