buildFile << """
            class MyModel {
                List<String> tasks = []
            }

            class MyPlugin extends RuleSource {
                @Model
                MyModel myModel() {
                    new MyModel()
                }

                @Mutate
                void addTasks1(ModelMap<Task> tasks, MyModel myModel) {
                    myModel.tasks.each { n ->

    }

    private void addModelImplementation(String targetBuildName) {
        file("$targetBuildName/src/main/groovy/my/MyModel.groovy") << """
            package my

            class MyModel implements java.io.Serializable {
                private final String message
                MyModel(String message) { this.message = message }
                String getMessage() { message }
                String toString() { message }

}

apply plugin: Rules

model {
    components {
        assert it.toString() == "ComponentSpecContainer 'components'"
        assert it instanceof ComponentSpecContainer
    }
}
"""

        expect:
        succeeds 'tasks'
    }

    def "component sources and binaries containers are visible in model report"() {
        when:
        succeeds "model"

        then:

    SampleBinary 'sampleLib:2ndBinary'
        build using task: :sampleLib2ndBinary
""")
        where:
        ruleInputs << ["SampleLibrary library, CustomModel myModel",  "CustomModel myModel, SampleLibrary library"]
    }

    def "@ComponentBinaries rule operates with fully configured component"() {
        given:
        buildFile << """
@Managed

    model = ModelWithDefault(foo="foo", bar="bar")
    assert jsonable_encoder(model) == {"foo": "foo", "bar": "bar", "bla": "bla"}
    assert jsonable_encoder(model, exclude_unset=True) == {"foo": "foo", "bar": "bar"}
    assert jsonable_encoder(model, exclude_defaults=True) == {"foo": "foo"}
    assert jsonable_encoder(model, exclude_unset=True, exclude_defaults=True) == {
        "foo": "foo"
    }

    private static void assertModelIsPolymorphic(Object model) {
        assert model != null

        assert model instanceof BaseModel

        assert model instanceof ShallowChildModel
        assert ((ShallowChildModel) model).getShallowMessage() == "shallow poly from 'root'"

        assert model instanceof DeepChildModel
        assert ((DeepChildModel) model).getDeepMessage() == "deep poly from 'root'"

package gorm

import "time"

// Model a basic GoLang struct which includes the following fields: ID, CreatedAt, UpdatedAt, DeletedAt
// It may be embedded into your model or you may build your own model without it
//
//	type User struct {
//	  gorm.Model
//	}
type Model struct {
	ID        uint `gorm:"primarykey"`
	CreatedAt time.Time
	UpdatedAt time.Time
	DeletedAt DeletedAt `gorm:"index"`

}

type ruleList struct {
	rules []*rule
}

// Model represents a single rule from an authorization policy. The conditions of the rule are consolidated into
// permission or principal to align with the Envoy RBAC filter API.
type Model struct {
	permissions []ruleList
	principals  []ruleList
}

// New returns a model representing a single authorization policy.

package v3

import (
	"istio.io/istio/pkg/model"
)

const (
	ClusterType                = model.ClusterType
	EndpointType               = model.EndpointType
	ListenerType               = model.ListenerType
	RouteType                  = model.RouteType
	SecretType                 = model.SecretType
	ExtensionConfigurationType = model.ExtensionConfigurationType
	NameTableType              = model.NameTableType

 * limitations under the License.
 */

package org.gradle.tooling.model;

// TODO:ADAM - Deprecate
/**
 * A model that is buildable by the Tooling API. Models contain various information regarding the build.
 * Models are typically tailored to a specific domain, for example build environment or IDE.
 *
 * @since 1.0-milestone-8
 */