Name:             stat.EndpointId,
				Id:               stat.EndpointId,
				SharedContainers: []string{c.container.ID},
			}
		}
	}

	eps := []hcsshim.HNSEndpoint{}
	for _, ep := range uniqueEndpoints {
		eps = append(eps, *ep)
	}

	return eps, nil
}

func Test_criStatsProvider_listContainerNetworkStats(t *testing.T) {
	fakeClock := testingclock.NewFakeClock(time.Time{})
	tests := []struct {
		name    string

	gotY, err := protomarshal.ToYAML(got)
	t.Log("Result: \n", gotY, err)
}

func getExtensionProviders(eps []*meshconfig.MeshConfig_ExtensionProvider) []string {
	got := []string{}
	for _, ep := range eps {
		got = append(got, ep.Name)
	}
	return got
}

func TestDeepMerge(t *testing.T) {
	cases := []struct {
		name string
		in   string
		out  string
	}{
		{

	var errs []error

	expectedCopy := sets.New[string](expected.UnsortedList()...)
	for _, ep := range actual {
		if !expectedCopy.Has(ep.String()) {
			errs = append(errs, fmt.Errorf("unexpected endpoint %v", ep))
		}
		expectedCopy.Delete(ep.String())
	}
	if len(expectedCopy) > 0 {
		errs = append(errs, fmt.Errorf("missing endpoints %v", expectedCopy.UnsortedList()))
	}

	for _, pool := range endpoints {
		for _, ep := range pool.Endpoints {
			if offlineHost == "" && ep.IsLocal || offlineHost == ep.Host {
				offlineDisks = append(offlineDisks, madmin.Disk{
					Endpoint:  ep.String(),
					State:     string(madmin.ItemOffline),
					PoolIndex: ep.PoolIdx,
					SetIndex:  ep.SetIdx,
					DiskIndex: ep.DiskIdx,
				})
			}
		}
	}
	return offlineDisks

	retry.UntilSuccessOrFail(t, func() error {
		found := false
		for _, ep := range ads.GetEndpoints()["outbound|80||foo.com"].Endpoints {
			if ep.Priority == 1 {
				found = true
			}
		}
		if !found {
			return fmt.Errorf("locality did not update")
		}
		return nil
	}, retry.Timeout(time.Second*5))

	ads.WaitClear()

a8okRAx6XGDL4mmaXANwM63L5buRTnYoEla/0jYfYlgLnwee8yxElSfVJtXFaCJ3
GelAuOYQVqc7+cQoZgoEzjoZOr2YHue7MHR4g7P4t+Vl6CsuuPfv5a5RZVFKk/PK
BOgTUnfENTnuV730Gibh6cVTddAHxGQ3Wh0pjDPGOTB5QI85GxDBJcYEm0wdYqeq
eP/FFnS7G+tK4b+iKp6cAvNjKx2z3lVsHAQ39SSJK8Eg9M8Jj63K0wM0YD8KYI5R
8QfXhYIx1LnUGQ5M6BrLAgAOj/5bp4m60QqPEJIet1/6ByhqTq54fp+8twZO8uj7
CuHtHlYj72FMF/Q76Q9gyrDfC6Bt3FJyPTyCSKAXlv42g1NJ3GhEIWjrXHJPxfrh
8da8wNayiQo+u6TMKIsh9JFLMyNBxo+gyw==

		return
	}
	// fire instance handles for workload
	ep := pc.c.NewEndpointBuilder(pod).buildIstioEndpoint(pod.Status.PodIP, 0, "", model.AlwaysDiscoverable, model.Healthy)
	workloadInstance := &model.WorkloadInstance{
		Name:      pod.Name,
		Namespace: pod.Namespace,
		Kind:      model.PodKind,
		Endpoint:  ep,
		PortMap:   getPortMap(pod),
	}

        "list",
        "patch",
        "update",
        "watch"
      ]
    },
    {
      "kind": "Endpoints",
      "name": "endpoints",
      "namespaced": true,
      "shortNames": [
        "ep"
      ],
      "singularName": "endpoints",
      "storageVersionHash": "fWeeMqaN/OA=",
      "verbs": [
        "create",
        "delete",
        "deletecollection",
        "get",
        "list",

func ExtractHealthEndpoints(cla *endpoint.ClusterLoadAssignment) ([]string, []string) {
	if cla == nil {
		return nil, nil
	}
	healthy := []string{}
	unhealthy := []string{}
	for _, ep := range cla.Endpoints {
		for _, lb := range ep.LbEndpoints {
			var addrString string
			switch lb.GetEndpoint().GetAddress().Address.(type) {
			case *core.Address_SocketAddress:
				addrString = fmt.Sprintf("%s:%d",

	if !ok {
		return madmin.BgHealState{}, false
	}

	status := madmin.BgHealState{
		ScannedItemsCount: bgSeq.getScannedItemsCount(),
	}

	healDisksMap := map[string]struct{}{}
	for _, ep := range getLocalDisksToHeal() {
		healDisksMap[ep.String()] = struct{}{}
	}

	if o == nil {
		healing := globalBackgroundHealState.getLocalHealingDisks()
		for _, disk := range healing {