Number getThing()
}

class BeanWithServices {
    @Inject
    Number getThing() {
        throw new UnsupportedOperationException()
    }
}

class BeanWithMutableServices extends BeanWithServices {
    void setThing(Number number) {
        throw new UnsupportedOperationException()
    }
}

class BeanWithServicesAndServiceRegistry extends BeanWithServices {
    ServiceRegistry getServices() {

    public CustomModel execute(BuildController controller) {
        CustomModel model1 = controller.getModel(CustomModel.class);
        CustomModel model2 = controller.getModel(CustomModel.class);
        assert model1.getThing() == model2.getThing();
        return model1;
    }

        CustomModel rootProjectModel = controller.getModel(controller.getBuildModel().getRootProject(), CustomModel.class);
        for (CustomModel customModel : result.values()) {
            assert customModel.getThing() == rootProjectModel.getThing();
        }

        return result;
    }

 */

package org.gradle.integtests.tooling.r16;

import java.util.Map;
import java.util.Set;

public interface CustomModel {
    String getValue();

    Thing getThing();

    Set<Thing> getThings();

    Map<String, Thing> getThingsByName();

    Thing findThing(String name);

    interface Thing {
    }

package org.test

class Person(name: String) {
    def getName(): String = name
}
"""
        file('src/main/scala/org/test/Other.scala') << """
package org.test

class Other(thing: String) {
    def getThing(): String = thing
}
"""
        when:
        succeeds 'compileScala'

        then:
        file('build/classes/scala/main/org/test/Person.class').exists()

        buildFile << '''
            @Managed
            interface SomeThings {
                Thing getThingA()
                Thing getThingB()
                Thing getThingC()
            }

            @Managed
            interface Thing {
                String getName()
                void setName(String name)
            }

allprojects {
    apply plugin: CustomPlugin
}

class CustomModel implements Serializable {
    static final INSTANCE = new CustomThing()
    String getValue() { 'greetings' }
    CustomThing getThing() { return INSTANCE }
    Set<CustomThing> getThings() { return [INSTANCE] }
    Map<String, CustomThing> getThingsByName() { return [child: INSTANCE] }
    CustomThing findThing(String name) { return INSTANCE }
}

        abstract String getThing();
    }

    public static abstract class AbstractSetterBean {
        String getThing() {
            return "";
        }

        abstract void setThing(String value);
    }

    public static abstract class AbstractSetMethodBean {
        String getThing() {
            return "";
        }

    @Managed
    interface SpecialThing extends Thing {}

    @Managed
    interface SimpleModel {
        Thing getThing()
    }

    @Managed
    interface SpecialModel extends SimpleModel {
        SpecialThing getThing()

        void setThing(SpecialThing thing)
    }

    def "a subclass may specialize a property type"() {
        when:
        def schema = extract(SpecialModel)

                "class SomeThing {}",
                "@${Managed.name} interface SomeThing { SomeThing getThing() }",
                "@${Managed.name} interface SomeThing { ${ModelSet.name}<SomeThing> getThings() }",
                "@${Managed.name} interface SomeThing { @${Managed.name} static interface Child {}; ${ModelSet.name}<Child> getThings() }",
        ]
    }

    def "does not hold strong reference to a managed #type type"() {