// appears in outDatedDisks.
					tamperedIndex = index
					dErr := erasureDisks[index].Delete(context.Background(), bucket, pathJoin(object, fi.DataDir, "part.1"), DeleteOptions{
						Recursive: false,
						Immediate: false,
					})
					if dErr != nil {
						t.Fatalf("Failed to delete %s - %v", filepath.Join(object, "part.1"), dErr)
					}
					break
				}
			case corruptPart:

pkg syscall (freebsd-arm64), type Timeval struct, Sec int64
pkg syscall (freebsd-arm64), type Timeval struct, Usec int64
pkg syscall (freebsd-arm64), type WaitStatus uint32
pkg syscall (freebsd-arm64), var Stderr int
pkg syscall (freebsd-arm64), var Stdin int
pkg syscall (freebsd-arm64), var Stdout int
pkg syscall (freebsd-arm64-cgo), const AF_APPLETALK = 16
pkg syscall (freebsd-arm64-cgo), const AF_APPLETALK ideal-int

pkg syscall (darwin-arm64), type Timeval32 struct, Sec int32
pkg syscall (darwin-arm64), type Timeval32 struct, Usec int32
pkg syscall (darwin-arm64), type WaitStatus uint32
pkg syscall (darwin-arm64), var Stderr int
pkg syscall (darwin-arm64), var Stdin int
pkg syscall (darwin-arm64), var Stdout int
pkg syscall (darwin-arm64-cgo), const AF_APPLETALK = 16
pkg syscall (darwin-arm64-cgo), const AF_APPLETALK ideal-int

	}

	err := decoder.Err()
	t.Logf("got error: %s", err)
	if err == nil {
		t.Fatalf("missing expected decoder error")
	}

	derr, ok := err.(DecoderError)
	if !ok {
		t.Fatalf("expected error of type DecoderError, got %T", err)
	}

	if derr.ReaderErr() == nil {
		t.Fatalf("missing expected underlying reader error")
	}
}

func TestDecoderMaxDepth(t *testing.T) {
	tests := []struct {

			// behavior.
			if err := send(metaCacheEntry{
				name:     opts.BaseDir,
				metadata: metadata,
			}); err != nil {
				return err
			}
		} else {
			st, sterr := Lstat(pathJoin(volumeDir, opts.BaseDir, xlStorageFormatFile))
			if sterr == nil && st.Mode().IsRegular() {
				return errFileNotFound
			}
		}
	}

	prefix := opts.FilterPrefix
	var scanDir func(path string) error

		return
	}

	aclHeader := r.Header.Get(xhttp.AmzACL)
	if aclHeader == "" {
		acl := &accessControlPolicy{}
		if err = xmlDecoder(r.Body, acl, r.ContentLength); err != nil {
			if terr, ok := err.(*xml.SyntaxError); ok && terr.Msg == io.EOF.Error() {
				writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrMalformedXML),
					r.URL)
				return
			}
			writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL)
			return
		}

			if errors.Is(err, BucketRemoteTargetNotFound{Bucket: t.SourceBucket}) {
				continue
			}
			return err
		}
		targets, terr := globalBucketTargetSys.ListBucketTargets(ctx, t.SourceBucket)
		if terr != nil {
			return err
		}
		tgtBytes, terr := json.Marshal(&targets)
		if terr != nil {
			return err
		}
		if _, err = globalBucketMetadataSys.Update(ctx, t.SourceBucket, bucketTargetsFile, tgtBytes); err != nil {

* s390x ingress controller support ([#52663](https://github.com/kubernetes/kubernetes/pull/52663), [@wwwtyro](https://github.com/wwwtyro))
* CRI: Add stdout/stderr fields to Exec and Attach requests. ([#52686](https://github.com/kubernetes/kubernetes/pull/52686), [@yujuhong](https://github.com/yujuhong))

			objSize = gr.ObjInfo.Size
		}

		files, err := zipindex.ReadDir(b[len(b)-size:], objSize, nil)
		if err == nil {
			return files, gr.ObjInfo, nil
		}
		var terr zipindex.ErrNeedMoreData
		if errors.As(err, &terr) {
			size = int(terr.FromEnd)
			if size <= 0 || size > 100<<20 {
				return nil, ObjectInfo{}, errors.New("zip directory too large")
			}
		} else {
			return nil, ObjectInfo{}, err
		}
	}

	if err = dErrResp.DecodeMsg(decoder); err != nil {
		for i := range errs {
			errs[i] = toStorageErr(err)
		}
		return errs
	}

	for i, dErr := range dErrResp.Errs {
		if dErr != "" {
			errs[i] = toStorageErr(errors.New(dErr))
		} else {
			errs[i] = nil
		}
	}

	return errs
}

// RenamePart - renames multipart part file