given:
        def api = toApi 'A': '''
            public class A {
               public void foo() {
                   class Person {}
               }
            }
        '''

        when:
        def outer = api.classes.A
        def inner = api.classes['A$1Person']
        def extractedOuter = api.extractAndLoadApiClassFrom(outer)

        then:
        !api.isApiClassExtractedFrom(inner)

  boolean isEmployed()
// end::property-type-boolean[]

// tag::property-type-managed[]
  void setMother(Person mother)
  Person getMother()
// end::property-type-managed[]

  void setFather(Person father)
  Person getFather()

// tag::property-type-managedset[]
  ModelSet<Person> getChildren()
// end::property-type-managedset[]

// tag::property-type-file[]
  void setHomeDirectory(File homeDir)

                @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"
                }

// tag::sample[]
public class Simpsons {
    private static final Person HOMER = new Person("Homer", "Simpson");
    private static final Person MARGE = new Person("Marjorie", "Simpson");
    private static final Person BART = new Person("Bartholomew", "Simpson");
    private static final Person LISA = new Person("Elisabeth Marie", "Simpson");
    private static final Person MAGGIE = new Person("Margaret Eve", "Simpson");

                String getName()
            }

            @Managed
            abstract class Person implements Named {
                abstract void setName(String name)
            }

            class RulePlugin extends RuleSource {
                @Model
                void createPerson(Person person) {
                    person.name = "foo"
                }

                @Mutate

public class Family {
    private final List<Person> members;

    public Family(Person... members) {
        this.members = Arrays.asList(members);
    }

    public List<Person> getMembers() {
        return members;
    }

    public int size() {
        return members.size();
    }

    public boolean contains(Person person) {
        return members.contains(person);
    }

    @java.lang.Override

        file("src/main/scala/Person.scala") << """class Person(val name: String = "foo", val age: Int = 1)"""
        file("src/main/scala/House.scala") << """class House(val owner: Person = new Person())"""
        file("src/main/scala/Other.scala") << """class Other"""
        file("src/main/scala/Other2.scala") << """class Other2"""

        def person = scalaClassFile("Person.class")
        def house = scalaClassFile("House.class")

          | Creator: 	PersonRules#person(Person)
    + employed
          | Type:   	boolean
          | Value:  	false
          | Creator: 	PersonRules#person(Person)
    + father
          | Type:   	Person
          | Value:  	null
          | Creator: 	PersonRules#person(Person)
    + firstName
          | Type:   	java.lang.String
          | Value:  	John
          | Creator: 	PersonRules#person(Person)
    + homeDirectory

        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) {
              }

package org.gradle.sample

import org.junit.*
import static org.junit.Assert.*

class PersonTest {
    @Test
    def void canCreateAPerson() {
        Person person = new Person()
        person.name = 'Barry'
        assertEquals('Barry', person.name)
    }