if err != nil {
		// Failed to create object, abort.
		t.Fatalf("%s : %s", instanceType, err.Error())
	}

	for _, disk := range disks {
		tmpMetaDir := path.Join(disk, minioMetaTmpBucket)
		files, err := os.ReadDir(tmpMetaDir)
		if err != nil {
			t.Fatal(err)
		}
		var found bool
		for _, fi := range files {
			if fi.Name() == ".trash" {
				continue
			}
			found = true
		}
		if found {

	// Limit the number of returned objects if > 0.
	Limit int

	// DiskID contains the disk ID of the disk.
	// Leave empty to not check disk ID.
	DiskID string
}

// supported FS for Nlink optimization in readdir.
const (
	xfs  = "XFS"
	ext4 = "EXT4"
)

// WalkDir will traverse a directory and return all entries found.
// On success a sorted meta cache stream will be returned.
// Metadata has data stripped, if any.

			objSize, err = gr.ObjInfo.DecryptedSize()
			if err != nil {
				return nil, ObjectInfo{}, err
			}
		} else {
			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 so, we try to add it to certificate manager.
	root, err := Open(globalCertsDir.Get())
	if err != nil {
		return nil, nil, false, err
	}
	defer root.Close()

	files, err := root.Readdir(-1)
	if err != nil {
		return nil, nil, false, err
	}
	for _, file := range files {
		// Ignore all
		// - regular files
		// - "CAs" directory
		// - any directory which starts with ".."

)

// A Reader wraps an io.Reader and computes the MD5 checksum
// of the read content as ETag. Optionally, it also computes
// the SHA256 checksum of the content.
//
// If the reference values for the ETag and content SHA26
// are not empty then it will check whether the computed
// match the reference values.
type Reader struct {
	src         io.Reader
	bytesRead   int64
	expectedMin int64

				err = dc.ReadNil()
				if err != nil {
					err = msgp.WrapError(err, "Compress")
					return
				}
				z.Compress = nil
			} else {
				if z.Compress == nil {
					z.Compress = new(bool)
				}
				*z.Compress, err = dc.ReadBool()
				if err != nil {
					err = msgp.WrapError(err, "Compress")
					return
				}
			}
		case "SmallerThan":
			if dc.IsNil() {
				err = dc.ReadNil()

                    extraSidAtts[i] = new PacSidAttributes(sid, attributes[i]);
                }
            }

            // ID for resource domain (used with relative IDs to get SIDs)
            SID resourceDomainId = null;
            if (resourceDomainIdPointer != 0) {
                resourceDomainId = pacStream.readSid();
            }

			fmt.Println(args...)
		}
	}
	// Inject random reader/writer sleeps.
	const maxSleep = int(1 * time.Millisecond)
	doSleep := !testing.Short()
	rb := New(4 << 10).SetBlocking(true)

	// Reader
	var readErr error
	var wg sync.WaitGroup
	wg.Add(1)
	go func() {
		readRng := rand.New(rand.NewSource(1))
		defer wg.Done()
		defer rb.CloseWithError(readErr)
		buf := make([]byte, 1024)
		for {
			// Read

func (z *rstats) DecodeMsg(dc *msgp.Reader) (err error) {
	var zb0002 uint32
	zb0002, err = dc.ReadArrayHeader()
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	if cap((*z)) >= int(zb0002) {
		(*z) = (*z)[:zb0002]
	} else {
		(*z) = make(rstats, zb0002)
	}
	for zb0001 := range *z {
		if dc.IsNil() {
			err = dc.ReadNil()
			if err != nil {

		case "LocksAbandoned":
			z.LocksAbandoned, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "LocksAbandoned")
				return
			}
		case "LastCleanup":
			if dc.IsNil() {
				err = dc.ReadNil()
				if err != nil {
					err = msgp.WrapError(err, "LastCleanup")
					return
				}
				z.LastCleanup = nil
			} else {
				if z.LastCleanup == nil {
					z.LastCleanup = new(time.Time)
				}