}
	}
}

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

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

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

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

			b.Fatal(err)
		}
	}
}

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

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

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

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

			bts, err = msgp.Skip(bts)
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *LockArgs) Msgsize() (s int) {
	s = 1 + 4 + msgp.StringPrefixSize + len(z.UID) + 10 + msgp.ArrayHeaderSize
	for za0001 := range z.Resources {

			bts, err = msgp.Skip(bts)
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *ServerSystemConfig) Msgsize() (s int) {
	s = 1 + 11 + msgp.IntSize + 9 + msgp.ArrayHeaderSize
	for za0001 := range z.CmdLines {
		s += msgp.StringPrefixSize + len(z.CmdLines[za0001])
	}

	}
	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()
		}
	}

			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *SiteResyncStatus) Msgsize() (s int) {
	s = 1 + 2 + msgp.IntSize + 3 + z.Status.Msgsize() + 4 + msgp.StringPrefixSize + len(z.DeplID) + 5 + msgp.MapHeaderSize
	if z.BucketStatuses != nil {

			b.Fatal(err)
		}
	}
}

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

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

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

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

			b.Fatal(err)
		}
	}
}

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

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

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

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

			b.Fatal(err)
		}
	}
}

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

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

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

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

			b.Fatal(err)
		}
	}
}

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

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

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

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