data.statuses,
			)
		}
	}
}

func TestLess(t *testing.T) {
	var cases = []struct {
		statuses SortedContainerStatuses
		expected bool
	}{
		{
			statuses: SortedContainerStatuses{{Name: "first"}, {Name: "second"}},
			expected: true,
		},
		{
			statuses: SortedContainerStatuses{{Name: "second"}, {Name: "first"}},
			expected: false,
		},
	}
	for _, data := range cases {

}

// SortInitContainerStatuses ensures that statuses are in the order that their
// init container appears in the pod spec
func SortInitContainerStatuses(p *v1.Pod, statuses []v1.ContainerStatus) {
	containers := p.Spec.InitContainers
	current := 0
	for _, container := range containers {
		for j := current; j < len(statuses); j++ {
			if container.Name == statuses[j].Name {
				statuses[current], statuses[j] = statuses[j], statuses[current]

			containers:        []v1.Container{{Name: "container-1"}},
			statuses:          []v1.ContainerStatus{{Name: "container-1"}},
			idx:               2,
			expectedContainer: v1.Container{},
			expectedOK:        false,
		}, {
			title:             "idx is large then number of statuses",
			containers:        []v1.Container{{Name: "container-1"}, {Name: "container-2"}},
			statuses:          []v1.ContainerStatus{{Name: "container-1"}},

func parseClusterStatuses(input map[string][]byte) (map[string][]cluster.DebugInfo, error) {
	statuses := make(map[string][]cluster.DebugInfo, len(input))
	for istiodKey, bytes := range input {
		var parsed []cluster.DebugInfo
		if err := json.Unmarshal(bytes, &parsed); err != nil {
			return nil, err
		}
		statuses[istiodKey] = parsed
	}
	return statuses, nil

func (w *sdsWriter) PrintDiffs(statuses []SecretItemDiff) error {
	var err error
	switch w.output {
	case JSON:
		err = w.printDiffsJSON(statuses)
	case TABULAR:
		err = w.printDiffsTabular(statuses)
	}
	return err
}

// printDiffsTabular prints the secret in table format
func (w *sdsWriter) printDiffsTabular(statuses []SecretItemDiff) error {
	if len(statuses) == 0 {

        if (statuses.isEmpty()) {
            LOGGER.quiet(DaemonMessages.NO_DAEMONS_RUNNING);
        }

        if (!(statuses.isEmpty() && stopEvents.isEmpty())) {
            LOGGER.quiet(String.format(STATUS_FORMAT, "PID", "STATUS", "INFO"));
        }

        printRunningDaemons(statuses);
        printStoppedDaemons(stopEvents);

        LOGGER.quiet("");

		}
	}
	return true
}

// GetContainerStatus extracts the status of container "name" from "statuses".
// It returns true if "name" exists, else returns false.
func GetContainerStatus(statuses []v1.ContainerStatus, name string) (v1.ContainerStatus, bool) {
	for i := range statuses {
		if statuses[i].Name == name {
			return statuses[i], true
		}
	}
	return v1.ContainerStatus{}, false
}

// "containers" with respect to "statuses".
// It returns true if the container is valid, else returns false.
func GetContainerByIndex(containers []v1.Container, statuses []v1.ContainerStatus, idx int) (v1.Container, bool) {
	if idx < 0 || idx >= len(containers) || idx >= len(statuses) {
		return v1.Container{}, false
	}
	if statuses[idx].Name != containers[idx].Name {
		return v1.Container{}, false
	}

		},
		{
			name: "same type statuses without reasons should be equal",
			x:    NewStatus(Success),
			y:    NewStatus(Success),
			want: true,
		},
		{
			name: "statuses with same message should be equal",
			x:    NewStatus(Unschedulable, "unschedulable"),
			y:    NewStatus(Unschedulable, "unschedulable"),
			want: true,
		},
		{
			name: "error statuses with same message should be equal",

			if s.SchedulerName == "" {
				s.SchedulerName = "default-scheduler"
			}
		},
		func(j *example.PodPhase, c fuzz.Continue) {
			statuses := []example.PodPhase{"Pending", "Running", "Succeeded", "Failed", "Unknown"}
			*j = statuses[c.Rand.Intn(len(statuses))]
		},
		func(rp *example.RestartPolicy, c fuzz.Continue) {
			policies := []example.RestartPolicy{"Always", "Never", "OnFailure"}