for {
		count := len(objsToDel)
		if count == 0 {
			break
		}
		if count > maxDeleteList {
			count = maxDeleteList
		}
		_, errs := api.DeleteObjects(ctx, r.Bucket, objsToDel[:count], opts)
		allErrs = append(allErrs, errs...)
		// Next batch of deletion
		objsToDel = objsToDel[count:]
	}

	return allErrs
}

const (
	batchExpireName                 = "batch-expire.bin"

	deleteList := toNames(objectsToDelete)
	dObjects, errs := deleteObjectsFn(ctx, bucket, deleteList, ObjectOptions{
		PrefixEnabledFn:  vc.PrefixEnabled,
		VersionSuspended: vc.Suspended(),
	})

	// Are all objects saying bucket not found?
	if isAllBucketsNotFound(errs) {
		writeErrorResponse(ctx, w, toAPIError(ctx, errs[0]), r.URL)
		return
	}

	for i := range errs {

	}

	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 {

	connStats := globalConnStats.toServerConnStats()
	rpcStats := rest.GetRPCStats()
	if globalIsDistErasure {
		m.Set(internodeErrorsTotal, float64(rpcStats.Errs))
		m.Set(internodeDialErrorsTotal, float64(rpcStats.DialErrs))
		m.Set(internodeDialAvgTimeNanos, float64(rpcStats.DialAvgDuration))
		m.Set(internodeSentBytesTotal, float64(connStats.internodeOutputBytes))

	if write {
		quorum = writeQuorum
	}

	// List all online disks.
	_, modTime, etag := listOnlineDisks(storageDisks, partsMetadata, errs, quorum)

	if write {
		err = reduceWriteQuorumErrs(ctx, errs, objectOpIgnoredErrs, writeQuorum)
	} else {
		err = reduceReadQuorumErrs(ctx, errs, objectOpIgnoredErrs, readQuorum)
	}
	if err != nil {
		return fi, nil, err
	}

	// Pick one from the first valid metadata.

	r.errorStatus(err)
	return err
}

func (r *respBodyMonitor) errorStatus(err error) {
	if xnet.IsNetworkOrHostDown(err, r.expectTimeouts) {
		r.errorStatusOnce.Do(func() {
			atomic.AddUint64(&globalStats.errs, 1)
		})
	}
}

// dumpHTTP - dump HTTP request and response.
func (c *Client) dumpHTTP(req *http.Request, resp *http.Response) {
	// Starts http dump.

			if err != nil {
				err = msgp.WrapError(err, "Errs")
				return
			}
			if cap(z.Errs) >= int(zb0002) {
				z.Errs = (z.Errs)[:zb0002]
			} else {
				z.Errs = make([]string, zb0002)
			}
			for za0001 := range z.Errs {
				z.Errs[za0001], err = dc.ReadString()
				if err != nil {
					err = msgp.WrapError(err, "Errs", za0001)
					return
				}
			}
		default:

					return
				}
				mu.Lock()
				errs++
				mu.Unlock()
				return
			}
			mu.Lock()
			ok++
			mu.Unlock()
		}()
	}
	close(start)
	wg.Wait()
	if ok != 1 {
		t.Fatalf("want 1 ok, got %d", ok)
	}
	if errs != n-1 {
		t.Fatalf("want %d errors, got %d", n-1, errs)
	}
}

		depIDs = append(depIDs, d)
	}
	errs := make([]error, len(c.state.Peers))
	var wg sync.WaitGroup
	wg.Add(len(depIDs))
	for i := range depIDs {
		go func(i int) {
			defer wg.Done()
			if depIDs[i] == globalDeploymentID() {
				if selfActionFn != nil {
					errs[i] = selfActionFn()
				}
			} else {
				errs[i] = peerActionFn(depIDs[i], c.state.Peers[depIDs[i]])
			}

					},
				}
				err = tgt.RemoveObjectTagging(ctx, tgt.Bucket, object, dopts)
			}
			if err != nil {
				errs[idx] = err
			}
		}(idx, tgt)
	}
	wg.Wait()

	var (
		terr        error
		taggedCount int
	)
	for _, err := range errs {
		if err == nil {
			taggedCount++
			continue
		}
		if err != nil {
			terr = err
		}
	}