})
	}
}

func Test_getNamespaces(t *testing.T) {
	createNamespace := func(name string, labels map[string]string) *corev1.Namespace {
		return &corev1.Namespace{
			ObjectMeta: metav1.ObjectMeta{
				Name:   name,
				Labels: labels,
			},
		}
	}
	nss := []runtime.Object{
		createNamespace("default", nil),
		createNamespace("kube-system", nil),

		setLV := strconv.Itoa(h.SetID)
		labels := []string{poolIDL, poolLV, setIDL, setLV}
		m.Set(erasureSetReadQuorum, float64(h.ReadQuorum), labels...)
		m.Set(erasureSetWriteQuorum, float64(h.WriteQuorum), labels...)
		m.Set(erasureSetOnlineDrivesCount, float64(h.HealthyDrives), labels...)
		m.Set(erasureSetHealingDrivesCount, float64(h.HealingDrives), labels...)
		m.Set(erasureSetHealth, b2f(h.Healthy), labels...)

		readHealthy := true

}

func LabelSelectorAsSelector(ps *meshapi.LabelSelector) (labels.Selector, error) {
	if ps == nil {
		return labels.Nothing(), nil
	}
	if len(ps.MatchLabels)+len(ps.MatchExpressions) == 0 {
		return labels.Everything(), nil
	}
	requirements := make([]labels.Requirement, 0, len(ps.MatchLabels)+len(ps.MatchExpressions))
	for k, v := range ps.MatchLabels {
		r, err := labels.NewRequirement(k, selection.Equals, []string{v})

	Type   string   `json:"type"`
	Labels []string `json:"labels"`
}

func (md metricDisplay) String() string {
	return fmt.Sprintf("Name: %s\nType: %s\nHelp: %s\nLabels: {%s}\n", md.Name, md.Type, md.Help, strings.Join(md.Labels, ","))
}

func (md metricDisplay) TableRow() string {
	labels := strings.Join(md.Labels, ",")
	if labels == "" {
		labels = ""
	} else {
		labels = "`" + labels + "`"
	}

func DefaultClusterScopedAttr(obj runtime.Object) (labels.Set, fields.Set, error) {
	metadata, err := meta.Accessor(obj)
	if err != nil {
		return nil, nil, err
	}
	fieldSet := fields.Set{
		"metadata.name": metadata.GetName(),
	}

	return labels.Set(metadata.GetLabels()), fieldSet, nil
}

func DefaultNamespaceScopedAttr(obj runtime.Object) (labels.Set, fields.Set, error) {
	metadata, err := meta.Accessor(obj)

				continue
			}
		}

		labels := make([]string, 0, len(metric.VariableLabels)*2)
		for k, v := range metric.VariableLabels {
			if newLabel, ok := renameLabels[k]; ok {
				labels = append(labels, newLabel, v)
			} else {
				labels = append(labels, k, v)
			}
		}
		labels = append(labels, extraLabels...)
		// If valid non zero value set the metrics
		if metric.Value > 0 {

			Labels: map[string]string{"app": "wle"},
		},
		Resolution: networking.ServiceEntry_STATIC,
	},
}

func TestIndex(t *testing.T) {
	// Setup a couple of workload instances for test
	wi1 := &model.WorkloadInstance{
		Name:      selector.Name,
		Namespace: selector.Namespace,
		Endpoint: &model.IstioEndpoint{
			Address:        "2.2.2.2",
			Labels:         map[string]string{"app": "wle"},

		expected *tcp.TcpProxy
	}{
		{
			name: "telemetry",
			push: env.PushContext(),
			proxy: &model.Proxy{
				ConfigNamespace: "default",
				Labels:          map[string]string{"app": "test"},
				Metadata:        &model.NodeMetadata{Labels: map[string]string{"app": "test"}},
			},
			tcp:   &tcp.TcpProxy{},
			class: networking.ListenerClassSidecarInbound,
			expected: &tcp.TcpProxy{

         "metadata":{
            "name":"mock",
            "labels":{
               "app":"mock",
               "status":"replaced"
            }
         },
         "spec":{
            "replicas":1,
            "selector":{
               "app":"mock"
            },
            "template":{
               "metadata":{
                  "labels":{
                     "app":"mock"
                  }

	if r.Metadata.Labels[InjectionLabelName] == InjectionLabelEnableValue {
		return false
	}
	if v, ok := r.Metadata.Labels[label.IoIstioRev.Name]; ok && v != "" {
		return false
	}
	return r.Metadata.Labels[constants.DataplaneModeLabel] == constants.DataplaneModeAmbient
}