return t.setTB(tb, errorMessage)
}

// SetFatalTB will set the logger to output to tb.Panic.
// Call the returned function to disable logging.
func (t *testLogger) SetFatalTB(tb testing.TB) func() {
	return t.setTB(tb, fatalMessage)
}

func (t *testLogger) setTB(tb testing.TB, action int32) func() {
	old := t.action.Swap(action)
	t.current.Store(&tb)
	return func() {
		t.current.Store(nil)

					return
				}
				err = za0002.DecodeMsg(dc)
				if err != nil {
					err = msgp.WrapError(err, "BucketStatuses", za0001)
					return
				}
				z.BucketStatuses[za0001] = za0002
			}
		case "tb":
			z.TotBuckets, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "TotBuckets")
				return
			}
		case "cst":
			err = z.TargetReplicationResyncStatus.DecodeMsg(dc)
			if err != nil {

// Returns an initialized setup for erasure tests.
func newErasureTestSetup(tb testing.TB, dataBlocks int, parityBlocks int, blockSize int64) (*erasureTestSetup, error) {
	diskPaths := make([]string, dataBlocks+parityBlocks)
	disks := make([]StorageAPI, len(diskPaths))
	var err error
	for i := range diskPaths {
		disks[i], diskPaths[i], err = newXLStorageTestSetup(tb)
		if err != nil {
			return nil, err
		}

func loadMetacacheSample(t testing.TB) *metacacheReader {
	b, err := os.ReadFile("testdata/metacache.s2")
	if err != nil {
		t.Fatal(err)
	}
	return newMetacacheReader(bytes.NewReader(b))
}

func loadMetacacheSampleEntries(t testing.TB) metaCacheEntriesSorted {
	r := loadMetacacheSample(t)
	defer r.Close()

¦EcDistœ ¨CSumAlgo ¨PartNums‘ ©PartETagsÀ©PartSizes‘Ñ iªPartASizes‘Ñ i¤SizeÑ i¥MTimeÓ É Ñ©XȧMetaSys ¼x-minio-internal-inline-dataÄ true§MetaUsr‚¤etagÙ 929f74acf4e3cc5de554¬content-type¸application/octet-stream¡v Î ñ ¤nullć VBŽ¤ šPsYUûàwÄ)â ´PÀ•èŸ‹Ç “]Tb€ Þ ¤Name¦bucket§CreatedÇ f*½‚!ê’H«LockEnabled°PolicyConfigJSONÄ µNotificationConfigXMÄ ²Life multisitea/data/disterasure/xl1/.minio.sys/buckets/bucket/.usage-cache.bin.bkp/xl.meta XL2 Æ } Ä$•Ä Ó É žÕô Ä ö / Å Qƒ¤Type ¥V2ObjÞ ¢IDÄ ¤DDirÄ emJ½¥ºI œú\¨U¯...

		}
		t.Log("Roundtrip:", time.Since(start))
	})
}

func TestSingleRoundtripNotReady(t *testing.T) {
	defer testlogger.T.SetLogTB(t)()
	errFatal := func(t testing.TB, err error) {
		t.Helper()
		if err != nil {
			t.Fatal(err)
		}
	}
	grid, err := SetupTestGrid(2)
	errFatal(t, err)
	remoteHost := grid.Hosts[1]
	local := grid.Managers[0]

	// 1: Echo

func (o *ObjectInfo) EncryptedSize() int64 {
	size, err := sio.EncryptedSize(uint64(o.Size))
	if err != nil {
		// This cannot happen since AWS S3 allows parts to be 5GB at most
		// sio max. size is 256 TB
		reqInfo := (&logger.ReqInfo{}).AppendTags("size", strconv.FormatUint(size, 10))
		ctx := logger.SetReqInfo(GlobalContext, reqInfo)
		logger.CriticalIf(ctx, err)
	}
	return int64(size)
}

// Using this interface, functionalities to be used in tests can be
// made generalized, and can be integrated in benchmarks/unit tests/go check suite tests.
type TestErrHandler interface {
	testing.TB
}

const (
	// ErasureSDStr is the string which is used as notation for Single node ObjectLayer in the unit tests.
	ErasureSDStr string = "ErasureSD"

			}
		}
		if should < 10 {
			t.Errorf("host %q only connects to %d hosts", hosts[x], should)
		}
		t.Logf("host %q should connect to %d hosts", hosts[x], should)
	}
}

func startServer(t testing.TB, listener net.Listener, handler http.Handler) (server *httptest.Server) {
	t.Helper()
	server = httptest.NewUnstartedServer(handler)
	server.Config.Addr = listener.Addr().String()
	server.Listener = listener

	BucketStatuses                map[string]ResyncStatusType `json:"buckets" msg:"bkts"`
	TotBuckets                    int                         `json:"totbuckets" msg:"tb"`
	TargetReplicationResyncStatus `json:"currSt" msg:"cst"`
}

func (s *SiteResyncStatus) clone() SiteResyncStatus {
	if s == nil {
		return SiteResyncStatus{}
	}
	o := *s