)

// DefaultParallelism is the default parallelism used in scheduler.
const DefaultParallelism int = 16

// Parallelizer holds the parallelism for scheduler.
type Parallelizer struct {
	parallelism int
}

// NewParallelizer returns an object holding the parallelism.
func NewParallelizer(p int) Parallelizer {
	return Parallelizer{parallelism: p}
}

				t.Errorf(".spec.suspend does not match; -want,+got:\n%s", diff)
			}
			validateDefaultInt32(t, "Completions", actual.Spec.Completions, expected.Spec.Completions)
			validateDefaultInt32(t, "Parallelism", actual.Spec.Parallelism, expected.Spec.Parallelism)
			validateDefaultInt32(t, "BackoffLimit", actual.Spec.BackoffLimit, expected.Spec.BackoffLimit)

			if diff := cmp.Diff(expected.Spec.PodFailurePolicy, actual.Spec.PodFailurePolicy); diff != "" {

			},
			wantWarningsCount: 1,
		},
		"valid Indexed low completions low parallelism": {
			spec: &batch.JobSpec{
				CompletionMode: completionModePtr(batch.IndexedCompletion),
				Completions:    pointer.Int32(10_000),
				Parallelism:    pointer.Int32(10_000),
				Template:       validPodTemplate,
			},
		},
		"valid Indexed high completions low parallelism": {
			spec: &batch.JobSpec{

	// For a non-parallel job, you can leave both `.spec.completions` and
	// `.spec.parallelism` unset.  When both are unset, both are defaulted to 1.
	if obj.Spec.Completions == nil && obj.Spec.Parallelism == nil {
		obj.Spec.Completions = utilpointer.Int32(1)
		obj.Spec.Parallelism = utilpointer.Int32(1)
	}
	if obj.Spec.Parallelism == nil {
		obj.Spec.Parallelism = utilpointer.Int32(1)
	}
	if obj.Spec.BackoffLimit == nil {

		completions := ptr.Deref(spec.Completions, 0)
		parallelism := ptr.Deref(spec.Parallelism, 0)
		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"

						SchedulerName: ptr.To("default-scheduler"),
					},
				},
			},
		},
		{
			name: "set non default parallelism",
			config: &configv1.KubeSchedulerConfiguration{
				Parallelism: ptr.To[int32](8),
			},
			expected: &configv1.KubeSchedulerConfiguration{
				Parallelism: ptr.To[int32](8),
				DebuggingConfiguration: componentbaseconfig.DebuggingConfiguration{
					EnableProfiling:           &enable,

	}
	return &jobStorage, server
}

func validNewJob() *batch.Job {
	completions := int32(1)
	parallelism := int32(1)
	return &batch.Job{
		ObjectMeta: metav1.ObjectMeta{
			Name:      "foo",
			Namespace: "default",
		},
		Spec: batch.JobSpec{
			Completions: &completions,
			Parallelism: &parallelism,
			Selector: &metav1.LabelSelector{
				MatchLabels: map[string]string{"a": "b"},
			},

	}
	// Special case: -1 for either completions or parallelism means leave nil (negative is not allowed
	// in practice by validation.
	if completions >= 0 {
		j.Spec.Completions = &completions
	} else {
		j.Spec.Completions = nil
	}
	if parallelism >= 0 {
		j.Spec.Parallelism = &parallelism
	} else {
		j.Spec.Parallelism = nil
	}
	j.Spec.BackoffLimit = &backoffLimit

	return j
}

		func(j *batch.JobSpec, c fuzz.Continue) {
			c.FuzzNoCustom(j) // fuzz self without calling this function again
			completions := int32(c.Rand.Int31())
			parallelism := int32(c.Rand.Int31())
			backoffLimit := int32(c.Rand.Int31())
			j.Completions = &completions
			j.Parallelism = &parallelism
			j.BackoffLimit = &backoffLimit
			j.ManualSelector = pointer.Bool(c.RandBool())
			mode := batch.NonIndexedCompletion
			if c.RandBool() {

		wantErrs field.ErrorList
	}{
		"good": {
			config: validConfig,
		},
		"bad-parallelism-invalid-value": {
			config: invalidParallelismValue,
			wantErrs: field.ErrorList{
				&field.Error{
					Type:  field.ErrorTypeInvalid,
					Field: "parallelism",
				},
			},
		},
		"bad-resource-name-not-set": {
			config: resourceNameNotSet,
			wantErrs: field.ErrorList{