JobTemplate: batch.JobTemplateSpec{
			Spec: batch.JobSpec{
				Template: validPodTemplateSpec,
			},
		},
	}
)

func completionModePtr(m batch.CompletionMode) *batch.CompletionMode {
	return &m
}

func TestCronJobStrategy(t *testing.T) {
	ctx := genericapirequest.NewDefaultContext()
	if !Strategy.NamespaceScoped() {
		t.Errorf("CronJob must be namespace scoped")
	}

                          CreateFingerprintDef(export_dir));
  EXPECT_GT(fingerprint_pb.saved_model_checksum(), 0);
  // We test for multiple fingerprints due to non-determinism when building with
  // different compilation_mode flag options.
  EXPECT_THAT(absl::flat_hash_set<uint64_t>(
                  {906548630859202535U, 9562420523583756263U}),
              ::testing::Contains(fingerprint_pb.graph_def_program_hash()));

	// is possible during upgrades due to version skew, the controller
	// skips updates for the Job.
	// +optional
	CompletionMode *CompletionMode `json:"completionMode,omitempty" protobuf:"bytes,9,opt,name=completionMode,casttype=CompletionMode"`

	// suspend specifies whether the Job controller should create Pods or not. If
	// a Job is created with suspend set to true, no Pods are created by the Job

		return err
	}
	out.TTLSecondsAfterFinished = (*int32)(unsafe.Pointer(in.TTLSecondsAfterFinished))
	out.CompletionMode = (*batch.CompletionMode)(unsafe.Pointer(in.CompletionMode))
	out.Suspend = (*bool)(unsafe.Pointer(in.Suspend))
	out.PodReplacementPolicy = (*batch.PodReplacementPolicy)(unsafe.Pointer(in.PodReplacementPolicy))

	"k8s.io/kubernetes/pkg/features"
)

const (
	completionIndexEnvName = "JOB_COMPLETION_INDEX"
	unknownCompletionIndex = -1
)

func isIndexedJob(job *batch.Job) bool {
	return job.Spec.CompletionMode != nil && *job.Spec.CompletionMode == batch.IndexedCompletion
}

func hasBackoffLimitPerIndex(job *batch.Job) bool {
	return feature.DefaultFeatureGate.Enabled(features.JobBackoffLimitPerIndex) && job.Spec.BackoffLimitPerIndex != nil
}

				j.BackoffLimitPerIndex = pointer.Int32(c.Rand.Int31())
				j.MaxFailedIndexes = pointer.Int32(c.Rand.Int31())
			}
			if c.RandBool() {
				j.BackoffLimit = pointer.Int32(math.MaxInt32)
			}
			j.CompletionMode = &mode
			// We're fuzzing the internal JobSpec type, not the v1 type, so we don't
			// need to fuzz the nil value.
			j.Suspend = pointer.Bool(c.RandBool())
			podReplacementPolicy := batch.TerminatingOrFailed

	// +optional
	Spec JobSpec
}

// CompletionMode specifies how Pod completions of a Job are tracked.
type CompletionMode string

const (
	// NonIndexedCompletion is a Job completion mode. In this mode, the Job is
	// considered complete when there have been .spec.completions
	// successfully completed Pods. Pod completions are homologous to each other.
	NonIndexedCompletion CompletionMode = "NonIndexed"

	if in.TTLSecondsAfterFinished != nil {
		in, out := &in.TTLSecondsAfterFinished, &out.TTLSecondsAfterFinished
		*out = new(int32)
		**out = **in
	}
	if in.CompletionMode != nil {
		in, out := &in.CompletionMode, &out.CompletionMode
		*out = new(CompletionMode)
		**out = **in
	}
	if in.Suspend != nil {
		in, out := &in.Suspend, &out.Suspend
		*out = new(bool)
		**out = **in
	}

	if in.TTLSecondsAfterFinished != nil {
		in, out := &in.TTLSecondsAfterFinished, &out.TTLSecondsAfterFinished
		*out = new(int32)
		**out = **in
	}
	if in.CompletionMode != nil {
		in, out := &in.CompletionMode, &out.CompletionMode
		*out = new(CompletionMode)
		**out = **in
	}
	if in.Suspend != nil {
		in, out := &in.Suspend, &out.Suspend
		*out = new(bool)
		**out = **in
	}

		}
		return nil
	}

	if job.Spec.CompletionMode != nil && *job.Spec.CompletionMode != batch.NonIndexedCompletion && *job.Spec.CompletionMode != batch.IndexedCompletion {
		jm.recorder.Event(&job, v1.EventTypeWarning, "UnknownCompletionMode", "Skipped Job sync because completion mode is unknown")
		return nil
	}

	completionMode := getCompletionMode(&job)
	action := metrics.JobSyncActionReconciling