package cmd

import (
	"bytes"
	"encoding/gob"
	"io"
	"testing"
	"time"

	"github.com/tinylib/msgp/msgp"
)

func BenchmarkDecodeVolInfoMsgp(b *testing.B) {
	v := VolInfo{
		Name:    "uuid",
		Created: time.Now(),
	}
	var buf bytes.Buffer
	msgp.Encode(&buf, &v)
	rd := msgp.NewEndlessReader(buf.Bytes(), b)
	dc := msgp.NewReader(rd)

// Package amztime implements AWS specific time parsing and deviations
package amztime

import (
	"errors"
	"testing"
	"time"
)

func TestParse(t *testing.T) {
	type testCase struct {
		expectedErr  error
		expectedTime time.Time
		timeStr      string
	}
	testCases := []testCase{
		{
			ErrMalformedDate,
			time.Time{},
			"Tue Sep  6 07:10:23 PM PDT 2022",
		},

					continue
				}
				if gotFile.File != wantFile || gotFile.Bucket != req.Bucket || gotFile.Prefix != req.Prefix {
					continue
				}
				quorum++
				if toAdd.Modtime.After(gotFile.Modtime) || len(gotFile.Data) < len(toAdd.Data) {
					// Pick latest, or largest to avoid possible truncated entries.
					continue
				}
				toAdd = gotFile
			}
		}
		if quorum < readQuorum {

	Name string

	// Date and time when the bucket was created.
	Created time.Time
	Deleted time.Time

	// Bucket features enabled
	Versioning, ObjectLocking bool
}

// ObjectInfo - represents object metadata.
type ObjectInfo struct {
	// Name of the bucket.
	Bucket string

	// Name of the object.
	Name string

	// Date and time when the object was last modified.
	ModTime time.Time

type BucketStatsMap struct {
	Stats     map[string]BucketStats
	Timestamp time.Time
}

// BucketStats bucket statistics
type BucketStats struct {
	Uptime           int64                  `json:"uptime"`
	ReplicationStats BucketReplicationStats `json:"currStats"`  // current replication stats since cluster startup

		ModifiedDate:     5678,
	}
	fi := fh.FileInfo()
	fh2, err := FileInfoHeader(fi)
	if err != nil {
		t.Fatal(err)
	}
	if got, want := fh2.ModTime(), fh.ModTime(); got != want {
		t.Errorf("Modified: got %s, want %s\n", got, want)
	}
	if got, want := fi.ModTime(), fh.ModTime(); got != want {
		t.Errorf("Modified: got %s, want %s\n", got, want)
	}
}

type repeatedByte struct {
	off int64
	b   byte

	tmp := struct {
		VersionID string
		ModTime   time.Time
		Signature string
		Type      uint8
		Flags     uint8
		EcM, EcN  uint8 // Note that these will be 0/0 for non-v2 objects and older xl.meta
	}{
		VersionID: hex.EncodeToString(z.VersionID[:]),
		ModTime:   time.Unix(0, z.ModTime),
		Signature: hex.EncodeToString(z.Signature[:]),
		Type:      z.Type,

				if err != nil {
					err = msgp.WrapError(err, "Metrics", za0001)
					return
				}
				z.Metrics[za0001] = za0002
			}
		case "Uptime":
			z.Uptime, err = dc.ReadInt64()
			if err != nil {
				err = msgp.WrapError(err, "Uptime")
				return
			}
		default:
			err = dc.Skip()
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	return
}

func timeToMsDosTime(t time.Time) (fDate uint16, fTime uint16) {
	fDate = uint16(t.Day() + int(t.Month())<<5 + (t.Year()-1980)<<9)
	fTime = uint16(t.Second()/2 + t.Minute()<<5 + t.Hour()<<11)
	return
}

// ModTime returns the modification time in UTC using the legacy
// [ModifiedDate] and [ModifiedTime] fields.
//
// Deprecated: Use [Modified] instead.
func (h *FileHeader) ModTime() time.Time {

				return
			}
		case "ETag":
			z.ETag, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "ETag")
				return
			}
		case "ModTime":
			z.ModTime, err = dc.ReadTime()
			if err != nil {
				err = msgp.WrapError(err, "ModTime")
				return
			}
		case "StatusCode":
			z.StatusCode, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "StatusCode")
				return