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

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

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

			},
			outputFormat: "text",
			expectedOutput: `registry.k8s.io/kube-apiserver:{{.KubeVersion}}
registry.k8s.io/kube-controller-manager:{{.KubeVersion}}
registry.k8s.io/kube-scheduler:{{.KubeVersion}}
registry.k8s.io/kube-proxy:{{.KubeVersion}}
registry.k8s.io/coredns/coredns:{{.CoreDNSVersion}}
registry.k8s.io/pause:{{.PauseVersion}}
registry.k8s.io/etcd:{{.EtcdVersion}}
`,
		},
		{
			name: "JSON output",

        def project = Stub(ProjectInternal)
        def projectState = Mock(ProjectState)

        when:
        registry.register(builder1)
        registry.register(builder2)

        then:
        userCodeApplicationContext.current() >> application
        0 * _

        when:
        def actualBuilder = registry.locateForClientOperation("model", false, projectState)

        then:
        builder1.canBuild("model") >> false

	clearMetrics()
	fakeClient := fake.NewSimpleClientset()
	registry := &mockRangeRegistry{
		item: &api.RangeAllocation{Range: "100-200"},
	}
	pr, _ := net.ParsePortRange(registry.item.Range)
	r := NewRepair(0, fakeClient.CoreV1(), fakeClient.EventsV1(), *pr, registry)

	if err := r.runOnce(); err != nil {
		t.Fatal(err)
	}

    final DaemonRegistry registry = Mock()
    final Address address = Mock()
    final DaemonContext context = Mock()
    final updater = new DaemonRegistryUpdater(registry, context)

    def "marks idle"() {
        given:
        updater.onStart(address)

        when:
        updater.onCompleteActivity()

        then:
        1 * registry.markState(address, Idle)
    }

        registry.registerDescriber(IncompatibleGraphVariantFailure.class, IncompatibleGraphVariantsFailureDescriber.class);

        registry.registerDescriber(AmbiguousResolutionFailure.class, AmbiguousArtifactVariantsFailureDescriber.class);
        registry.registerDescriber(IncompatibleResolutionFailure.class, IncompatibleArtifactVariantsFailureDescriber.class);

        reference = ModelReference.of(collectionPath, collectionType)
        registry.register(
            ModelRegistrations.of(collectionPath, nodeInitializer)
                .descriptor("define collection")
                .build()
        )
    }

    void mutate(@DelegatesTo(C) Closure<?> action) {
        registry.mutate(reference, new ClosureBackedAction<>(action))
    }