b.Fatal(err)
		}
	}
}

func TestEncodeDecodeBaseOptions(t *testing.T) {
	v := BaseOptions{}
	var buf bytes.Buffer
	msgp.Encode(&buf, &v)

	m := v.Msgsize()
	if buf.Len() > m {
		t.Log("WARNING: TestEncodeDecodeBaseOptions Msgsize() is inaccurate")
	}

	vn := BaseOptions{}
	err := msgp.Decode(&buf, &vn)
	if err != nil {
		t.Error(err)
	}

	buf.Reset()
	msgp.Encode(&buf, &v)

		}
	}
	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *dataUsageCache) Msgsize() (s int) {
	s = 1 + 5 + z.Info.Msgsize() + 6 + msgp.MapHeaderSize
	if z.Cache != nil {
		for za0001, za0002 := range z.Cache {
			_ = za0002
			s += msgp.StringPrefixSize + len(za0001) + za0002.Msgsize()
		}
	}
	return
}

			}
		}
	}
	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *BucketReplicationStat) Msgsize() (s int) {
	s = 1 + 15 + msgp.Int64Size + 12 + msgp.Int64Size + 10 + z.FailStats.Msgsize() + 7 + z.Failed.Msgsize() + 16 + msgp.Int64Size + 8 + 1 + 16 + z.Latency.UploadHistogram.Msgsize() + 31 + msgp.Int64Size + 34 + msgp.Float64Size + 3

len(z.UserTags) + 5 + msgp.BoolSize + 18 + z.ReplicationStatus.Msgsize() + 26 + msgp.StringPrefixSize + len(z.ReplicationStatusInternal) + 27 + msgp.StringPrefixSize + len(z.VersionPurgeStatusInternal) + 19 + z.VersionPurgeStatus.Msgsize() + 17 + z.ReplicationState.Msgsize() + 13 + msgp.BoolSize + 7 + z.OpType.Msgsize() + 10 + msgp.StringPrefixSize + len(z.EventType) + 11 + msgp.Uint32Size + 8 + msgp.StringPrefixSize + len(z.ResetID) + 4 + z.Dsc.Msgsize() + 18 + z.ExistingObjResync.Msgsize() + 10 + msgp.StringPrefixSize...

	}
	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *BucketReplicationResyncStatus) Msgsize() (s int) {
	s = 1 + 2 + msgp.IntSize + 4 + msgp.MapHeaderSize
	if z.TargetsMap != nil {
		for za0001, za0002 := range z.TargetsMap {
			_ = za0002
			s += msgp.StringPrefixSize + len(za0001) + za0002.Msgsize()
		}
	}

			z.DeleteMarker = nil
		}
	}
	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *xlMetaV2Version) Msgsize() (s int) {
	s = 1 + 5 + msgp.Uint8Size + 6
	if z.ObjectV1 == nil {
		s += msgp.NilSize
	} else {
		s += z.ObjectV1.Msgsize()
	}
	s += 6
	if z.ObjectV2 == nil {
		s += msgp.NilSize
	} else {

        final int maximumBufferSize = getContext().getConfig().getMaximumBufferSize();
        final int msgSize = nextCommand != 0 ? nextCommand : size;
        if (msgSize > maximumBufferSize) {
            throw new IOException(String.format("Message size %d exceeds maxiumum buffer size %d", msgSize, maximumBufferSize));
        }

        ServerMessageBlock2Response cur = (ServerMessageBlock2Response) response;

            }

            final StringBuilder buf = new StringBuilder(255);
            buf.append("\"record_count\":").append(docIdList.size());
            buf.append(", \"data\":[");
            if (!docIdList.isEmpty()) {
                for (int i = 0; i < docIdList.size(); i++) {
                    if (i > 0) {
                        buf.append(',');
                    }

      return null;
    }
    return entry.getValue();
  }

  @SuppressWarnings("unchecked")
  final Segment<K, V, E, S>[] newSegmentArray(int ssize) {
    return (Segment<K, V, E, S>[]) new Segment<?, ?, ?, ?>[ssize];
  }

  // Inner Classes

  /**
   * Segments are specialized versions of hash tables. This subclass inherits from ReentrantLock

		if err != nil {
			return err
		}
		pReader := NewPutObjReader(hr)
		opts.PreserveETag = ""
		pInfo, err = api.PutObjectPart(ctx, tgtBucket, tgtObject, res.UploadID, i+1, pReader, opts)
		if err != nil {
			return err
		}
		if pInfo.Size != objInfo.Size {
			return fmt.Errorf("Part size mismatch: got %d, want %d", pInfo.Size, objInfo.Size)