ic.createKubeService(t, c)
	ic.createServiceImport(t, mcsapi.ClusterSetIP, serviceImportVIPs)
	ic.checkServiceInstances(t)

	// Update the k8s service and verify that both services are updated.
	ic.updateKubeService(t)
}

func TestHeadlessServiceImported(t *testing.T) {
	// Create and run the controller.
	c, ic := newTestServiceImportCache(t)

	ic.createKubeService(t, c)
	ic.createServiceImport(t, mcsapi.Headless, nil)

			ServiceCIDR:          ic.serviceCIDR,
			SecondaryServiceCIDR: ic.secondaryServiceCIDR,
			NodeCIDRMaskSizes:    nodeCIDRMaskSizes,
		}

		ic.cidrAllocator, err = ipam.New(ctx, kubeClient, cloud, nodeInformer, ic.allocatorType, allocatorParams)
		if err != nil {
			return nil, err
		}
	}

	ic.nodeLister = nodeInformer.Lister()
	ic.nodeInformerSynced = nodeInformer.Informer().HasSynced

		vips := ic.getClusterSetIPs(namespacedName)
		name := namespacedName.Name
		ns := namespacedName.Namespace

		if len(vips) == 0 || (event == model.EventDelete &&
			ic.opts.MeshServiceController.GetService(kube.ServiceHostname(name, ns, ic.opts.DomainSuffix)) == nil) {
			if prevMcsService != nil {
				// There are no vips in this cluster. Just delete the MCS service now.
				ic.deleteService(prevMcsService)
			}

	filter Filter,
) Informer[T] {
	ic := &informerClient[T]{
		informer:      inf.Informer,
		startInformer: inf.Start,
	}
	if filter.ObjectFilter != nil {
		applyDynamicFilter(filter, gvr, ic)
	}
	return ic
}

func applyDynamicFilter[T controllers.ComparableObject](filter Filter, gvr schema.GroupVersionResource, ic *informerClient[T]) {
	if filter.ObjectFilter != nil {

	return &configMap{
		ctx:       ctx,
		namespace: namespace,
		revisions: revisions,
	}
}

func (ic *injectConfig) InjectConfig() (*inject.Config, error) {
	ic.mu.Lock()
	myic := ic.injectConfig
	ic.mu.Unlock()

	if myic == nil {
		c := ic.ctx.AllClusters().Configs()[0]

		cfgMap, err := ic.getConfigMap(c, ic.configMapName())
		if err != nil {
			return nil, err
		}

	istrue(ib != ic)
	istrue(ib != id)
	isfalse(ic != id)
	isfalse(ie != ie)

	// these are not okay, because there is no comparison on slices or maps.
	//isfalse(a == ib)
	//isfalse(a == ic)
	//isfalse(a == id)
	//isfalse(b == ic)
	//isfalse(b == id)

	istrue(c == id)
	istrue(e == ie)

	//isfalse(ia == b)
	isfalse(ia == c)
	isfalse(ia == d)
	isfalse(ib == c)
	isfalse(ib == d)
	istrue(ic == d)

	// If CAName is empty this is a CA cert.
	if len(k.CAName) != 0 {
		if ic.ClusterConfiguration.CertificateValidityPeriod != nil {
			k.config.NotAfter = k.creationTime.
				Add(ic.ClusterConfiguration.CertificateValidityPeriod.Duration)
		}
	} else {
		if ic.ClusterConfiguration.CACertificateValidityPeriod != nil {
			k.config.NotAfter = k.creationTime.
				Add(ic.ClusterConfiguration.CACertificateValidityPeriod.Duration)
		}
	}

	return ic.Read(c)
}

// ReadStackCounter reads the given StackCounter.
func ReadStackCounter(c *counter.StackCounter) (stackCounts map[string]uint64, _ error) {
	return ic.ReadStack(c)
}

// ReadFile reads the counters and stack counters from the given file.
func ReadFile(name string) (counters, stackCounters map[string]uint64, _ error) {
	return ic.ReadFile(name)

  handle_data.set_is_set(true);
  {
    mutex_lock l(graph->mu);
    tensorflow::shape_inference::InferenceContext* ic =
        graph->refiner.GetContext(node);
    CHECK(ic != nullptr);
    CHECK_LT(output.index, ic->num_outputs());
    const auto* shapes_and_types =
        ic->output_handle_shapes_and_types(output.index);
    if (shapes_and_types == nullptr) return "";

    for (const auto& p : *shapes_and_types) {

	for i := 0; i < ilevel; i++ {
		base.Ctxt.Logf("  ")
	}
	ic := inlcalls.Calls[idx]
	callee := base.Ctxt.InlTree.InlinedFunction(ic.InlIndex)
	base.Ctxt.Logf("  %d: II:%d (%s) V: (", idx, ic.InlIndex, callee.Name)
	for _, f := range ic.InlVars {
		base.Ctxt.Logf(" %v", f.Name)
	}
	base.Ctxt.Logf(" ) C: (")
	for _, k := range ic.Children {
		base.Ctxt.Logf(" %v", k)
	}
	base.Ctxt.Logf(" ) R:")