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

		}
	}
	return nil, false
}

func schemaFor(kind, proto string) resource.Schema {
	return resource.Builder{
		Kind:   kind,
		Plural: kind + "s",
		Proto:  proto,
	}.BuildNoValidate()
}

func TestConfigDescriptor(t *testing.T) {
	a := schemaFor("a", "proxy.A")
	schemas := collection.SchemasFor(
		a,
		schemaFor("b", "proxy.B"),
		schemaFor("c", "proxy.C"))
	want := []string{"a", "b", "c"}

			},
		},
		"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)

import org.gradle.kotlin.dsl.accessors.TypedProjectSchema
import java.lang.reflect.Modifier
import kotlin.reflect.KVisibility


class DefaultProjectSchemaProvider : ProjectSchemaProvider {

    override fun schemaFor(scriptTarget: Any): TypedProjectSchema? =
        targetTypeOf(scriptTarget)
            ?.let { scriptTargetType ->
                targetSchemaFor(
                    scriptTarget,
                    scriptTargetType

        require(classLoaderScope.isLocked) {
            "project.classLoaderScope must be locked before querying the project schema"
        }
        return projectSchemaProvider.schemaFor(scriptTarget)?.takeIf { it.isNotEmpty() }
    }
}


internal
class GenerateProjectAccessors(
    private val scriptTarget: Any,
    private val scriptTargetSchema: TypedProjectSchema,

                    rootProject.run {
                        applyPlugins(plugins)
                        serviceOf<ProjectSchemaProvider>().schemaFor(this)!!
                    }
                }
            }
        }
    }

    private
    fun projectSchemaBuildStartParameterFor(projectDir: File): ProjectSchemaBuildStartParameter =

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