expect:
        def schema = store.getSchema(ModelTypes.set(ModelType.of(String)))
        schema instanceof ScalarCollectionSchema
        schema instanceof ManagedImplSchema
        !(schema instanceof CompositeSchema)
        !(schema instanceof StructSchema)
        schema.elementType == ModelType.of(String)
        schema.elementTypeSchema == store.getSchema(ModelType.of(String))
    }

        schema.getProperty('readOnlyString').schema == store.getSchema(ModelType.of(String))
        schema.getProperty('strings').schema == store.getSchema(ModelTypes.list(ModelType.of(String)))
    }

    def "assembles schema for unmanaged type marked with @UnmanagedStruct"() {
        expect:
        def schema = store.getSchema(ModelType.of(SomeStruct))
        schema instanceof UnmanagedImplStructSchema

        schema.getProperty('readOnlyString').schema == store.getSchema(ModelType.of(String))
        schema.getProperty('strings').type == ModelTypes.list(ModelType.of(String))
        schema.getProperty('strings').schema == store.getSchema(ModelTypes.list(ModelType.of(String)))
    }

    def "assembles schema for @Managed type that references itself"() {
        expect:
        def schema = store.getSchema(ModelType.of(Person))

    abstract static class ManagedThing {}

    def "type doesn't need to implement named"() {
        when:
        schemaStore.getSchema(ModelTypes.modelMap(ManagedThing))

        then:
        noExceptionThrown()
    }

    def "must have type param"() {
        when:
        schemaStore.getSchema(ModelType.of(ModelMap))

        then:
        def e = thrown InvalidManagedModelElementTypeException

        schema.properties*.name == ['readOnlyString', 'strings']
        schema.getProperty('readOnlyString').schema == store.getSchema(ModelType.of(String))
        schema.getProperty('strings').schema == store.getSchema(ModelTypes.list(ModelType.of(String)))
    }

    def "supports a boolean property with an is style getter"() {
        expect:
        store.getSchema(ModelType.of(HasIsTypeGetter))
    }

    abstract class HasStaticProperties {
        static String staticValue
        String value
    }

    def "does not extract static properties"() {
        def schema = store.getSchema(HasStaticProperties)
        expect:
        schema.properties*.name == ["value"]
    }

    }

    @Override
    public <T> ModelSchema<T> getSchema(ModelType<T> type) {
        synchronized (lock) {
            ModelSchema<T> schema = cache.get(type);
            if (schema != null) {
                return schema;
            }
            return schemaExtractor.extract(type, cache);
        }
    }

    @Override
    public <T> ModelSchema<T> getSchema(Class<T> type) {
        return getSchema(ModelType.of(type));

        def type2 = ModelType.of(SimpleManagedType)

        expect:
        store.getSchema(type1).is(store.getSchema(type2))
    }

    def "each thread receives same schema object"() {
        def seen = new CopyOnWriteArraySet()

        when:
        async {
            5.times {
                start {
                    seen << store.getSchema(SimpleManagedType)
                }
            }
        }

import javax.annotation.concurrent.ThreadSafe;

@ThreadSafe
@ServiceScope(Scope.Global.class)
public interface ModelSchemaStore {

    <T> ModelSchema<T> getSchema(ModelType<T> type);

    <T> ModelSchema<T> getSchema(Class<T> type);

    /**
     * Remove any cached information for types that have been GC'd.
     */
    void cleanUp(); // TODO hook this in to the (daemon) build lifecycle

    def "assembles schema for model map subtype"() {
        expect:
        def schema = store.getSchema(ModelType.of(SpecializedMap))
        schema instanceof SpecializedMapSchema
        schema.elementType == ModelType.of(String)
        schema.elementTypeSchema == store.getSchema(ModelType.of(String))
        SpecializedMap.isAssignableFrom schema.implementationType
    }