message SuccessPolicyRule {
  // succeededIndexes specifies the set of indexes
  // which need to be contained in the actual set of the succeeded indexes for the Job.
  // The list of indexes must be within 0 to ".spec.completions-1" and
  // must not contain duplicates. At least one element is required.
  // The indexes are represented as intervals separated by commas.

			}
			if !reflect.DeepEqual(testCase.indexes, gotIndexes) {
				t.Errorf("Expected %v, got %v", testCase.indexes, gotIndexes)
			}
		})
	}
}

// Test tests calculating set indexes.
func TestGetSetIndexes(t *testing.T) {
	testCases := []struct {
		args       []string
		totalSizes []uint64
		indexes    [][]uint64
		success    bool
	}{
		// Invalid inputs.
		{

			if diff := cmp.Diff(tc.wantStatusIntervals, gotStatusIntervals); diff != "" {
				t.Errorf("Unexpected completed indexes from status (-want,+got):\n%s", diff)
			}
			if diff := cmp.Diff(tc.wantIntervals, gotIntervals); diff != "" {
				t.Errorf("Unexpected completed indexes (-want,+got):\n%s", diff)
			}
		})
	}
}

func TestIsIndexFailed(t *testing.T) {
	logger, _ := ktesting.NewTestContext(t)

// argument must be a string, slice, or array.
func slice(item reflect.Value, indexes ...reflect.Value) (reflect.Value, error) {
	item = indirectInterface(item)
	if !item.IsValid() {
		return reflect.Value{}, fmt.Errorf("slice of untyped nil")
	}
	if len(indexes) > 3 {
		return reflect.Value{}, fmt.Errorf("too many slice indexes: %d", len(indexes))
	}
	var cap int
	switch item.Kind() {
	case reflect.String:

		},
	}

	c := newTypedXdsCache[uint64]()

	cache := c.(*lruCache[uint64])

	assert.Equal(t, cache.store.Len(), 0)
	assert.Equal(t, cache.indexLength(), 0)

	// adding the entry populates the indexes
	c.Add(firstEntry.Key(), firstEntry, req, res)

	assert.Equal(t, cache.store.Len(), 1)
	assert.Equal(t, cache.indexLength(), 2)
	assert.Equal(t, cache.configIndexSnapshot(), map[ConfigHash]sets.Set[uint64]{

	}
	addService := func(ns string, indexes ...int) {
		var hostnames []string
		for _, i := range indexes {
			hostnames = append(hostnames, fmt.Sprintf("svc%d%s", i, svcSuffix))
		}
		addServiceByNames(ns, hostnames...)
	}

	addServiceInstance := func(hostname host.Name, indexes ...int) {
		for _, i := range indexes {
			s.MemRegistry.AddEndpoint(hostname, "http-main", 2080, "192.168.1.10", i)

// The indexes range in the usual order, from 0 through len(s)-1.
func All[Slice ~[]E, E any](s Slice) iter.Seq2[int, E] {
	return func(yield func(int, E) bool) {
		for i, v := range s {
			if !yield(i, v) {
				return
			}
		}
	}
}

// Backward returns an iterator over index-value pairs in the slice,
// traversing it backward. The indexes range from len(s)-1 down to 0.

		}, []string{"event"})

	// JobFinishedIndexesTotal records the number of finished indexes.
	JobFinishedIndexesTotal = metrics.NewCounterVec(
		&metrics.CounterOpts{
			Subsystem: JobControllerSubsystem,
			Name:      "job_finished_indexes_total",
			Help: `The number of finished indexes. Possible values for the
			status label are: "succeeded", "failed". Possible values for the

		if completions > completionsSoftLimit && parallelism > parallelismSoftLimitForUnlimitedCompletions {
			msg := "In Indexed Jobs with a number of completions higher than 10^5 and a parallelism higher than 10^4, Kubernetes might not be able to track completedIndexes when a big number of indexes fail"
			warnings = append(warnings, fmt.Sprintf("%s: %s", path, msg))
		}
	}
	var oldPodTemplate *core.PodTemplateSpec

The new [iter] package provides the basic definitions for working with
user-defined iterators.

The [slices] package adds several functions that work with iterators:
- [All](/pkg/slices#All) returns an iterator over slice indexes and values.
- [Values](/pkg/slices#Values) returns an iterator over slice elements.
- [Backward](/pkg/slices#Backward) returns an iterator that loops over
  a slice backward.