def converter = converter("maven")
    def registry = new ProjectLayoutSetupRegistry(defaultType, converter, Mock(TemplateOperationFactory))

    def "can add multiple descriptors"() {
        when:
        registry.add(generator("desc1"))
        registry.add(generator("desc2"))
        registry.add(generator("desc3"))

        then:
        registry.get("desc1") != null
        registry.get("desc2") != null

	registry := testutil.NewFakeKubeRegistry("1.30.0")
	registry.MustRegister(encryptionConfigAutomaticReloadsTotal)
	registry.MustRegister(deprecatedEncryptionConfigAutomaticReloadFailureTotal)
	registry.MustRegister(deprecatedEncryptionConfigAutomaticReloadSuccessTotal)
	registry.MustRegister(encryptionConfigAutomaticReloadLastTimestampSeconds)

	t.Cleanup(func() { registry.Reset() })

	return registry
}

        DefaultProjectDescriptor project = new DefaultProjectDescriptor(null, "name", TEST_DIR, registry, FILE_RESOLVER);

        registry.changeDescriptorPath(Path.path(":"), Path.path(":newPath"));
        assertThat(registry.getRootProject(), nullValue());
        assertThat(registry.getProject(":"), nullValue());
        assertThat(registry.getProject(":newPath"), sameInstance(project));
    }

package mime

import (
	"internal/syscall/windows/registry"
)

func init() {
	osInitMime = initMimeWindows
}

func initMimeWindows() {
	names, err := registry.CLASSES_ROOT.ReadSubKeyNames()
	if err != nil {
		return
	}
	for _, name := range names {
		if len(name) < 2 || name[0] != '.' { // looking for extensions only
			continue
		}
		k, err := registry.OpenKey(registry.CLASSES_ROOT, name, registry.READ)
		if err != nil {

namespace mlir {

void RegisterCommonToolingDialects(mlir::DialectRegistry& registry) {
  mlir::RegisterAllTensorFlowDialects(registry);
  mlir::mhlo::registerAllMhloDialects(registry);
  mlir::registerAllDialects(registry);
  mlir::registerAllExtensions(registry);
  mlir::stablehlo::registerAllDialects(registry);

  registry.insert<mlir::TFL::TensorFlowLiteDialect>();
  registry.insert<mlir::kernel_gen::tf_framework::TFFrameworkDialect>();

        return registry.find(path, clazz);
    }

    @Nullable
    private static <T> T modelElement(ModelRegistry registry, String path, ModelType<T> modelType) {
        return registry.find(path, modelType);
    }

    def loggerFactory = new RecordingProgressLoggerFactory()
    def logger = Mock(Logger)

    def "registry keeps track of initial installations"() {
        def jdk8 = createJdkInstallation("8")
        when:
        def registry = createRegistry([jdk8])
        def installations = registry.listInstallations()

        then:
        installations.size() == 1
        installations[0].location == jdk8

	registry := runtime.Registry{}
	profile := &schedulerapi.KubeSchedulerProfile{
		SchedulerName: profileName,
		Plugins:       &schedulerapi.Plugins{},
	}
	for _, f := range fns {
		f(&registry, profile)
	}
	return runtime.NewFramework(ctx, registry, profile, opts...)
}

        given:
        def registry = scopedRegistry(Scope.BuildTree)
        def service = new BuildTreeScopedService()

        when:
        registry.add(service)

        then:
        noExceptionThrown()

        and:
        registry.get(BuildTreeScopedService) === service
    }

    def "fails to create an inherited registry providing a service in the wrong scope"() {
        when:

        add(Chmod, chmod)
    }}

    def registry(baseDir) {
        new DefaultServiceRegistry(parent).addProvider(new DaemonRegistryServices(tmp.createDir(baseDir)))
    }

    def "same daemon registry instance is used for same daemon registry file across service instances"() {
        expect:
        registry("a").get(DaemonRegistry).is(registry("a").get(DaemonRegistry))