if pet.Toy.Name != "" {
				t.Errorf("No toy should for user %v's pet %v but got %v", idx+1, pet.Name, pet.Toy.Name)
			}
		}
	}

	if len(users2[2].Pets) != 3 {
		t.Errorf("Invalid pet toys found for user 3 got %v", len(users2[2].Pets))
	} else {
		sort.Slice(users2[2].Pets, func(i, j int) bool {
			return users2[2].Pets[i].ID < users2[2].Pets[j].ID
		})

func (z *LockArgs) Msgsize() (s int) {
	s = 1 + 4 + msgp.StringPrefixSize + len(z.UID) + 10 + msgp.ArrayHeaderSize
	for za0001 := range z.Resources {
		s += msgp.StringPrefixSize + len(z.Resources[za0001])
	}
	s += 6 + msgp.StringPrefixSize + len(z.Owner) + 7 + msgp.StringPrefixSize + len(z.Source) + 7
	if z.Quorum == nil {
		s += msgp.NilSize
	} else {
		s += msgp.IntSize
	}
	return

		obj := ObjectOpts{
			Name:        "obj",
			VersionID:   verIDs[i],
			ModTime:     curModTime.Add(time.Duration(-i) * time.Second),
			UserTags:    fmt.Sprintf("%s=minio", tagKeys[i]),
			NumVersions: len(verIDs),
		}
		if i == 0 {
			obj.IsLatest = true
		} else {
			obj.SuccessorModTime = curModTime.Add(time.Duration(-i+1) * time.Second)
		}
		objs = append(objs, obj)
	}

	// default:
	// 	return Errorf("unsupported MFADelete state %s", v.MFADelete)
	// }
	switch v.Status {
	case Enabled:
		const maxExcludedPrefixes = 10
		if len(v.ExcludedPrefixes) > maxExcludedPrefixes {
			return errTooManyExcludedPrefixes
		}

	case Suspended:
		if len(v.ExcludedPrefixes) > 0 {
			return errExcludedPrefixNotSupported
		}
	default:
		return Errorf("unsupported Versioning status %s", v.Status)
	}
	return nil

	}
	r.Close()

	if g := uint64(b.Len()); g != size {
		t.Errorf("%v: read %v bytes but f.UncompressedSize == %v", f.Name, g, size)
	}

	var c []byte
	if ft.Content != nil {
		c = ft.Content
	} else if c, err = os.ReadFile("testdata/" + ft.File); err != nil {
		t.Error(err)
		return
	}

	if b.Len() != len(c) {
		t.Errorf("%s: len=%d, want %d", f.Name, b.Len(), len(c))
		return
	}

	data.IsTruncated = isTruncated

	commonPrefixes := make([]CommonPrefix, 0, len(prefixes))
	for _, prefix := range prefixes {
		prefixItem := CommonPrefix{}
		prefixItem.Prefix = s3EncodeName(prefix, encodingType)
		commonPrefixes = append(commonPrefixes, prefixItem)
	}
	data.CommonPrefixes = commonPrefixes
	data.KeyCount = len(data.Contents) + len(data.CommonPrefixes)
	return data
}

				delete(mustFindInPolicy, k)
				break
			}
		}
	}

	// Check mustFindInPolicy to see if any key is left, if so, it was not found in policy and we return an error.
	if len(mustFindInPolicy) != 0 {
		logKeys := make([]string, 0, len(mustFindInPolicy))
		for key := range mustFindInPolicy {
			logKeys = append(logKeys, key)
		}

							h.Name(),
						)
						h.failedMessages.Add(1)
						continue
					}
				} else {
					entries = append(entries, entry)
				}
				count++
			}

			if len(h.logCh) > 0 || len(globalBuffer) > 0 || count == 0 {
				// there is something in the log queue
				// process it first, even if we tickered
				// first, or we have not received any events
				// yet, still wait on it.

	}

	if parentUser == "" {
		return auth.Credentials{}, time.Time{}, errInvalidArgument
	}

	if len(opts.accessKey) > 0 && len(opts.secretKey) == 0 {
		return auth.Credentials{}, time.Time{}, auth.ErrNoSecretKeyWithAccessKey
	}
	if len(opts.secretKey) > 0 && len(opts.accessKey) == 0 {
		return auth.Credentials{}, time.Time{}, auth.ErrNoAccessKeyWithSecretKey
	}

	var policyBuf []byte

	entry.ReqClaims = reqClaims
	entry.ReqHost = r.Host
	entry.ReqPath = r.URL.Path

	q := r.URL.Query()
	reqQuery := make(map[string]string, len(q))
	for k, v := range q {
		reqQuery[k] = strings.Join(v, ",")
	}
	entry.ReqQuery = reqQuery

	reqHeader := make(map[string]string, len(r.Header))
	for k, v := range r.Header {
		reqHeader[k] = strings.Join(v, ",")
	}
	entry.ReqHeader = reqHeader

	wh := w.Header()