if startup != proberesults.Success {
						if startup == proberesults.Failure {
							// If the restartable init container failed the startup probe,
							// restart it.
							changes.ContainersToKill[status.ID] = containerToKillInfo{
								name:      container.Name,
								container: container,
								message:   fmt.Sprintf("Init container %s failed startup probe", container.Name),
								reason:    reasonStartupProbe,

	}
	if e, a := map[string]types.UID{"pod1_test1": "2-static"}, podWorkers.startedStaticPodsByFullname; !reflect.DeepEqual(e, a) {
		t.Fatalf("unexpected started static pods: %s", cmp.Diff(e, a))
	}

	// attempt to start a second and third static pod, which should not start
	podWorkers.UpdatePod(UpdatePodOptions{
		Pod:        newNamedPod("3-static", "test1", "pod1", true),
		UpdateType: kubetypes.SyncPodUpdate,
	})

}

// allowStaticPodStart tries to start the static pod and returns true if
// 1. there are no other started static pods with the same fullname
// 2. the uid matches that of the first valid static pod waiting to start
func (p *podWorkers) allowStaticPodStart(fullname string, uid types.UID) bool {
	startedUID, started := p.startedStaticPodsByFullname[fullname]
	if started {
		return startedUID == uid
	}

        _ * b.localStateFile >> sharedFile

        expect:
        tasksAreNotExecutedInParallel(a, b)
    }

    def "a task that writes into a directory that is an output of a running task is not started"() {
        given:
        Task a = task("a", type: AsyncWithOutputDirectory)
        _ * a.outputDirectory >> file("outputDir")
        Task b = task("b", type: AsyncWithOutputDirectory)

						Name:            "finished-job-started-hour-ago",
						OwnerReferences: []metav1.OwnerReference{{Name: "fooer", Controller: pointer.Bool(true)}},
					},
					Status: batchv1.JobStatus{StartTime: &metav1.Time{Time: justBeforeThePriorHour()}},
				},
				{
					ObjectMeta: metav1.ObjectMeta{
						Namespace:       "foo-ns",
						Name:            "finished-job-started-minute-ago",

		ri.countItem(batch[i].Size, batch[i].DeleteMarker, true, 1)
	}
}

// Start start the batch replication job, resumes if there was a pending job via "job.ID"
func (r *BatchJobReplicateV1) Start(ctx context.Context, api ObjectLayer, job BatchJobRequest) error {
	ri := &batchJobInfo{
		JobID:     job.ID,
		JobType:   string(job.Type()),
		StartTime: job.Started,
	}
	if err := ri.load(ctx, api, job); err != nil {
		return err
	}

		}

		// sub[i] is not a char or char class;
		// emit char class for sub[start:i]...
		if i == start {
			// Nothing to do - run of length 0.
		} else if i == start+1 {
			out = append(out, sub[start])
		} else {
			// Make new char class.
			// Start with most complex regexp in sub[start].
			max := start
			for j := start + 1; j < i; j++ {

          }
        },
        "ready": true,
        "restartCount": 5,
        "image": "imageValue",
        "imageID": "imageIDValue",
        "containerID": "containerIDValue",
        "started": true,
        "allocatedResources": {
          "allocatedResourcesKey": "0"
        },
        "resources": {
          "limits": {
            "limitsKey": "0"
          },

          }
        },
        "ready": true,
        "restartCount": 5,
        "image": "imageValue",
        "imageID": "imageIDValue",
        "containerID": "containerIDValue",
        "started": true,
        "allocatedResources": {
          "allocatedResourcesKey": "0"
        },
        "resources": {
          "limits": {
            "limitsKey": "0"
          },

          }
        },
        "ready": true,
        "restartCount": 5,
        "image": "imageValue",
        "imageID": "imageIDValue",
        "containerID": "containerIDValue",
        "started": true,
        "allocatedResources": {
          "allocatedResourcesKey": "0"
        },
        "resources": {
          "limits": {
            "limitsKey": "0"
          },