if (GetName(funcs[0]) == GetName(func0)) {
    AssertEqual(func0, funcs[0]);
    AssertEqual(func1, funcs[1]);
  } else {
    AssertEqual(func0, funcs[1]);
    AssertEqual(func1, funcs[0]);
  }

  TF_DeleteFunction(funcs[0]);
  TF_DeleteFunction(funcs[1]);

  TF_DeleteFunction(func0);
  TF_DeleteFunction(func1);
}

}  // namespace

		t.Fatal(err)
	}
	if len(left) > 0 {
		t.Errorf("%d bytes left over after Skip(): %q", len(left), left)
	}
}

func BenchmarkMarshalMsgActiveWorkerStat(b *testing.B) {
	v := ActiveWorkerStat{}
	b.ReportAllocs()
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		v.MarshalMsg(nil)
	}
}

func BenchmarkAppendMsgActiveWorkerStat(b *testing.B) {
	v := ActiveWorkerStat{}
	bts := make([]byte, 0, v.Msgsize())

// returns the slice of errors from all function calls.
func (g *NotificationGroup) Wait() []NotificationPeerErr {
	g.workers.Wait()
	return g.errs
}

// Go calls the given function in a new goroutine.
//
// The first call to return a non-nil error will be
// collected in errs slice and returned by Wait().
func (g *NotificationGroup) Go(ctx context.Context, f func() error, index int, addr xnet.Host) {

	}
	if len(left) > 0 {
		t.Errorf("%d bytes left over after Skip(): %q", len(left), left)
	}
}

func BenchmarkMarshalMsgBucketReplicationResyncStatus(b *testing.B) {
	v := BucketReplicationResyncStatus{}
	b.ReportAllocs()
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		v.MarshalMsg(nil)
	}
}

func BenchmarkAppendMsgBucketReplicationResyncStatus(b *testing.B) {
	v := BucketReplicationResyncStatus{}

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

// DecodeMsg implements msgp.Decodable
func (z *StatusType) DecodeMsg(dc *msgp.Reader) (err error) {
	{
		var zb0001 string
		zb0001, err = dc.ReadString()
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		(*z) = StatusType(zb0001)
	}
	return
}

// EncodeMsg implements msgp.Encodable
func (z StatusType) EncodeMsg(en *msgp.Writer) (err error) {

		t.Fatal(err)
	}
	if len(left) > 0 {
		t.Errorf("%d bytes left over after Skip(): %q", len(left), left)
	}
}

func BenchmarkMarshalMsgPoolDecommissionInfo(b *testing.B) {
	v := PoolDecommissionInfo{}
	b.ReportAllocs()
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		v.MarshalMsg(nil)
	}
}

func BenchmarkAppendMsgPoolDecommissionInfo(b *testing.B) {
	v := PoolDecommissionInfo{}
	bts := make([]byte, 0, v.Msgsize())

		t.Fatal(err)
	}
	if len(left) > 0 {
		t.Errorf("%d bytes left over after Skip(): %q", len(left), left)
	}
}

func BenchmarkMarshalMsgBatchJobKV(b *testing.B) {
	v := BatchJobKV{}
	b.ReportAllocs()
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		v.MarshalMsg(nil)
	}
}

func BenchmarkAppendMsgBatchJobKV(b *testing.B) {
	v := BatchJobKV{}
	bts := make([]byte, 0, v.Msgsize())
	bts, _ = v.MarshalMsg(bts[0:0])

	}
	if len(left) > 0 {
		t.Errorf("%d bytes left over after Skip(): %q", len(left), left)
	}
}

func BenchmarkMarshalMsgBatchJobKeyRotateEncryption(b *testing.B) {
	v := BatchJobKeyRotateEncryption{}
	b.ReportAllocs()
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		v.MarshalMsg(nil)
	}
}

func BenchmarkAppendMsgBatchJobKeyRotateEncryption(b *testing.B) {
	v := BatchJobKeyRotateEncryption{}

		t.Fatal(err)
	}
	if len(left) > 0 {
		t.Errorf("%d bytes left over after Skip(): %q", len(left), left)
	}
}

func BenchmarkMarshalMsgxlMetaDataDirDecoder(b *testing.B) {
	v := xlMetaDataDirDecoder{}
	b.ReportAllocs()
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		v.MarshalMsg(nil)
	}
}

func BenchmarkAppendMsgxlMetaDataDirDecoder(b *testing.B) {
	v := xlMetaDataDirDecoder{}
	bts := make([]byte, 0, v.Msgsize())

)

// isMaxObjectSize - verify if max object size
func isMaxObjectSize(size int64) bool {
	return size > globalMaxObjectSize
}

// Check if part size is more than or equal to minimum allowed size.
func isMinAllowedPartSize(size int64) bool {
	return size >= globalMinPartSize
}

// isMaxPartNumber - Check if part ID is greater than the maximum allowed ID.
func isMaxPartID(partID int) bool {
	return partID > globalMaxPartID