2021-04-18 21:41:13 +02:00
|
|
|
// Copyright (c) 2015-2021 MinIO, Inc.
|
|
|
|
//
|
|
|
|
// This file is part of MinIO Object Storage stack
|
|
|
|
//
|
|
|
|
// This program is free software: you can redistribute it and/or modify
|
|
|
|
// it under the terms of the GNU Affero General Public License as published by
|
|
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
|
|
// (at your option) any later version.
|
|
|
|
//
|
|
|
|
// This program is distributed in the hope that it will be useful
|
|
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
// GNU Affero General Public License for more details.
|
|
|
|
//
|
|
|
|
// You should have received a copy of the GNU Affero General Public License
|
|
|
|
// along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
|
2020-11-03 02:07:52 +01:00
|
|
|
package cmd
|
|
|
|
|
|
|
|
// Code generated by github.com/tinylib/msgp DO NOT EDIT.
|
|
|
|
|
|
|
|
import (
|
|
|
|
"bytes"
|
|
|
|
"testing"
|
|
|
|
|
|
|
|
"github.com/tinylib/msgp/msgp"
|
|
|
|
)
|
|
|
|
|
2020-11-04 19:10:54 +01:00
|
|
|
func TestMarshalUnmarshalDiskInfo(t *testing.T) {
|
|
|
|
v := DiskInfo{}
|
|
|
|
bts, err := v.MarshalMsg(nil)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
left, err := v.UnmarshalMsg(bts)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
if len(left) > 0 {
|
|
|
|
t.Errorf("%d bytes left over after UnmarshalMsg(): %q", len(left), left)
|
|
|
|
}
|
|
|
|
|
|
|
|
left, err = msgp.Skip(bts)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
if len(left) > 0 {
|
|
|
|
t.Errorf("%d bytes left over after Skip(): %q", len(left), left)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func BenchmarkMarshalMsgDiskInfo(b *testing.B) {
|
|
|
|
v := DiskInfo{}
|
|
|
|
b.ReportAllocs()
|
|
|
|
b.ResetTimer()
|
|
|
|
for i := 0; i < b.N; i++ {
|
|
|
|
v.MarshalMsg(nil)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func BenchmarkAppendMsgDiskInfo(b *testing.B) {
|
|
|
|
v := DiskInfo{}
|
|
|
|
bts := make([]byte, 0, v.Msgsize())
|
|
|
|
bts, _ = v.MarshalMsg(bts[0:0])
|
|
|
|
b.SetBytes(int64(len(bts)))
|
|
|
|
b.ReportAllocs()
|
|
|
|
b.ResetTimer()
|
|
|
|
for i := 0; i < b.N; i++ {
|
|
|
|
bts, _ = v.MarshalMsg(bts[0:0])
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func BenchmarkUnmarshalDiskInfo(b *testing.B) {
|
|
|
|
v := DiskInfo{}
|
|
|
|
bts, _ := v.MarshalMsg(nil)
|
|
|
|
b.ReportAllocs()
|
|
|
|
b.SetBytes(int64(len(bts)))
|
|
|
|
b.ResetTimer()
|
|
|
|
for i := 0; i < b.N; i++ {
|
|
|
|
_, err := v.UnmarshalMsg(bts)
|
|
|
|
if err != nil {
|
|
|
|
b.Fatal(err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestEncodeDecodeDiskInfo(t *testing.T) {
|
|
|
|
v := DiskInfo{}
|
|
|
|
var buf bytes.Buffer
|
|
|
|
msgp.Encode(&buf, &v)
|
|
|
|
|
|
|
|
m := v.Msgsize()
|
|
|
|
if buf.Len() > m {
|
|
|
|
t.Log("WARNING: TestEncodeDecodeDiskInfo Msgsize() is inaccurate")
|
|
|
|
}
|
|
|
|
|
|
|
|
vn := DiskInfo{}
|
|
|
|
err := msgp.Decode(&buf, &vn)
|
|
|
|
if err != nil {
|
|
|
|
t.Error(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
buf.Reset()
|
|
|
|
msgp.Encode(&buf, &v)
|
|
|
|
err = msgp.NewReader(&buf).Skip()
|
|
|
|
if err != nil {
|
|
|
|
t.Error(err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func BenchmarkEncodeDiskInfo(b *testing.B) {
|
|
|
|
v := DiskInfo{}
|
|
|
|
var buf bytes.Buffer
|
|
|
|
msgp.Encode(&buf, &v)
|
|
|
|
b.SetBytes(int64(buf.Len()))
|
|
|
|
en := msgp.NewWriter(msgp.Nowhere)
|
|
|
|
b.ReportAllocs()
|
|
|
|
b.ResetTimer()
|
|
|
|
for i := 0; i < b.N; i++ {
|
|
|
|
v.EncodeMsg(en)
|
|
|
|
}
|
|
|
|
en.Flush()
|
|
|
|
}
|
|
|
|
|
|
|
|
func BenchmarkDecodeDiskInfo(b *testing.B) {
|
|
|
|
v := DiskInfo{}
|
|
|
|
var buf bytes.Buffer
|
|
|
|
msgp.Encode(&buf, &v)
|
|
|
|
b.SetBytes(int64(buf.Len()))
|
|
|
|
rd := msgp.NewEndlessReader(buf.Bytes(), b)
|
|
|
|
dc := msgp.NewReader(rd)
|
|
|
|
b.ReportAllocs()
|
|
|
|
b.ResetTimer()
|
|
|
|
for i := 0; i < b.N; i++ {
|
|
|
|
err := v.DecodeMsg(dc)
|
2021-03-17 04:06:57 +01:00
|
|
|
if err != nil {
|
|
|
|
b.Fatal(err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestMarshalUnmarshalDiskMetrics(t *testing.T) {
|
|
|
|
v := DiskMetrics{}
|
|
|
|
bts, err := v.MarshalMsg(nil)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
left, err := v.UnmarshalMsg(bts)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
if len(left) > 0 {
|
|
|
|
t.Errorf("%d bytes left over after UnmarshalMsg(): %q", len(left), left)
|
|
|
|
}
|
|
|
|
|
|
|
|
left, err = msgp.Skip(bts)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
if len(left) > 0 {
|
|
|
|
t.Errorf("%d bytes left over after Skip(): %q", len(left), left)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func BenchmarkMarshalMsgDiskMetrics(b *testing.B) {
|
|
|
|
v := DiskMetrics{}
|
|
|
|
b.ReportAllocs()
|
|
|
|
b.ResetTimer()
|
|
|
|
for i := 0; i < b.N; i++ {
|
|
|
|
v.MarshalMsg(nil)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func BenchmarkAppendMsgDiskMetrics(b *testing.B) {
|
|
|
|
v := DiskMetrics{}
|
|
|
|
bts := make([]byte, 0, v.Msgsize())
|
|
|
|
bts, _ = v.MarshalMsg(bts[0:0])
|
|
|
|
b.SetBytes(int64(len(bts)))
|
|
|
|
b.ReportAllocs()
|
|
|
|
b.ResetTimer()
|
|
|
|
for i := 0; i < b.N; i++ {
|
|
|
|
bts, _ = v.MarshalMsg(bts[0:0])
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func BenchmarkUnmarshalDiskMetrics(b *testing.B) {
|
|
|
|
v := DiskMetrics{}
|
|
|
|
bts, _ := v.MarshalMsg(nil)
|
|
|
|
b.ReportAllocs()
|
|
|
|
b.SetBytes(int64(len(bts)))
|
|
|
|
b.ResetTimer()
|
|
|
|
for i := 0; i < b.N; i++ {
|
|
|
|
_, err := v.UnmarshalMsg(bts)
|
|
|
|
if err != nil {
|
|
|
|
b.Fatal(err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestEncodeDecodeDiskMetrics(t *testing.T) {
|
|
|
|
v := DiskMetrics{}
|
|
|
|
var buf bytes.Buffer
|
|
|
|
msgp.Encode(&buf, &v)
|
|
|
|
|
|
|
|
m := v.Msgsize()
|
|
|
|
if buf.Len() > m {
|
|
|
|
t.Log("WARNING: TestEncodeDecodeDiskMetrics Msgsize() is inaccurate")
|
|
|
|
}
|
|
|
|
|
|
|
|
vn := DiskMetrics{}
|
|
|
|
err := msgp.Decode(&buf, &vn)
|
|
|
|
if err != nil {
|
|
|
|
t.Error(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
buf.Reset()
|
|
|
|
msgp.Encode(&buf, &v)
|
|
|
|
err = msgp.NewReader(&buf).Skip()
|
|
|
|
if err != nil {
|
|
|
|
t.Error(err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func BenchmarkEncodeDiskMetrics(b *testing.B) {
|
|
|
|
v := DiskMetrics{}
|
|
|
|
var buf bytes.Buffer
|
|
|
|
msgp.Encode(&buf, &v)
|
|
|
|
b.SetBytes(int64(buf.Len()))
|
|
|
|
en := msgp.NewWriter(msgp.Nowhere)
|
|
|
|
b.ReportAllocs()
|
|
|
|
b.ResetTimer()
|
|
|
|
for i := 0; i < b.N; i++ {
|
|
|
|
v.EncodeMsg(en)
|
|
|
|
}
|
|
|
|
en.Flush()
|
|
|
|
}
|
|
|
|
|
|
|
|
func BenchmarkDecodeDiskMetrics(b *testing.B) {
|
|
|
|
v := DiskMetrics{}
|
|
|
|
var buf bytes.Buffer
|
|
|
|
msgp.Encode(&buf, &v)
|
|
|
|
b.SetBytes(int64(buf.Len()))
|
|
|
|
rd := msgp.NewEndlessReader(buf.Bytes(), b)
|
|
|
|
dc := msgp.NewReader(rd)
|
|
|
|
b.ReportAllocs()
|
|
|
|
b.ResetTimer()
|
|
|
|
for i := 0; i < b.N; i++ {
|
|
|
|
err := v.DecodeMsg(dc)
|
2020-11-04 19:10:54 +01:00
|
|
|
if err != nil {
|
|
|
|
b.Fatal(err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-11-03 02:07:52 +01:00
|
|
|
func TestMarshalUnmarshalFileInfo(t *testing.T) {
|
|
|
|
v := FileInfo{}
|
|
|
|
bts, err := v.MarshalMsg(nil)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
left, err := v.UnmarshalMsg(bts)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
if len(left) > 0 {
|
|
|
|
t.Errorf("%d bytes left over after UnmarshalMsg(): %q", len(left), left)
|
|
|
|
}
|
|
|
|
|
|
|
|
left, err = msgp.Skip(bts)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
if len(left) > 0 {
|
|
|
|
t.Errorf("%d bytes left over after Skip(): %q", len(left), left)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func BenchmarkMarshalMsgFileInfo(b *testing.B) {
|
|
|
|
v := FileInfo{}
|
|
|
|
b.ReportAllocs()
|
|
|
|
b.ResetTimer()
|
|
|
|
for i := 0; i < b.N; i++ {
|
|
|
|
v.MarshalMsg(nil)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func BenchmarkAppendMsgFileInfo(b *testing.B) {
|
|
|
|
v := FileInfo{}
|
|
|
|
bts := make([]byte, 0, v.Msgsize())
|
|
|
|
bts, _ = v.MarshalMsg(bts[0:0])
|
|
|
|
b.SetBytes(int64(len(bts)))
|
|
|
|
b.ReportAllocs()
|
|
|
|
b.ResetTimer()
|
|
|
|
for i := 0; i < b.N; i++ {
|
|
|
|
bts, _ = v.MarshalMsg(bts[0:0])
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func BenchmarkUnmarshalFileInfo(b *testing.B) {
|
|
|
|
v := FileInfo{}
|
|
|
|
bts, _ := v.MarshalMsg(nil)
|
|
|
|
b.ReportAllocs()
|
|
|
|
b.SetBytes(int64(len(bts)))
|
|
|
|
b.ResetTimer()
|
|
|
|
for i := 0; i < b.N; i++ {
|
|
|
|
_, err := v.UnmarshalMsg(bts)
|
|
|
|
if err != nil {
|
|
|
|
b.Fatal(err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestEncodeDecodeFileInfo(t *testing.T) {
|
|
|
|
v := FileInfo{}
|
|
|
|
var buf bytes.Buffer
|
|
|
|
msgp.Encode(&buf, &v)
|
|
|
|
|
|
|
|
m := v.Msgsize()
|
|
|
|
if buf.Len() > m {
|
|
|
|
t.Log("WARNING: TestEncodeDecodeFileInfo Msgsize() is inaccurate")
|
|
|
|
}
|
|
|
|
|
|
|
|
vn := FileInfo{}
|
|
|
|
err := msgp.Decode(&buf, &vn)
|
|
|
|
if err != nil {
|
|
|
|
t.Error(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
buf.Reset()
|
|
|
|
msgp.Encode(&buf, &v)
|
|
|
|
err = msgp.NewReader(&buf).Skip()
|
|
|
|
if err != nil {
|
|
|
|
t.Error(err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func BenchmarkEncodeFileInfo(b *testing.B) {
|
|
|
|
v := FileInfo{}
|
|
|
|
var buf bytes.Buffer
|
|
|
|
msgp.Encode(&buf, &v)
|
|
|
|
b.SetBytes(int64(buf.Len()))
|
|
|
|
en := msgp.NewWriter(msgp.Nowhere)
|
|
|
|
b.ReportAllocs()
|
|
|
|
b.ResetTimer()
|
|
|
|
for i := 0; i < b.N; i++ {
|
|
|
|
v.EncodeMsg(en)
|
|
|
|
}
|
|
|
|
en.Flush()
|
|
|
|
}
|
|
|
|
|
|
|
|
func BenchmarkDecodeFileInfo(b *testing.B) {
|
|
|
|
v := FileInfo{}
|
|
|
|
var buf bytes.Buffer
|
|
|
|
msgp.Encode(&buf, &v)
|
|
|
|
b.SetBytes(int64(buf.Len()))
|
|
|
|
rd := msgp.NewEndlessReader(buf.Bytes(), b)
|
|
|
|
dc := msgp.NewReader(rd)
|
|
|
|
b.ReportAllocs()
|
|
|
|
b.ResetTimer()
|
|
|
|
for i := 0; i < b.N; i++ {
|
|
|
|
err := v.DecodeMsg(dc)
|
|
|
|
if err != nil {
|
|
|
|
b.Fatal(err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestMarshalUnmarshalFileInfoVersions(t *testing.T) {
|
|
|
|
v := FileInfoVersions{}
|
|
|
|
bts, err := v.MarshalMsg(nil)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
left, err := v.UnmarshalMsg(bts)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
if len(left) > 0 {
|
|
|
|
t.Errorf("%d bytes left over after UnmarshalMsg(): %q", len(left), left)
|
|
|
|
}
|
|
|
|
|
|
|
|
left, err = msgp.Skip(bts)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
if len(left) > 0 {
|
|
|
|
t.Errorf("%d bytes left over after Skip(): %q", len(left), left)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func BenchmarkMarshalMsgFileInfoVersions(b *testing.B) {
|
|
|
|
v := FileInfoVersions{}
|
|
|
|
b.ReportAllocs()
|
|
|
|
b.ResetTimer()
|
|
|
|
for i := 0; i < b.N; i++ {
|
|
|
|
v.MarshalMsg(nil)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func BenchmarkAppendMsgFileInfoVersions(b *testing.B) {
|
|
|
|
v := FileInfoVersions{}
|
|
|
|
bts := make([]byte, 0, v.Msgsize())
|
|
|
|
bts, _ = v.MarshalMsg(bts[0:0])
|
|
|
|
b.SetBytes(int64(len(bts)))
|
|
|
|
b.ReportAllocs()
|
|
|
|
b.ResetTimer()
|
|
|
|
for i := 0; i < b.N; i++ {
|
|
|
|
bts, _ = v.MarshalMsg(bts[0:0])
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func BenchmarkUnmarshalFileInfoVersions(b *testing.B) {
|
|
|
|
v := FileInfoVersions{}
|
|
|
|
bts, _ := v.MarshalMsg(nil)
|
|
|
|
b.ReportAllocs()
|
|
|
|
b.SetBytes(int64(len(bts)))
|
|
|
|
b.ResetTimer()
|
|
|
|
for i := 0; i < b.N; i++ {
|
|
|
|
_, err := v.UnmarshalMsg(bts)
|
|
|
|
if err != nil {
|
|
|
|
b.Fatal(err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestEncodeDecodeFileInfoVersions(t *testing.T) {
|
|
|
|
v := FileInfoVersions{}
|
|
|
|
var buf bytes.Buffer
|
|
|
|
msgp.Encode(&buf, &v)
|
|
|
|
|
|
|
|
m := v.Msgsize()
|
|
|
|
if buf.Len() > m {
|
|
|
|
t.Log("WARNING: TestEncodeDecodeFileInfoVersions Msgsize() is inaccurate")
|
|
|
|
}
|
|
|
|
|
|
|
|
vn := FileInfoVersions{}
|
|
|
|
err := msgp.Decode(&buf, &vn)
|
|
|
|
if err != nil {
|
|
|
|
t.Error(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
buf.Reset()
|
|
|
|
msgp.Encode(&buf, &v)
|
|
|
|
err = msgp.NewReader(&buf).Skip()
|
|
|
|
if err != nil {
|
|
|
|
t.Error(err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func BenchmarkEncodeFileInfoVersions(b *testing.B) {
|
|
|
|
v := FileInfoVersions{}
|
|
|
|
var buf bytes.Buffer
|
|
|
|
msgp.Encode(&buf, &v)
|
|
|
|
b.SetBytes(int64(buf.Len()))
|
|
|
|
en := msgp.NewWriter(msgp.Nowhere)
|
|
|
|
b.ReportAllocs()
|
|
|
|
b.ResetTimer()
|
|
|
|
for i := 0; i < b.N; i++ {
|
|
|
|
v.EncodeMsg(en)
|
|
|
|
}
|
|
|
|
en.Flush()
|
|
|
|
}
|
|
|
|
|
|
|
|
func BenchmarkDecodeFileInfoVersions(b *testing.B) {
|
|
|
|
v := FileInfoVersions{}
|
|
|
|
var buf bytes.Buffer
|
|
|
|
msgp.Encode(&buf, &v)
|
|
|
|
b.SetBytes(int64(buf.Len()))
|
|
|
|
rd := msgp.NewEndlessReader(buf.Bytes(), b)
|
|
|
|
dc := msgp.NewReader(rd)
|
|
|
|
b.ReportAllocs()
|
|
|
|
b.ResetTimer()
|
|
|
|
for i := 0; i < b.N; i++ {
|
|
|
|
err := v.DecodeMsg(dc)
|
|
|
|
if err != nil {
|
|
|
|
b.Fatal(err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestMarshalUnmarshalFilesInfo(t *testing.T) {
|
|
|
|
v := FilesInfo{}
|
|
|
|
bts, err := v.MarshalMsg(nil)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
left, err := v.UnmarshalMsg(bts)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
if len(left) > 0 {
|
|
|
|
t.Errorf("%d bytes left over after UnmarshalMsg(): %q", len(left), left)
|
|
|
|
}
|
|
|
|
|
|
|
|
left, err = msgp.Skip(bts)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
if len(left) > 0 {
|
|
|
|
t.Errorf("%d bytes left over after Skip(): %q", len(left), left)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func BenchmarkMarshalMsgFilesInfo(b *testing.B) {
|
|
|
|
v := FilesInfo{}
|
|
|
|
b.ReportAllocs()
|
|
|
|
b.ResetTimer()
|
|
|
|
for i := 0; i < b.N; i++ {
|
|
|
|
v.MarshalMsg(nil)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func BenchmarkAppendMsgFilesInfo(b *testing.B) {
|
|
|
|
v := FilesInfo{}
|
|
|
|
bts := make([]byte, 0, v.Msgsize())
|
|
|
|
bts, _ = v.MarshalMsg(bts[0:0])
|
|
|
|
b.SetBytes(int64(len(bts)))
|
|
|
|
b.ReportAllocs()
|
|
|
|
b.ResetTimer()
|
|
|
|
for i := 0; i < b.N; i++ {
|
|
|
|
bts, _ = v.MarshalMsg(bts[0:0])
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func BenchmarkUnmarshalFilesInfo(b *testing.B) {
|
|
|
|
v := FilesInfo{}
|
|
|
|
bts, _ := v.MarshalMsg(nil)
|
|
|
|
b.ReportAllocs()
|
|
|
|
b.SetBytes(int64(len(bts)))
|
|
|
|
b.ResetTimer()
|
|
|
|
for i := 0; i < b.N; i++ {
|
|
|
|
_, err := v.UnmarshalMsg(bts)
|
|
|
|
if err != nil {
|
|
|
|
b.Fatal(err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestEncodeDecodeFilesInfo(t *testing.T) {
|
|
|
|
v := FilesInfo{}
|
|
|
|
var buf bytes.Buffer
|
|
|
|
msgp.Encode(&buf, &v)
|
|
|
|
|
|
|
|
m := v.Msgsize()
|
|
|
|
if buf.Len() > m {
|
|
|
|
t.Log("WARNING: TestEncodeDecodeFilesInfo Msgsize() is inaccurate")
|
|
|
|
}
|
|
|
|
|
|
|
|
vn := FilesInfo{}
|
|
|
|
err := msgp.Decode(&buf, &vn)
|
|
|
|
if err != nil {
|
|
|
|
t.Error(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
buf.Reset()
|
|
|
|
msgp.Encode(&buf, &v)
|
|
|
|
err = msgp.NewReader(&buf).Skip()
|
|
|
|
if err != nil {
|
|
|
|
t.Error(err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func BenchmarkEncodeFilesInfo(b *testing.B) {
|
|
|
|
v := FilesInfo{}
|
|
|
|
var buf bytes.Buffer
|
|
|
|
msgp.Encode(&buf, &v)
|
|
|
|
b.SetBytes(int64(buf.Len()))
|
|
|
|
en := msgp.NewWriter(msgp.Nowhere)
|
|
|
|
b.ReportAllocs()
|
|
|
|
b.ResetTimer()
|
|
|
|
for i := 0; i < b.N; i++ {
|
|
|
|
v.EncodeMsg(en)
|
|
|
|
}
|
|
|
|
en.Flush()
|
|
|
|
}
|
|
|
|
|
|
|
|
func BenchmarkDecodeFilesInfo(b *testing.B) {
|
|
|
|
v := FilesInfo{}
|
|
|
|
var buf bytes.Buffer
|
|
|
|
msgp.Encode(&buf, &v)
|
|
|
|
b.SetBytes(int64(buf.Len()))
|
|
|
|
rd := msgp.NewEndlessReader(buf.Bytes(), b)
|
|
|
|
dc := msgp.NewReader(rd)
|
|
|
|
b.ReportAllocs()
|
|
|
|
b.ResetTimer()
|
|
|
|
for i := 0; i < b.N; i++ {
|
|
|
|
err := v.DecodeMsg(dc)
|
|
|
|
if err != nil {
|
|
|
|
b.Fatal(err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestMarshalUnmarshalFilesInfoVersions(t *testing.T) {
|
|
|
|
v := FilesInfoVersions{}
|
|
|
|
bts, err := v.MarshalMsg(nil)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
left, err := v.UnmarshalMsg(bts)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
if len(left) > 0 {
|
|
|
|
t.Errorf("%d bytes left over after UnmarshalMsg(): %q", len(left), left)
|
|
|
|
}
|
|
|
|
|
|
|
|
left, err = msgp.Skip(bts)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
if len(left) > 0 {
|
|
|
|
t.Errorf("%d bytes left over after Skip(): %q", len(left), left)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func BenchmarkMarshalMsgFilesInfoVersions(b *testing.B) {
|
|
|
|
v := FilesInfoVersions{}
|
|
|
|
b.ReportAllocs()
|
|
|
|
b.ResetTimer()
|
|
|
|
for i := 0; i < b.N; i++ {
|
|
|
|
v.MarshalMsg(nil)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func BenchmarkAppendMsgFilesInfoVersions(b *testing.B) {
|
|
|
|
v := FilesInfoVersions{}
|
|
|
|
bts := make([]byte, 0, v.Msgsize())
|
|
|
|
bts, _ = v.MarshalMsg(bts[0:0])
|
|
|
|
b.SetBytes(int64(len(bts)))
|
|
|
|
b.ReportAllocs()
|
|
|
|
b.ResetTimer()
|
|
|
|
for i := 0; i < b.N; i++ {
|
|
|
|
bts, _ = v.MarshalMsg(bts[0:0])
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func BenchmarkUnmarshalFilesInfoVersions(b *testing.B) {
|
|
|
|
v := FilesInfoVersions{}
|
|
|
|
bts, _ := v.MarshalMsg(nil)
|
|
|
|
b.ReportAllocs()
|
|
|
|
b.SetBytes(int64(len(bts)))
|
|
|
|
b.ResetTimer()
|
|
|
|
for i := 0; i < b.N; i++ {
|
|
|
|
_, err := v.UnmarshalMsg(bts)
|
|
|
|
if err != nil {
|
|
|
|
b.Fatal(err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestEncodeDecodeFilesInfoVersions(t *testing.T) {
|
|
|
|
v := FilesInfoVersions{}
|
|
|
|
var buf bytes.Buffer
|
|
|
|
msgp.Encode(&buf, &v)
|
|
|
|
|
|
|
|
m := v.Msgsize()
|
|
|
|
if buf.Len() > m {
|
|
|
|
t.Log("WARNING: TestEncodeDecodeFilesInfoVersions Msgsize() is inaccurate")
|
|
|
|
}
|
|
|
|
|
|
|
|
vn := FilesInfoVersions{}
|
|
|
|
err := msgp.Decode(&buf, &vn)
|
|
|
|
if err != nil {
|
|
|
|
t.Error(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
buf.Reset()
|
|
|
|
msgp.Encode(&buf, &v)
|
|
|
|
err = msgp.NewReader(&buf).Skip()
|
|
|
|
if err != nil {
|
|
|
|
t.Error(err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func BenchmarkEncodeFilesInfoVersions(b *testing.B) {
|
|
|
|
v := FilesInfoVersions{}
|
|
|
|
var buf bytes.Buffer
|
|
|
|
msgp.Encode(&buf, &v)
|
|
|
|
b.SetBytes(int64(buf.Len()))
|
|
|
|
en := msgp.NewWriter(msgp.Nowhere)
|
|
|
|
b.ReportAllocs()
|
|
|
|
b.ResetTimer()
|
|
|
|
for i := 0; i < b.N; i++ {
|
|
|
|
v.EncodeMsg(en)
|
|
|
|
}
|
|
|
|
en.Flush()
|
|
|
|
}
|
|
|
|
|
|
|
|
func BenchmarkDecodeFilesInfoVersions(b *testing.B) {
|
|
|
|
v := FilesInfoVersions{}
|
|
|
|
var buf bytes.Buffer
|
|
|
|
msgp.Encode(&buf, &v)
|
|
|
|
b.SetBytes(int64(buf.Len()))
|
|
|
|
rd := msgp.NewEndlessReader(buf.Bytes(), b)
|
|
|
|
dc := msgp.NewReader(rd)
|
|
|
|
b.ReportAllocs()
|
|
|
|
b.ResetTimer()
|
|
|
|
for i := 0; i < b.N; i++ {
|
|
|
|
err := v.DecodeMsg(dc)
|
|
|
|
if err != nil {
|
|
|
|
b.Fatal(err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestMarshalUnmarshalVolInfo(t *testing.T) {
|
|
|
|
v := VolInfo{}
|
|
|
|
bts, err := v.MarshalMsg(nil)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
left, err := v.UnmarshalMsg(bts)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
if len(left) > 0 {
|
|
|
|
t.Errorf("%d bytes left over after UnmarshalMsg(): %q", len(left), left)
|
|
|
|
}
|
|
|
|
|
|
|
|
left, err = msgp.Skip(bts)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
if len(left) > 0 {
|
|
|
|
t.Errorf("%d bytes left over after Skip(): %q", len(left), left)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func BenchmarkMarshalMsgVolInfo(b *testing.B) {
|
|
|
|
v := VolInfo{}
|
|
|
|
b.ReportAllocs()
|
|
|
|
b.ResetTimer()
|
|
|
|
for i := 0; i < b.N; i++ {
|
|
|
|
v.MarshalMsg(nil)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func BenchmarkAppendMsgVolInfo(b *testing.B) {
|
|
|
|
v := VolInfo{}
|
|
|
|
bts := make([]byte, 0, v.Msgsize())
|
|
|
|
bts, _ = v.MarshalMsg(bts[0:0])
|
|
|
|
b.SetBytes(int64(len(bts)))
|
|
|
|
b.ReportAllocs()
|
|
|
|
b.ResetTimer()
|
|
|
|
for i := 0; i < b.N; i++ {
|
|
|
|
bts, _ = v.MarshalMsg(bts[0:0])
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func BenchmarkUnmarshalVolInfo(b *testing.B) {
|
|
|
|
v := VolInfo{}
|
|
|
|
bts, _ := v.MarshalMsg(nil)
|
|
|
|
b.ReportAllocs()
|
|
|
|
b.SetBytes(int64(len(bts)))
|
|
|
|
b.ResetTimer()
|
|
|
|
for i := 0; i < b.N; i++ {
|
|
|
|
_, err := v.UnmarshalMsg(bts)
|
|
|
|
if err != nil {
|
|
|
|
b.Fatal(err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestEncodeDecodeVolInfo(t *testing.T) {
|
|
|
|
v := VolInfo{}
|
|
|
|
var buf bytes.Buffer
|
|
|
|
msgp.Encode(&buf, &v)
|
|
|
|
|
|
|
|
m := v.Msgsize()
|
|
|
|
if buf.Len() > m {
|
|
|
|
t.Log("WARNING: TestEncodeDecodeVolInfo Msgsize() is inaccurate")
|
|
|
|
}
|
|
|
|
|
|
|
|
vn := VolInfo{}
|
|
|
|
err := msgp.Decode(&buf, &vn)
|
|
|
|
if err != nil {
|
|
|
|
t.Error(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
buf.Reset()
|
|
|
|
msgp.Encode(&buf, &v)
|
|
|
|
err = msgp.NewReader(&buf).Skip()
|
|
|
|
if err != nil {
|
|
|
|
t.Error(err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func BenchmarkEncodeVolInfo(b *testing.B) {
|
|
|
|
v := VolInfo{}
|
|
|
|
var buf bytes.Buffer
|
|
|
|
msgp.Encode(&buf, &v)
|
|
|
|
b.SetBytes(int64(buf.Len()))
|
|
|
|
en := msgp.NewWriter(msgp.Nowhere)
|
|
|
|
b.ReportAllocs()
|
|
|
|
b.ResetTimer()
|
|
|
|
for i := 0; i < b.N; i++ {
|
|
|
|
v.EncodeMsg(en)
|
|
|
|
}
|
|
|
|
en.Flush()
|
|
|
|
}
|
|
|
|
|
|
|
|
func BenchmarkDecodeVolInfo(b *testing.B) {
|
|
|
|
v := VolInfo{}
|
|
|
|
var buf bytes.Buffer
|
|
|
|
msgp.Encode(&buf, &v)
|
|
|
|
b.SetBytes(int64(buf.Len()))
|
|
|
|
rd := msgp.NewEndlessReader(buf.Bytes(), b)
|
|
|
|
dc := msgp.NewReader(rd)
|
|
|
|
b.ReportAllocs()
|
|
|
|
b.ResetTimer()
|
|
|
|
for i := 0; i < b.N; i++ {
|
|
|
|
err := v.DecodeMsg(dc)
|
|
|
|
if err != nil {
|
|
|
|
b.Fatal(err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2020-11-04 19:10:54 +01:00
|
|
|
|
|
|
|
func TestMarshalUnmarshalVolsInfo(t *testing.T) {
|
|
|
|
v := VolsInfo{}
|
|
|
|
bts, err := v.MarshalMsg(nil)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
left, err := v.UnmarshalMsg(bts)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
if len(left) > 0 {
|
|
|
|
t.Errorf("%d bytes left over after UnmarshalMsg(): %q", len(left), left)
|
|
|
|
}
|
|
|
|
|
|
|
|
left, err = msgp.Skip(bts)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
if len(left) > 0 {
|
|
|
|
t.Errorf("%d bytes left over after Skip(): %q", len(left), left)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func BenchmarkMarshalMsgVolsInfo(b *testing.B) {
|
|
|
|
v := VolsInfo{}
|
|
|
|
b.ReportAllocs()
|
|
|
|
b.ResetTimer()
|
|
|
|
for i := 0; i < b.N; i++ {
|
|
|
|
v.MarshalMsg(nil)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func BenchmarkAppendMsgVolsInfo(b *testing.B) {
|
|
|
|
v := VolsInfo{}
|
|
|
|
bts := make([]byte, 0, v.Msgsize())
|
|
|
|
bts, _ = v.MarshalMsg(bts[0:0])
|
|
|
|
b.SetBytes(int64(len(bts)))
|
|
|
|
b.ReportAllocs()
|
|
|
|
b.ResetTimer()
|
|
|
|
for i := 0; i < b.N; i++ {
|
|
|
|
bts, _ = v.MarshalMsg(bts[0:0])
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func BenchmarkUnmarshalVolsInfo(b *testing.B) {
|
|
|
|
v := VolsInfo{}
|
|
|
|
bts, _ := v.MarshalMsg(nil)
|
|
|
|
b.ReportAllocs()
|
|
|
|
b.SetBytes(int64(len(bts)))
|
|
|
|
b.ResetTimer()
|
|
|
|
for i := 0; i < b.N; i++ {
|
|
|
|
_, err := v.UnmarshalMsg(bts)
|
|
|
|
if err != nil {
|
|
|
|
b.Fatal(err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestEncodeDecodeVolsInfo(t *testing.T) {
|
|
|
|
v := VolsInfo{}
|
|
|
|
var buf bytes.Buffer
|
|
|
|
msgp.Encode(&buf, &v)
|
|
|
|
|
|
|
|
m := v.Msgsize()
|
|
|
|
if buf.Len() > m {
|
|
|
|
t.Log("WARNING: TestEncodeDecodeVolsInfo Msgsize() is inaccurate")
|
|
|
|
}
|
|
|
|
|
|
|
|
vn := VolsInfo{}
|
|
|
|
err := msgp.Decode(&buf, &vn)
|
|
|
|
if err != nil {
|
|
|
|
t.Error(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
buf.Reset()
|
|
|
|
msgp.Encode(&buf, &v)
|
|
|
|
err = msgp.NewReader(&buf).Skip()
|
|
|
|
if err != nil {
|
|
|
|
t.Error(err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func BenchmarkEncodeVolsInfo(b *testing.B) {
|
|
|
|
v := VolsInfo{}
|
|
|
|
var buf bytes.Buffer
|
|
|
|
msgp.Encode(&buf, &v)
|
|
|
|
b.SetBytes(int64(buf.Len()))
|
|
|
|
en := msgp.NewWriter(msgp.Nowhere)
|
|
|
|
b.ReportAllocs()
|
|
|
|
b.ResetTimer()
|
|
|
|
for i := 0; i < b.N; i++ {
|
|
|
|
v.EncodeMsg(en)
|
|
|
|
}
|
|
|
|
en.Flush()
|
|
|
|
}
|
|
|
|
|
|
|
|
func BenchmarkDecodeVolsInfo(b *testing.B) {
|
|
|
|
v := VolsInfo{}
|
|
|
|
var buf bytes.Buffer
|
|
|
|
msgp.Encode(&buf, &v)
|
|
|
|
b.SetBytes(int64(buf.Len()))
|
|
|
|
rd := msgp.NewEndlessReader(buf.Bytes(), b)
|
|
|
|
dc := msgp.NewReader(rd)
|
|
|
|
b.ReportAllocs()
|
|
|
|
b.ResetTimer()
|
|
|
|
for i := 0; i < b.N; i++ {
|
|
|
|
err := v.DecodeMsg(dc)
|
|
|
|
if err != nil {
|
|
|
|
b.Fatal(err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|