md5Bytes := md5.Sum([]byte(object.content))
			oi, err := obj.PutObject(context.Background(), testCase.bucketName, object.name, mustGetPutObjReader(t, strings.NewReader(object.content),
				int64(len(object.content)), hex.EncodeToString(md5Bytes[:]), ""), ObjectOptions{})
			if err != nil {
				t.Log(oi)
				t.Fatalf("%s : %s", instanceType, err.Error())
			}
		}

	gz, err := gzip.NewReader(bufio.NewReader(f))
	if err != nil {
		t.Fatal(err)
	}

	buf, err := io.ReadAll(gz)
	if err != nil {
		t.Fatal(err)
	}

	_, err = readXLMetaNoData(bytes.NewReader(buf), int64(len(buf)))
	if err == nil {
		t.Fatal("expected error but returned success")
	}
}

func TestXLV2FormatData(t *testing.T) {
	failOnErr := func(err error) {
		t.Helper()
		if err != nil {
			t.Fatal(err)

xlHeaderVersion version == 1:

```
//msgp:tuple xlMetaV2VersionHeader
type xlMetaV2VersionHeader struct {
 VersionID [16]byte  // Version UUID, raw.
 ModTime   int64     // Unix nanoseconds.
 Signature [4]byte   // Signature of metadata.
 Type      uint8     // Type if the version
 Flags     uint8
}
```

The following flags are defined:

```
const (

func NewStub(defaultKeyName string) *KMS {
	return &KMS{
		Type:           Builtin,
		DefaultKey:     defaultKeyName,
		latencyBuckets: defaultLatencyBuckets,
		latency:        make([]atomic.Uint64, len(defaultLatencyBuckets)),
		conn: &StubKMS{
			KeyNames: []string{defaultKeyName},
		},
	}
}

// StubKMS is a KMS implementation for tests
type StubKMS struct {
	KeyNames []string
}

	"errors"
	"fmt"
	"reflect"
	"sort"
	"strings"

	"gorm.io/gorm/clause"
	"gorm.io/gorm/logger"
	"gorm.io/gorm/schema"
)

type result struct {
	Result       sql.Result
	RowsAffected int64
}

func (info *result) ModifyStatement(stmt *Statement) {
	stmt.Result = info
}

// Build implements clause.Expression interface
func (result) Build(clause.Builder) {
}

func WithResult() *result {

	opts Opts

	// Once can be used to initialize values for lazy initialization.
	// Should be set before calling Get().
	Once sync.Once

	// Managed values.
	val          atomic.Pointer[T]
	lastUpdateMs atomic.Int64
	updating     sync.Mutex
}

// New allocates a new cached value instance. Tt must be initialized with
// `.TnitOnce`.
func New[T any]() *Cache[T] {
	return &Cache[T]{}
}

		if !c.Args().Present() {
			cli.ShowAppHelpAndExit(c, 1) // last argument is exit code
		}

		ht := make(map[string]map[string]any)
		file := c.Args().Get(0)
		if strings.HasSuffix(file, ".zip") {
			var sz int64
			f, err := os.Open(file)
			if err != nil {
				return err
			}
			if st, err := f.Stat(); err == nil {
				sz = st.Size()
			}
			defer f.Close()
			zr, err := zip.NewReader(f, sz)
			if err != nil {

		t.Fatalf("invalid results length found, expects: %v, got %v", len(expects), len(results))
	}

	for idx, expect := range expects {
		AssertObjEqual(t, results[idx], expect, "Name", "Age")
	}

	var count int64
	if err := DB.Model(&User{}).Where("name like ?", "distinct%").Count(&count).Error; err != nil || count != 5 {
		t.Errorf("failed to query users count, got error: %v, count: %v", err, count)
	}

			// ... nothing changes for compressed stream.
			// if actualSize is -1 we have no known way to
			// determine what is the actualSize.
		case encrypted:
			decSize, err := sio.DecryptedSize(uint64(n))
			if err == nil {
				actualSize = int64(decSize)
			}
		default:
			actualSize = n
		}
	}
	// If ServerSideChecksum is wanted for this object, it takes precedence
	// over opts.WantChecksum.

func parseChunkSignature(chunk []byte) []byte {
	chunkSplits := bytes.SplitN(chunk, []byte(s3ChunkSignatureStr), 2)
	return chunkSplits[1]
}

// parse hex to uint64.
func parseHexUint(v []byte) (n uint64, err error) {
	for i, b := range v {
		switch {
		case '0' <= b && b <= '9':
			b -= '0'
		case 'a' <= b && b <= 'f':
			b = b - 'a' + 10
		case 'A' <= b && b <= 'F':