}

	for testIdx, testCase := range testCases {
		listener, listenErrs := newHTTPListener(t.Context(),
			testCase.serverAddrs,
			TCPOptions{},
		)
		for i, expectedListenErr := range testCase.expectedListenErrs {
			if !expectedListenErr {
				if listenErrs[i] != nil {

		Tiers: make(map[string]tierStats),
	}
}

func (ats *allTierStats) addSizes(tiers map[string]tierStats) {
	for tier, st := range tiers {
		ats.Tiers[tier] = ats.Tiers[tier].add(st)
	}
}

func (ats *allTierStats) merge(other *allTierStats) {
	for tier, st := range other.Tiers {
		ats.Tiers[tier] = ats.Tiers[tier].add(st)
	}
}

func (ats *allTierStats) clone() *allTierStats {
	if ats == nil {

				"BETWEEN_10_MB_AND_64_MB":  1,
			},
		},
	}
	for i, test := range tests {
		t.Run(fmt.Sprintf("Test-%d", i), func(t *testing.T) {
			var h sizeHistogram
			for _, sz := range test.sizes {
				h.add(sz)
			}
			got := h.toMap()
			exp := test.want
			// what is in exp is in got
			for k := range exp {
				if exp[k] != got[k] {

func (c *CoreDNS) List() (map[string][]SrvRecord, error) {
	srvRecords := map[string][]SrvRecord{}
	for _, domainName := range c.domainNames {
		key := msgPath(fmt.Sprintf("%s.", domainName), c.prefixPath)
		records, err := c.list(key+etcdPathSeparator, true)
		if err != nil {
			return srvRecords, err
		}
		for _, record := range records {
			if record.Key == "" {
				continue
			}

  /** Converts a Range to a GeneralRange. */
  @SuppressWarnings("rawtypes") // https://github.com/google/guava/issues/989
  static <T extends Comparable> GeneralRange<T> from(Range<T> range) {
    T lowerEndpoint = range.hasLowerBound() ? range.lowerEndpoint() : null;
    BoundType lowerBoundType = range.hasLowerBound() ? range.lowerBoundType() : OPEN;

    T upperEndpoint = range.hasUpperBound() ? range.upperEndpoint() : null;

	t.Run("CheckSchema/"+s.Name, func(t *testing.T) {
		tests.AssertObjEqual(t, s, v, "Name", "Table")

		for idx, field := range primaryFields {
			var found bool
			for _, f := range s.PrimaryFields {
				if f.Name == field {
					found = true
				}
			}

			if idx == 0 {
				if field != s.PrioritizedPrimaryField.Name {

func (z *erasureServerPools) GetDisksID(ids ...string) []StorageAPI {
	idMap := make(map[string]struct{}, len(ids))
	for _, id := range ids {
		idMap[id] = struct{}{}
	}
	res := make([]StorageAPI, 0, len(idMap))
	for _, s := range z.serverPools {
		for _, set := range s.sets {
			for _, disk := range set.getDisks() {
				if disk == OfflineDisk {
					continue
				}
				if id, _ := disk.GetDiskID(); id != "" {

	o = msgp.AppendArrayHeader(o, uint32(len(z.CmdLines)))
	for za0001 := range z.CmdLines {
		o = msgp.AppendString(o, z.CmdLines[za0001])
	}
	// string "MinioEnv"
	o = append(o, 0xa8, 0x4d, 0x69, 0x6e, 0x69, 0x6f, 0x45, 0x6e, 0x76)
	o = msgp.AppendMapHeader(o, uint32(len(z.MinioEnv)))
	for za0002, za0003 := range z.MinioEnv {
		o = msgp.AppendString(o, za0002)
		o = msgp.AppendString(o, za0003)
	}

	},
}

func TestEncryptRequest(t *testing.T) {
	defer func(flag bool) { globalIsTLS = flag }(globalIsTLS)
	globalIsTLS = true
	for i, test := range encryptRequestTests {
		content := bytes.NewReader(make([]byte, 64))
		req := &http.Request{Header: http.Header{}}
		for k, v := range test.header {
			req.Header.Set(k, v)
		}
		_, _, err := EncryptRequest(content, req, "bucket", "object", test.metadata)
		if err != nil {

	newFormats := make([][]*formatErasureV3, setCount)
	for i := range refFormat.Erasure.Sets {
		newFormats[i] = make([]*formatErasureV3, setDriveCount)
	}
	currentDisksInfo := make([][]DiskInfo, setCount)
	for i := range refFormat.Erasure.Sets {
		currentDisksInfo[i] = make([]DiskInfo, setDriveCount)
	}
	for i := range refFormat.Erasure.Sets {
		for j := range refFormat.Erasure.Sets[i] {