private final JavaToolchainResolverRegistryInternal registry;

    @Inject
    public DefaultJvmToolchainManagement(JavaToolchainResolverRegistryInternal registry) {
        this.registry = registry;
    }

    @Override
    public JavaToolchainRepositoryHandler getJavaRepositories() {
        return registry.getRepositories();
    }

    @Override

            }
        }

        when:
        registry.get("values")

        then:
        registry.get("first", MutableValue).value == null
        registry.get("second", MutableValue).value == null
        registry.get("values.first", MutableValue).value == "first"
        registry.get("values.second", MutableValue).value == "from first: first"
    }

        JavaExtensionRegistry registry = asciidoctor.javaExtensionRegistry();

        registry.docinfoProcessor(MetadataDocinfoProcessor.class);
        registry.docinfoProcessor(new MultiLanguageSamplesDocinfoProcessor());

        registry.includeProcessor(GuidesContributeIncludeProcessor.class);
        registry.includeProcessor(SampleIncludeProcessor.class);

        registry.treeprocessor(ExampleSelfLinkProcessor.class);
    }

	}{
		{
			name:           "with .dockerconfigjson and auth field",
			image:          "test.registry.io",
			defaultKeyring: &fakeKeyring{},
			pullSecrets: []v1.Secret{
				{
					Type: v1.SecretTypeDockerConfigJson,
					Data: map[string][]byte{
						v1.DockerConfigJsonKey: []byte(`{"auths": {"test.registry.io": {"auth": "dXNlcjpwYXNzd29yZA=="}}}`),
					},
				},
			},

// license that can be found in the LICENSE file.

//go:build windows

// Package registry provides access to the Windows registry.
//
// Here is a simple example, opening a registry key and reading a string value from it.
//
//	k, err := registry.OpenKey(registry.LOCAL_MACHINE, `SOFTWARE\Microsoft\Windows NT\CurrentVersion`, registry.QUERY_VALUE)
//	if err != nil {
//		log.Fatal(err)
//	}
//	defer k.Close()
//

    def "can be empty"() {
        def registry = new ToPlannedNodeConverterRegistry([])
        expect:
        registry.getConverter(Stub(Node)) == null
    }

    def "finds converter matching type"() {
        def testConverter = Stub(ToPlannedNodeConverter) {
            getSupportedNodeType() >> TestNode
        }
        def registry = new ToPlannedNodeConverterRegistry([testConverter])

        when:

    def os = Stub(OperatingSystem)
    def registry = new ToolSearchPath(os)

    def "finds executable in system path"() {
        def file = tmpDir.createFile("cc.bin")

        given:
        os.getExecutableName("cc") >> "cc.bin"
        os.path >> [file.parentFile]

        when:
        def result = registry.locate(ToolType.C_COMPILER, "cc")

        then:
        result.available

        ProjectLayoutSetupRegistry registry = new ProjectLayoutSetupRegistry(basicType, mavenBuildConverter, templateOperationBuilder);
        registry.add(of(new JvmApplicationProjectInitDescriptor(Description.JAVA, libraryVersionProvider, documentationRegistry), jvmProjectGenerators, libraryVersionProvider));

  std::string saved_model_mlir_path = tensorflow::GetDataDependencyFilepath(
      "tensorflow/compiler/mlir/tfrt/tests/saved_model/testdata/test.mlir");

  mlir::DialectRegistry registry;
  mlir::RegisterAllTensorFlowDialects(registry);
  mlir::MLIRContext context(registry);
  auto module =
      mlir::parseSourceFile<mlir::ModuleOp>(saved_model_mlir_path, &context);
  ASSERT_TRUE(module);

  std::vector<std::string> inputs;

                    registry.register(new RunEclipseTasksBuilder());
                    registry.register(new EclipseModelBuilder(gradleProjectBuilder, projectStateRegistry));
                    registry.register(ideaModelBuilder);
                    registry.register(gradleProjectBuilder);
                    registry.register(new GradleBuildBuilder(buildStateRegistry));
                    registry.register(new BasicIdeaModelBuilder(ideaModelBuilder));