store1 := memory.Make(collection.SchemasFor(schemaFor("SomeConfig", "broken message name")))

	stores := []model.ConfigStore{store1}

	store, err := makeStore(stores, nil)
	g.Expect(err).To(MatchError(ContainSubstring("not found: broken message name")))
	g.Expect(store).To(BeNil())
}

func TestAggregateStoreGet(t *testing.T) {
	g := NewWithT(t)

	store1 := memory.Make(collection.SchemasFor(collections.GatewayClass))

    private
    val schema = Cached.of { schemaOf(project) }

    @Suppress("unused")
    @TaskAction
    internal
    fun printExtensions() {
        printAccessorsFor(schema.get()!!)
    }

    private
    fun schemaOf(project: Project) =
        projectSchemaProvider.schemaFor(project)
}


internal
fun printAccessorsFor(schema: TypedProjectSchema) {

import org.gradle.internal.service.scopes.ServiceScope
import org.gradle.kotlin.dsl.*
import java.io.Serializable


@ServiceScope(Scope.UserHome::class)
interface ProjectSchemaProvider {

    fun schemaFor(scriptTarget: Any): TypedProjectSchema?
}


data class SchemaType(val value: TypeOf<*>) {

    companion object {
        inline fun <reified T> of() = SchemaType(typeOf<T>())
    }

			},
		},
		"subsets": []any{
			map[string]any{
				"name": "foo",
				"labels": map[string]any{
					"test": "label",
				},
			},
		},
	}

	badSchema := schemaFor("bad", "bad-name")
	if _, err := crd.FromYAML(badSchema, wantYAML); err == nil {
		t.Errorf("FromYAML should have failed using Schema with bad MessageName")
	}

	gotJSON, err := protomarshal.ToJSON(msg)

	rootSchema, ok := schemaOf(rootRef)
	visitedRefs.Insert(rootRef)
	if !ok {
		return nil, fmt.Errorf("internal error: cannot resolve Ref for root schema %q: %w", rootRef, ErrSchemaNotFound)
	}
	return populateRefs(schemaOf, visitedRefs, rootSchema)
}

func populateRefs(schemaOf func(ref string) (*spec.Schema, bool), visited sets.Set[string], schema *spec.Schema) (*spec.Schema, error) {
	result := *schema
	changed := false

func TestSchemas_Remove(t *testing.T) {
	g := NewWithT(t)

	schemas := collection.SchemasFor(emptyResource, structResource)
	g.Expect(schemas.Remove(structResource)).To(Equal(collection.SchemasFor(emptyResource)))
	g.Expect(schemas.Remove(emptyResource, structResource)).To(Equal(collection.SchemasFor()))
	g.Expect(schemas).To(Equal(collection.SchemasFor(emptyResource, structResource)))
}

func TestSchemas_Add(t *testing.T) {

	ts := &testState{
		ConfigFiles: map[string][]byte{"gateway.yml": []byte(statusRegressionYAML)},
	}

	ts.testSetup(t)

	store := memory.Make(collection.SchemasFor(collections.Gateway))
	fileWatcher := NewFileSnapshot(ts.rootPath, collection.SchemasFor(), "foo")

	mon := NewMonitor("", store, fileWatcher.ReadConfigFiles, "")
	stop := make(chan struct{})
	defer func() { close(stop) }()
	mon.Start(stop)

	g := NewWithT(t)

	ts := &testState{
		ConfigFiles: map[string][]byte{"gateway.yml": []byte(gatewayYAML)},
	}

	ts.testSetup(t)

	fileWatcher := NewFileSnapshot(ts.rootPath, collection.SchemasFor(), "foo")
	configs, err := fileWatcher.ReadConfigFiles()
	g.Expect(err).NotTo(HaveOccurred())
	g.Expect(configs).To(HaveLen(1))
	g.Expect(configs[0].Domain).To(Equal("foo"))

 *   schema
 * }
 *
 * task schemaJar(type: Jar) {
 *   //some imaginary task that creates a jar artifact with some schema
 * }
 *
 * //associating the task that produces the artifact with the configuration
 * artifacts {
 *   //configuration name and the task:
 *   schema schemaJar
 * }
 * </pre>
 */
@ServiceScope(Scope.Project.class)

// Schemas contains metadata about configuration resources.
type Schemas struct {
	byCollection map[config.GroupVersionKind]resource.Schema
	byAddOrder   []resource.Schema
}

// SchemasFor is a shortcut for creating Schemas. It uses MustAdd for each element.
func SchemasFor(schemas ...resource.Schema) Schemas {
	b := NewSchemasBuilder()
	for _, s := range schemas {
		b.MustAdd(s)
	}
	return b.Build()
}