encodedSuccessResponse0 := encodeResponse(successResponse0)

	successRequest1 := encodeResponse(requestList[1])

	deletedObjects = make([]DeletedObject, len(requestList[1].Objects))
	for i := range requestList[1].Objects {
		var vid string
		if isDirObject(requestList[0].Objects[i].ObjectName) {
			vid = ""
		}
		deletedObjects[i] = DeletedObject{

	}
	return listMultipartUploadsResponse
}

// generate multi objects delete response.
func generateMultiDeleteResponse(quiet bool, deletedObjects []DeletedObject, errs []DeleteError) DeleteObjectsResponse {
	deleteResp := DeleteObjectsResponse{}
	if !quiet {
		deleteResp.DeletedObjects = deletedObjects
	}
	deleteResp.Errors = errs
	return deleteResp
}

				deleteResult.delInfo.VersionID = ""
			}
			deletedObjects = append(deletedObjects, deleteResult.delInfo)
		}
	}

	response := generateMultiDeleteResponse(deleteObjectsReq.Quiet, deletedObjects, deleteErrors)
	encodedSuccessResponse := encodeResponse(response)

	// Write success response.
	writeSuccessResponseXML(w, encodedSuccessResponse)
	for _, dobj := range deletedObjects {
		if dobj.ObjectName == "" {
			continue

					return
				}
				orgIndexes := origIndexMap[idx]
				deletedObjects, errs := pool.DeleteObjects(ctx, bucket, objs, opts)
				mu.Lock()
				for i, derr := range errs {
					if derr != nil {
						derrs[orgIndexes[i]] = derr
					}
					deletedObjects[i].ObjectName = decodeDirObject(deletedObjects[i].ObjectName)
					dobjects[orgIndexes[i]] = deletedObjects[i]
				}
				mu.Unlock()
			}(idx, pool)
		}

	delRespBytes, err = io.ReadAll(response.Body)
	c.Assert(err, nil)
	err = xml.Unmarshal(delRespBytes, &deleteResp)
	c.Assert(err, nil)
	c.Assert(len(deleteResp.DeletedObjects), len(delObjReq.Objects))
	for i := 0; i < 10; i++ {
		c.Assert(deleteResp.DeletedObjects[i], DeletedObject{
			ObjectName: delObjReq.Objects[i].ObjectName,
			VersionID:  delObjReq.Objects[i].VersionID,
		})
	}
	c.Assert(len(deleteResp.Errors), 0)
}