kate: "DefaultPolymorphicDomainObjectContainerTest.Person",
            bob: "DefaultPolymorphicDomainObjectContainerTest.Person",
            mary: "DefaultPolymorphicDomainObjectContainerTest.Person", // TODO should be AgeAwarePerson
            john: "DefaultPolymorphicDomainObjectContainerTest.Person",

                @Model
                void person(Person person) {
                    person.name += " init"
                }

                @Defaults
                void beforePerson(Person person, Names names) {
                    person.name = names.name
                }

                @Finalize
                void afterPerson(Person person) {
                    person.name += " after"
                }

        output.contains "display-name: ModelSet<Person> 'people'"
        output.contains "to-string: ModelSet<Person> 'people'"
    }

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

            class Rules extends RuleSource {
              @Model
              void people(ModelSet<Person> people) {
              }

  MyPlugin#checkName(Person, Person)
    subject:
      - person.parent.parent Person (parameter 1) [*]
    inputs:
      - person.parent.parent.parent.parent Person (parameter 2) [*]

  MyPlugin#name(Person, Person)
    inputs:
      - person.parent.parent Person (parameter 1) [*]
      - person.parent.parent.parent.parent Person (parameter 2) [*]

    }

    def "cannot mutate when used as an input"() {
        when:
        buildScript '''
            @Managed
            interface Person extends Named {
              String getValue()
              void setValue(String string)
            }

            class RulePlugin extends RuleSource {
                @Model

            @Managed
            interface Person {
                Person getFather()
                void setFather(Person person)
            }

            class Rules extends RuleSource {
                @Model
                void father(Person father) {}

                @Model
                void person(Person child, @Path("father") Person father) {
                    child.father = father

            }
        """
        file("src/main/${languageName}/Person.${languageName}") << """
            public record Person(String name, int age) {}
        """

        outputs.snapshot { run language.compileTaskName }

        when:
        file("src/main/${languageName}/Person.${languageName}").text = """
            public record Person(String firstName, String lastName, int age) {}
        """

		if info.Person == nil {
			t.Fatalf("Failed, expected not nil, got person nil")
		}
		if info.Address == nil {
			t.Fatalf("Failed, expected not nil, got address nil")
		}
		if info.Person.ID == person1.ID {
			personMatched = true
			if info.Person.Name != person1.Name {
				t.Errorf("Failed, expected %v, got %v", person1.Name, info.Person.Name)
			}
		}

        when:
        succeeds("compileJava")

        then:
        output.contains(new File("src/main/java/compile/test/Person.java").toString())
        output.contains(new File("src/main/java/compile/test/Person2.java").toString())
        output.contains(logStatement())
        javaClassFile("compile/test/Person.class").exists()
        javaClassFile("compile/test/Person2.class").exists()
    }

The convention plugin is applied to the `api`, `shared`, and `person-service` subprojects:

====
include::sample[dir="snippets/multiproject/dependencies-java/kotlin",files="api/build.gradle.kts[];shared/build.gradle.kts[];services/person-service/build.gradle.kts[]"]
include::sample[dir="snippets/multiproject/dependencies-java/groovy",files="api/build.gradle[];shared/build.gradle[];services/person-service/build.gradle[]"]
====