t.Run(test.desc, func(t *testing.T) {
			defer registry.Reset()
			RecordEtcdRequest(test.operation, test.typ, test.err, test.startTime)
			if err := testutil.GatherAndCompare(registry, strings.NewReader(test.want), testedMetricsName...); err != nil {
				t.Fatal(err)
			}
		})
	}
}

func TestStorageSizeCollector(t *testing.T) {
	registry := metrics.NewKubeRegistry()
	registry.CustomMustRegister(storageMonitor)

        when:
        registry.registerWithInitializer("foo", NamedThingInterface, nodeInitializerRegistry)

        then:
        registry.realize("foo", NamedThingInterface).name == "foo"

        when:
        registry.registerWithInitializer("bar", NamedThingInterface, nodeInitializerRegistry)

        then:
        registry.realize("bar", NamedThingInterface).name == "bar"
    }

        collection.visitDependencies(Stub(TaskDependencyResolveContext))

        then:
        registry.state("tasks.redundant") == ModelNode.State.Discovered
    }

    def "realize is idempotent"() {
        given:
        ModelRegistryHelper registry = new ModelRegistryHelper()
        ModelPath path = ModelPath.path("tasks")

			destroyFunc, registry := NewTestGenericStoreRegistry(t)
			defer destroyFunc()
			registry.Decorator = tc.decorator
			registry.UpdateStrategy.(*testRESTStrategy).allowCreateOnUpdate = true
			registry.BeginUpdate = tc.beginUpdate
			registry.AfterUpdate = tc.afterUpdate
			registry.BeginCreate = tc.beginCreate
			registry.AfterCreate = tc.afterCreate
			registry.TTLFunc = tc.ttl

	resourceclaimparametersstore "k8s.io/kubernetes/pkg/registry/resource/resourceclaimparameters/storage"
	resourceclaimtemplatestore "k8s.io/kubernetes/pkg/registry/resource/resourceclaimtemplate/storage"
	resourceclassstore "k8s.io/kubernetes/pkg/registry/resource/resourceclass/storage"
	resourceclassparametersstore "k8s.io/kubernetes/pkg/registry/resource/resourceclassparameters/storage"

#   REGISTRY=$VAR make
# .. is not the same as:
#   make REGISTRY=$VAR
REGISTRY := $(if $(REGISTRY),$(REGISTRY),staging-k8s.gcr.io)
IMAGE_TAG := $(if $(IMAGE_TAG),$(IMAGE_TAG),latest)

all: gcloudpush

build:
	docker build --pull -t $(REGISTRY)/kubemark:$(IMAGE_TAG) .

gcloudpush: build
	docker push $(REGISTRY)/kubemark:$(IMAGE_TAG)

push: build

        when:
        registry.maybeRegisterComponentType(MyComponentType).registerArtifactType(MyArtifactType, ArtifactType.SOURCES)

        then:
        registry.getComponentRegistration(MyComponentType).getArtifactType(MyArtifactType) == ArtifactType.SOURCES
    }

    def "can separately register multiple artifact types for component type"() {
        when:

        addClassLoader(knownClassLoaders, registry.getRuntimeClassLoader(), "runtime:" + gradleVersion);
        addClassLoader(knownClassLoaders, registry.getGradleApiClassLoader(), "gradle-api:" + gradleVersion);
        addClassLoader(knownClassLoaders, registry.getGradleCoreApiClassLoader(), "gradle-core-api:" + gradleVersion);
        addClassLoader(knownClassLoaders, registry.getPluginsClassLoader(), "plugins:" + gradleVersion);

    DaemonRegistry registry

    def setup() {
        // Start with a new registry on each test.
        registry = new EmbeddedDaemonRegistry()
    }

    DaemonInfo registerDaemon(DaemonStateControl.State state, long lastIdle = -1) {
        final String uid = UUID.randomUUID().toString()
        final int id = registry.getAll().size() + 1

void Register(const std::string& op_name, OpRegistry* registry) {
  registry->Register([op_name](OpRegistrationData* op_reg_data) -> Status {
    op_reg_data->op_def.set_name(op_name);
    return absl::OkStatus();
  });
}

}  // namespace

TEST(TfTextUtilsTest, TestTfTextRegistered) {
  std::unique_ptr<OpRegistry> registry(new OpRegistry);
  Register("WhitespaceTokenizeWithOffsets", registry.get());