doNameLookups = false
		var err error
		h.Gname, err = iface.Gname()
		if err != nil {
			return nil, err
		}
		h.Uname, err = iface.Uname()
		if err != nil {
			return nil, err
		}
	}
	if sysStat != nil {
		return h, sysStat(fi, h, doNameLookups)
	}
	return h, nil
}

// FileInfoNames extends [fs.FileInfo].

				ongoing: false,
				expiry:  time.Date(2012, 12, 21, 0, 0, 0, 0, time.UTC),
			},
			expectedErr: nil,
		},
		{
			// valid: represents an ongoing restore object request.
			restoreHdr: `ongoing-request="true"`,
			expectedStatus: restoreObjStatus{
				ongoing: true,
			},
			expectedErr: nil,
		},
		{
			// invalid; ongoing restore object request can't have expiry set on it.

		t.Fatal("Unexpected error", err)
	}
}

// Tests - renameAll()
func TestOSRenameAll(t *testing.T) {
	// create xlStorage test setup
	_, path, err := newXLStorageTestSetup(t)
	if err != nil {
		t.Fatalf("Unable to create xlStorage test setup, %s", err)
	}

	if err = mkdirAll(pathJoin(path, "testvolume1"), 0o777, ""); err != nil {
		t.Fatal(err)
	}

		if err != nil {
			if testCase.expectedErr == nil {
				t.Fatalf("test %v: error: expected = <nil>, got = %v", i+1, err)
			}
			if testCase.expectedErr.Error() != err.Error() {
				t.Fatalf("test %v: error: expected = %v, got = %v", i+1, testCase.expectedErr, err)
			}
		} else {
			if testCase.expectedErr != nil {

		go func(index int, isReadLock bool, c NetLocker) {
			defer wg.Done()

			g := Granted{index: index}
			if c == nil {
				log("dsync: nil locker\n")
				ch <- g
				return
			}

			var locked bool
			var err error
			if isReadLock {
				if locked, err = c.RLock(netLockCtx, args); err != nil {
					log("dsync: Unable to call RLock failed with %s for %#v at %s\n", err, args, c)
				}
			} else {

		Find(&personAddressInfoList).Error; err != nil {
		t.Errorf("Failed to run join query, got error: %v", err)
	}

	personMatched := false
	addressMatched := false

	for _, info := range personAddressInfoList {
		if info.Person == nil {
			t.Fatalf("Failed, expected not nil, got person nil")
		}
		if info.Address == nil {
			t.Fatalf("Failed, expected not nil, got address nil")
		}
		if info.Person.ID == person1.ID {

	var err error
	// obtains random bucket name.
	bucket := getRandomBucketName()
	// create bucket.
	err = obj.MakeBucket(context.Background(), bucket, MakeBucketOptions{})
	if err != nil {
		b.Fatal(err)
	}

	// get text data generated for number of bytes equal to object size.
	textData := generateBytesData(objSize)
	// generate md5sum for the generated data.

func (bp *BytePoolCap) Get() (b []byte) {
	if bp == nil {
		return nil
	}
	select {
	case b = <-bp.c:
		// reuse existing buffer
	default:
		// create new aligned buffer
		b = reedsolomon.AllocAligned(1, bp.wcap)[0][:bp.w]
	}
	return
}

// Put returns the given Buffer to the BytePool.
func (bp *BytePoolCap) Put(b []byte) {
	if bp == nil {
		return
	}

	if cap(b) != bp.wcap {

		Result  string
		Vars    []interface{}
	}{
		{
			[]clause.Interface{clause.Delete{}, clause.From{}},
			"DELETE FROM `users`", nil,
		},
		{
			[]clause.Interface{clause.Delete{Modifier: "LOW_PRIORITY"}, clause.From{}},
			"DELETE LOW_PRIORITY FROM `users`", nil,
		},
	}

	for idx, result := range results {
		t.Run(fmt.Sprintf("case #%v", idx), func(t *testing.T) {

	if srcFilePath == "" || dstFilePath == "" {
		return errInvalidArgument
	}

	if err = checkPathLength(srcFilePath); err != nil {
		return err
	}
	if err = checkPathLength(dstFilePath); err != nil {
		return err
	}

	if err = reliableRename(srcFilePath, dstFilePath, baseDir); err != nil {
		switch {
		case isSysErrNotDir(err) && !osIsNotExist(err):