if testing.Short() {
		t.Skip("skipping in short mode")
	}
	t.Parallel()
	const filename = "huge.txt"
	gen := func(wantOff uint64) func(*Writer) {
		return func(w *Writer) {
			w.testHookCloseSizeOffset = func(size, off uint64) {
				if off != wantOff {
					t.Errorf("central directory offset = %d (%x); want %d", off, off, wantOff)
				}
			}
			f, err := w.CreateHeader(&FileHeader{

	Size      int64
	Objects   uint64
	Versions  uint64 // Versions that are not delete markers.
	ObjSizes  sizeHistogram
	Compacted bool
}

type dataUsageEntryV7 struct {
	Children dataUsageHashMap `msg:"ch"`
	// These fields do no include any children.
	Size          int64             `msg:"sz"`
	Objects       uint64            `msg:"os"`

		return nil
	}

	q, err := sys.Get(ctx, bucket)
	if err != nil {
		return err
	}

	var quotaSize uint64
	if q != nil && q.Type == madmin.HardQuota {
		if q.Size > 0 {
			quotaSize = q.Size
		} else if q.Quota > 0 {
			quotaSize = q.Quota
		}
	}
	if quotaSize > 0 {
		if uint64(size) >= quotaSize { // check if file size already exceeds the quota
			return BucketQuotaExceeded{Bucket: bucket}
		}

	debug bool
}

type sizeSummary struct {
	totalSize       int64
	versions        uint64
	deleteMarkers   uint64
	replicatedSize  int64
	replicatedCount int64
	pendingSize     int64
	failedSize      int64
	replicaSize     int64
	replicaCount    int64
	pendingCount    uint64
	failedCount     uint64
	replTargetStats map[string]replTargetSizeSummary
	tiers           map[string]tierStats
}

	}
}

type (
	ID      int64
	INT     int
	INT8    int8
	INT16   int16
	INT32   int32
	INT64   int64
	UINT    uint
	UINT8   uint8
	UINT16  uint16
	UINT32  uint32
	UINT64  uint64
	FLOAT32 float32
	FLOAT64 float64
	BOOL    bool
	STRING  string
	TIME    time.Time
	BYTES   []byte

	TypeAlias struct {
		ID
		INT     `gorm:"column:fint"`

func reduceCommonVersions(diskVersions [][]byte, writeQuorum int) (versions []byte) {
	diskVersionsCount := make(map[uint64]int)
	for _, versions := range diskVersions {
		if len(versions) > 0 {
			diskVersionsCount[binary.BigEndian.Uint64(versions)]++
		}
	}

	var commonVersions uint64
	maxCnt := 0
	for versions, count := range diskVersionsCount {
		if maxCnt < count {
			maxCnt = count

var (
	path, name string
	value      uint64
	set, list  bool
)

func getxattr(path, name string) (uint64, error) {
	buf, err := xattr.LGet(path, name)
	if err != nil {
		return 0, err
	}

	return binary.LittleEndian.Uint64(buf[:8]), nil
}

func listxattr(path string) ([]string, error) {
	return xattr.LList(path)
}

func setxattr(path, name string, value uint64) error {
	data := make([]byte, 8)

		}
		name := filepath.ToSlash(path)
		w, err := zw.CreateRaw(&zip.FileHeader{
			Name:               name,
			Method:             zip.Store,
			CompressedSize64:   uint64(len(data)),
			UncompressedSize64: uint64(len(data)),
			CRC32:              crc32.ChecksumIEEE(data),
		})
		if err != nil {
			log.Fatal(err)
		}
		if _, err := w.Write(data); err != nil {
			log.Fatal(err)
		}

package cmd

import (
	"context"
	"time"
)

type rebalPoolProgress struct {
	NumObjects  uint64        `json:"objects"`
	NumVersions uint64        `json:"versions"`
	Bytes       uint64        `json:"bytes"`
	Bucket      string        `json:"bucket"`
	Object      string        `json:"object"`
	Elapsed     time.Duration `json:"elapsed"`

//
// The above means that any added/deleted fields are incompatible.
//
//msgp:tuple DiskInfo
type DiskInfo struct {
	Total      uint64
	Free       uint64
	Used       uint64
	UsedInodes uint64
	FreeInodes uint64
	Major      uint32
	Minor      uint32
	NRRequests uint64
	FSType     string
	RootDisk   bool
	Healing    bool
	Scanning   bool
	Endpoint   string
	MountPath  string
	ID         string