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

			return
		}
		spec, err := os.ReadFile(f.Path)
		if err != nil {
			f.err = err
			return
		}
		f.document, f.err = openapi_v2.ParseDocument(spec)
	})
	return f.document, f.err
}

func getSchema(f *Fake, model string) (openapi.Schema, error) {
	s, err := f.OpenAPISchema()
	if err != nil {
		return nil, err
	}
	m, err := openapi.NewOpenAPIData(s)
	if err != nil {
		return nil, err
	}

        modelRegistry.registerInstance("nodeInitializerRegistry", ProjectRegistrySpec.NODE_INITIALIZER_REGISTRY)

        def publicTypeSchema = (StructSchema<T>) SCHEMA_STORE.getSchema(publicType)
        def internalViewSchema = (StructSchema<? extends T>) SCHEMA_STORE.getSchema(internalView)
        def bindings = STRUCT_BINDINGS_STORE.getBindings(ModelType.of(publicType), [ModelType.of(internalView)], ModelType.of(implType))

    }

    @Override
    public Describable asDescribable() {
        return Describables.of(componentIdentifier);
    }

    @Override
    public AttributesSchemaInternal getSchema() {
        return schema;
    }

    @Override
    public ImmutableSet<ResolvedVariant> getVariants() {
        return variants;
    }

 * Used to select the artifacts given a particular variant selected during graph resolution.
 */
public interface ResolvedVariantSet {
    Describable asDescribable();

    AttributesSchemaInternal getSchema();

    /**
     * The variants available for artifact selection when variant reselection is not enabled.
     */
    Set<ResolvedVariant> getVariants();

    /**

    def setup() {
        internalType = holderType()
        internalTypeSchema = schemaStore.getSchema(internalType)
        assert internalTypeSchema instanceof StructSchema
        collectionProperty = internalTypeSchema.getProperty('items')
        collectionType = collectionProperty.type as ModelType<C>
        def collectionSchema = schemaStore.getSchema(collectionType)
        assert collectionSchema instanceof ManagedImplSchema

    }

    public String getName() {
        return name;
    }

    public ModelType<T> getType() {
        return type;
    }

    public ModelSchema<T> getSchema() {
        return schema;
    }

    public void setSchema(ModelSchema<T> schema) {
        this.schema = schema;
    }

    public boolean isWritable() {
        return hasSetter(accessors.keySet());
    }

        }
    }

    private <T> NodeInitializer extractNodeInitializer(NodeInitializerContext<T> context) {
        ModelSchema<T> schema = schemaStore.getSchema(context.getModelType());
        for (NodeInitializerExtractionStrategy extractor : allStrategies) {
            NodeInitializer nodeInitializer = extractor.extractNodeInitializer(schema, context);

    protected void renderOutputs(T binary, TextReportBuilder builder) {
    }

    protected void renderVariants(T binary, TextReportBuilder builder) {
        ModelSchema<?> schema = schemaStore.getSchema(((BinarySpecInternal)binary).getPublicType());
        if (!(schema instanceof StructSchema)) {
            return;
        }
        Map<String, Object> variants = new TreeMap<>();

        }
    }

    private <T> ModelSchema<T> getModelSchema(ModelType<T> managedType, MethodRuleDefinition<?, ?> ruleDefinition) {
        try {
            return schemaStore.getSchema(managedType);
        } catch (InvalidManagedModelElementTypeException e) {
            throw new InvalidModelRuleDeclarationException(ruleDefinition.getDescriptor(), e);
        }
    }