vID, err := uuid.Parse(fi.TierFreeVersionID())
		if err != nil {
			panic(fmt.Errorf("Invalid Tier Object delete marker versionId %s %v", fi.TierFreeVersionID(), err))
		}
		freeEntry := xlMetaV2Version{Type: DeleteType, WrittenByVersion: globalVersionUnix}
		freeEntry.DeleteMarker = &xlMetaV2DeleteMarker{
			VersionID: vID,
			ModTime:   j.ModTime, // fi.ModTime may be empty
			MetaSys:   make(map[string][]byte),
		}

	// An "invalid array index" compiler error signifies that the constant values have changed.
	// Re-run the stringer command to generate them again.
	var x [1]struct{}
	_ = x[invalidVersionType-0]
	_ = x[ObjectType-1]
	_ = x[DeleteType-2]
	_ = x[LegacyType-3]
	_ = x[lastVersionType-4]
}

const _VersionType_name = "invalidVersionTypeObjectTypeDeleteTypeLegacyTypelastVersionType"

var _VersionType_index = [...]uint8{0, 18, 28, 38, 48, 63}

// limitations under the License.

package repair

import (
	"istio.io/istio/pkg/monitoring"
)

var (
	typeLabel  = monitoring.CreateLabel("type")
	deleteType = "delete"
	repairType = "repair"
	labelType  = "label"

	resultLabel   = monitoring.CreateLabel("result")
	resultSuccess = "success"
	resultSkip    = "skip"
	resultFail    = "fail"

		return j.ObjectV2.Signature()
	case DeleteType:
		return j.DeleteMarker.Signature()
	case LegacyType:
		return j.ObjectV1.Signature()
	}
	return signatureErr
}

// getModTime will return the ModTime of the underlying version.
func (j xlMetaV2Version) getModTime() time.Time {
	switch j.Type {
	case ObjectType:
		return time.Unix(0, j.ObjectV2.ModTime)
	case DeleteType:

				{header: xlMetaV2VersionHeader{
					VersionID: [16]byte{7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7},
					ModTime:   baseTime.Add(90 * time.Minute).UnixNano(),
					Signature: [4]byte{6, 1, 1, 1},
					Type:      DeleteType,
					Flags:     0,
				}},
			},
		},
		// Delete marker and version from 1
		9: {
			versions: []xlMetaV2ShallowVersion{
				{header: xlMetaV2VersionHeader{

	}
	o, err = j.UnmarshalMsg(bts)

	// Fix inconsistent x-minio-internal-replication-timestamp by converting to UTC.
	// Fixed in version 2 or later
	if err == nil && j.Type == DeleteType && v < 2 {
		if val, ok := j.DeleteMarker.MetaSys[ReservedMetadataPrefixLower+ReplicationTimestamp]; ok {
			tm, err := time.Parse(time.RFC3339Nano, string(val))
			if err == nil {

			},
			wantPods:  []*corev1.Pod{workingPod, workingPodDiedPreviously},
			wantErr:   false,
			wantCount: 1,
			wantTags:  map[string]string{"result": resultSuccess, "type": deleteType},
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			mt := monitortest.New(t)
			tt.config.DeletePods = true
			c, err := NewRepairController(tt.client, tt.config)

}

const (
	ReasonDeleteBrokenPod = "DeleteBrokenPod"
	ReasonLabelBrokenPod  = "LabelBrokenPod"
)

func (c *Controller) deleteBrokenPod(pod *corev1.Pod) error {
	m := podsRepaired.With(typeLabel.Value(deleteType))
	repairLog.Infof("Pod detected as broken, deleting: %s/%s", pod.Namespace, pod.Name)

	// Make sure we are deleting what we think we are...
	preconditions := &metav1.Preconditions{
		UID:             &pod.UID,

func (e *metaCacheEntry) isLatestDeletemarker() bool {
	if e.cached != nil {
		if len(e.cached.versions) == 0 {
			return true
		}
		return e.cached.versions[0].header.Type == DeleteType
	}
	if !isXL2V1Format(e.metadata) {
		return false
	}
	if meta, _, err := isIndexedMetaV2(e.metadata); meta != nil {
		return meta.IsLatestDeleteMarker()
	} else if err != nil {
		return true
	}

		}
		test(t, &xl)
	})
	t.Run("write-timestamp", func(t *testing.T) {
		var xl xlMetaV2
		err = xl.Load(data)
		if err != nil {
			t.Fatal(err)
		}
		ventry := xlMetaV2Version{
			Type: DeleteType,
			DeleteMarker: &xlMetaV2DeleteMarker{
				VersionID: uuid.New(),
				ModTime:   time.Now().UnixNano(),