* limitations under the License.
 */

package org.gradle.api.reporting.components.internal;

import org.gradle.api.tasks.diagnostics.internal.text.TextReportBuilder;
import org.gradle.model.ModelElement;
import org.gradle.platform.base.BinarySpec;
import org.gradle.reporting.ReportRenderer;

import java.io.IOException;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Map;

        succeeds "fromPlugin", "fromScript"

        and:
        output.contains("fromPlugin: foo")
        output.contains("fromScript: foo")
    }

    def "can view unmanaged property as ModelElement"() {
        when:
        buildScript '''
            @Managed
            interface Platform {
                @Unmanaged
                OperatingSystem getOperatingSystem()

            true,
            [
                TypeCompatibilityModelProjectionSupport.description(ModelType.of(String)),
                TypeCompatibilityModelProjectionSupport.description(ModelType.of(ModelElement))
            ]
        ).asString()

        cause.message == message

        where:
        order << [ProvidesStringOne, MutatesS1AsInteger].permutations()
    }

 * To add elements to the set, the {@link #create(Action)} method can be used.
 *
 * @param <T> the type of model object
 */
@Incubating
public interface ModelSet<T> extends Set<T>, ModelElement {

    /**
     * Declares a new set element, configured by the given action.
     *
     * @param action the object configuration
     */
    void create(Action<? super T> action);

    /**

                    tasks.create("validate") {
                        assert components*.name == ["sampleLib"]
                        assert components.withType(ModelElement)*.name == ["sampleLib"]
                        assert components.withType(ComponentSpec)*.name == ["sampleLib"]
                        assert components.withType($componentSpecType)*.name == ["sampleLib"]

        succeeds "checkModel"
    }

    def "custom binary type can viewed as ModelElement"() {
        when:
        buildWithCustomBinaryPlugin()

        and:
        buildFile << '''
            class Rules extends RuleSource {
                @Mutate
                void tasks(ModelMap<Task> tasks, @Path("binaries.sampleBinary") ModelElement binary) {
                    tasks.create("checkModel") {

                void types(PrimitiveTypes primitiveTypes) {
                }

                @Mutate
                void addCheckTask(ModelMap<Task> tasks, @Path("types.intProp") ModelElement intProp, @Path("types.longProp") ModelElement longProp) {
                    tasks.create("check") {
                        doLast {
                            println "intProp: $intProp"

        '''

        then:
        succeeds "echo"

        and:
        output.contains("person: Person 'someone'")
        output.contains("name: foo")
    }

    def "can view a managed element as ModelElement"() {
        when:
        buildScript '''
            @Managed
            interface Person {
                String getName()
                void setName(String name)
            }

        and:
        output.contains "name: things"
        output.contains "display-name: ModelMap<Thing> 'things'"
        output.contains "to-string: ModelMap<Thing> 'things'"
    }

    def "can view as ModelElement"() {
        when:
        buildScript '''
            @Managed
            interface Thing {
            }

            class Rules extends RuleSource {
              @Model

    }

    def "can view a functional source set as a ModelElement"() {
        buildScript """
        apply plugin: 'language-base'

        class Rules extends RuleSource {
            @Model
            void fss(FunctionalSourceSet sources) {
            }

            @Mutate void printTask(ModelMap<Task> tasks, @Path("fss") ModelElement sources) {
                tasks.create("printTask") {