From 37b8e403379130d8367343bd4b328baee3da72a7 Mon Sep 17 00:00:00 2001 From: miaoxueyu Date: Wed, 24 Aug 2022 10:14:49 +0800 Subject: [PATCH] optimize Add unit testing for common (#229) * add unit test * add unit test * add unit test Co-authored-by: miaoxueyu --- pkg/common/bytes/buf_helper_test.go | 172 ++++++++++++++++++++++++++ pkg/common/bytes/buf_test.go | 184 ++++++++++++++++++++++++++++ 2 files changed, 356 insertions(+) create mode 100644 pkg/common/bytes/buf_helper_test.go create mode 100644 pkg/common/bytes/buf_test.go diff --git a/pkg/common/bytes/buf_helper_test.go b/pkg/common/bytes/buf_helper_test.go new file mode 100644 index 000000000..ea2c1adf1 --- /dev/null +++ b/pkg/common/bytes/buf_helper_test.go @@ -0,0 +1,172 @@ +package bytes + +import ( + "math" + "testing" + + "github.com/stretchr/testify/assert" +) + +func TestReadBytes(t *testing.T) { + bytes := []byte{2, 3, 4, 5, 6} + byteBuffer := NewByteBuffer(bytes) + readBytes := ReadBytes(len(bytes), byteBuffer) + assert.Equal(t, bytes, readBytes) +} + +func TestReadUint8(t *testing.T) { + bytes := []byte{255} + byteBuffer := NewByteBuffer(bytes) + readUint8 := ReadUint8(byteBuffer) + assert.Equal(t, readUint8, bytes[0]) +} + +func TestReadUInt16(t *testing.T) { + bytes := []byte{255, 255} + byteBuffer := NewByteBuffer(bytes) + readUint16 := ReadUInt16(byteBuffer) + assert.Equal(t, readUint16, uint16(math.MaxUint16)) +} + +func TestReadUInt32(t *testing.T) { + bytes := []byte{255, 255, 255, 255} + byteBuffer := NewByteBuffer(bytes) + readUInt32 := ReadUInt32(byteBuffer) + assert.Equal(t, readUInt32, uint32(math.MaxUint32)) +} + +func TestReadUInt64(t *testing.T) { + bytes := []byte{255, 255, 255, 255, 255, 255, 255, 255} + byteBuffer := NewByteBuffer(bytes) + readUInt64 := ReadUInt64(byteBuffer) + assert.Equal(t, readUInt64, uint64(math.MaxUint64)) +} + +func TestReadString8(t *testing.T) { + bytes := []byte("A") + byteBuffer := NewByteBuffer(bytes) + readString8 := ReadString8(byteBuffer) + assert.Equal(t, readString8, "A") +} + +func TestRead1String16(t *testing.T) { + bytes := []byte("seata_test") + byteBuffer := NewByteBuffer(bytes) + readString16 := Read1String16(byteBuffer) + assert.Equal(t, readString16, "se") +} + +func TestReadString32(t *testing.T) { + bytes := []byte("seata_test") + byteBuffer := NewByteBuffer(bytes) + readString32 := ReadString32(byteBuffer) + assert.Equal(t, readString32, "seat") +} + +func TestReadString64(t *testing.T) { + bytes := []byte("seata_test") + byteBuffer := NewByteBuffer(bytes) + readString64 := ReadString64(byteBuffer) + assert.Equal(t, readString64, "seata_te") +} + +func generateStringByLength(length int) string { + // a-z loop generate + // a == 97 + // z == 122 + letterCount := 26 + bytes := make([]byte, length) + for i := 0; i < length; i++ { + bytes[i] = byte(97 + (i % letterCount)) + } + return string(bytes) +} + +func ReadStringNLengthTest( + t *testing.T, + length int, + writeLengthFun func(length int, byteBuffer ByteBuffer), + readStringFun func(buf *ByteBuffer) string, +) { + str := generateStringByLength(length) + byteBuffer := NewByteBuffer([]byte{}) + + // write length and content + writeLengthFun(len(str), *byteBuffer) + _, _ = byteBuffer.WriteString(str) + + readString := readStringFun(byteBuffer) + assert.Equal(t, readString, generateStringByLength(length)) +} + +func TestReadString8Length(t *testing.T) { + writeLengthFun := func(length int, byteBuffer ByteBuffer) { + _ = byteBuffer.WriteByte(byte(length)) + } + + ReadStringNLengthTest(t, 0, writeLengthFun, ReadString8Length) + ReadStringNLengthTest(t, 255, writeLengthFun, ReadString8Length) +} + +func TestReadString16Length(t *testing.T) { + writeFun := func(length int, byteBuffer ByteBuffer) { + _, _ = byteBuffer.WriteUint16(uint16(length)) + } + + ReadStringNLengthTest(t, 0, writeFun, ReadString16Length) + ReadStringNLengthTest(t, math.MaxInt16, writeFun, ReadString16Length) +} + +func TestReadString32Length(t *testing.T) { + writeFun := func(length int, byteBuffer ByteBuffer) { + _, _ = byteBuffer.WriteUint32(uint32(length)) + } + + ReadStringNLengthTest(t, 0, writeFun, ReadString32Length) + ReadStringNLengthTest(t, math.MaxInt8, writeFun, ReadString32Length) +} + +func TestReadString64Length(t *testing.T) { + writeFun := func(length int, byteBuffer ByteBuffer) { + _, _ = byteBuffer.WriteUint64(uint64(length)) + } + + ReadStringNLengthTest(t, 0, writeFun, ReadString64Length) + ReadStringNLengthTest(t, math.MaxInt8, writeFun, ReadString64Length) +} + +func WriteStringNLengthTest( + t *testing.T, + length int, + writeStringFun func(value string, buf *ByteBuffer), + readStringFun func(buf *ByteBuffer) string, +) { + str := generateStringByLength(length) + byteBuffer := NewByteBuffer([]byte{}) + + // write length and content + writeStringFun(str, byteBuffer) + + readString := readStringFun(byteBuffer) + assert.Equal(t, readString, generateStringByLength(length)) +} + +func TestWriteString8Length(t *testing.T) { + WriteStringNLengthTest(t, 0, WriteString8Length, ReadString8Length) + WriteStringNLengthTest(t, math.MaxInt8, WriteString8Length, ReadString8Length) +} + +func TestWriteString16Length(t *testing.T) { + WriteStringNLengthTest(t, 0, WriteString16Length, ReadString16Length) + WriteStringNLengthTest(t, math.MaxInt8, WriteString16Length, ReadString16Length) +} + +func TestWriteString32Length(t *testing.T) { + WriteStringNLengthTest(t, 0, WriteString32Length, ReadString32Length) + WriteStringNLengthTest(t, math.MaxInt8, WriteString32Length, ReadString32Length) +} + +func TestWriteString64Length(t *testing.T) { + WriteStringNLengthTest(t, 0, WriteString64Length, ReadString64Length) + WriteStringNLengthTest(t, math.MaxInt8, WriteString64Length, ReadString64Length) +} diff --git a/pkg/common/bytes/buf_test.go b/pkg/common/bytes/buf_test.go new file mode 100644 index 000000000..d359d8130 --- /dev/null +++ b/pkg/common/bytes/buf_test.go @@ -0,0 +1,184 @@ +package bytes + +import ( + "math" + "testing" + + "github.com/stretchr/testify/assert" +) + +func TestBytes(t *testing.T) { + bytes := []byte{2, 3, 4, 5, 6} + byteBuffer := NewByteBuffer(bytes) + assert.Equal(t, byteBuffer.Bytes(), bytes) +} + +func TestRead(t *testing.T) { + bytes := []byte{2, 3, 4, 5, 6} + byteBuffer := NewByteBuffer(bytes) + newBytes := make([]byte, len(bytes)) + _, _ = byteBuffer.Read(newBytes) + assert.Equal(t, bytes, newBytes) +} + +func TestReadByte(t *testing.T) { + bytes := []byte{2, 3, 4, 5, 6} + byteBuffer := NewByteBuffer(bytes) + for _, byteItem := range bytes { + readByte, _ := byteBuffer.ReadByte() + assert.Equal(t, byteItem, readByte) + } +} + +func TestReadInt64(t *testing.T) { + byteBuffer := NewByteBuffer([]byte{127, 255, 255, 255, 255, 255, 255, 255}) + readInt64, _ := byteBuffer.ReadInt64() + assert.Equal(t, readInt64, int64(math.MaxInt64)) +} + +func TestReadUint16(t *testing.T) { + byteBuffer := NewByteBuffer([]byte{255, 255}) + readInt16, _ := byteBuffer.ReadUint16() + assert.Equal(t, readInt16, uint16(math.MaxUint16)) +} + +func TestReadUint32(t *testing.T) { + byteBuffer := NewByteBuffer([]byte{255, 255, 255, 255}) + readInt32, _ := byteBuffer.ReadUint32() + assert.Equal(t, readInt32, uint32(math.MaxUint32)) +} + +func TestReadUint64(t *testing.T) { + byteBuffer := NewByteBuffer([]byte{255, 255, 255, 255, 255, 255, 255, 255}) + readUint64, _ := byteBuffer.ReadUint64() + assert.Equal(t, readUint64, uint64(math.MaxUint64)) +} + +func TestWrite(t *testing.T) { + byteBuffer := NewByteBuffer([]byte{}) + _, err := byteBuffer.Write([]byte{255, 255}) + if err != nil { + t.Error() + } + readUint16, _ := byteBuffer.ReadUint16() + assert.Equal(t, readUint16, uint16(math.MaxUint16)) +} + +func TestWriteString(t *testing.T) { + byteBuffer := NewByteBuffer([]byte{}) + _, err := byteBuffer.WriteString("seata") + if err != nil { + t.Error() + return + } + seataBytes := []byte{115, 101, 97, 116, 97} + for _, byteItem := range seataBytes { + readByte, _ := byteBuffer.ReadByte() + assert.Equal(t, byteItem, readByte) + } +} + +func TestWriteByte(t *testing.T) { + byteBuffer := NewByteBuffer([]byte{}) + _ = byteBuffer.WriteByte(1) + readByte, _ := byteBuffer.ReadByte() + assert.Equal(t, readByte, byte(1)) +} + +func TestWriteUint16(t *testing.T) { + byteBuffer := NewByteBuffer([]byte{}) + _, _ = byteBuffer.WriteUint16(uint16(math.MaxUint16)) + readUint16, _ := byteBuffer.ReadUint16() + assert.Equal(t, uint16(math.MaxUint16), readUint16) +} + +func TestWriteUint32(t *testing.T) { + byteBuffer := NewByteBuffer([]byte{}) + _, _ = byteBuffer.WriteUint32(uint32(math.MaxUint32)) + readUint32, _ := byteBuffer.ReadUint32() + assert.Equal(t, uint32(math.MaxUint32), readUint32) +} + +func TestWriteUint64(t *testing.T) { + byteBuffer := NewByteBuffer([]byte{}) + _, _ = byteBuffer.WriteUint64(uint64(math.MaxUint64)) + readUint64, _ := byteBuffer.ReadUint64() + assert.Equal(t, uint64(math.MaxUint64), readUint64) +} + +func TestWriteInt64(t *testing.T) { + byteBuffer := NewByteBuffer([]byte{}) + _, _ = byteBuffer.WriteInt64(int64(math.MaxInt64)) + readInt64, _ := byteBuffer.ReadInt64() + assert.Equal(t, int64(math.MaxInt64), readInt64) +} + +func TestByte2Int64(t *testing.T) { + byte2Int64 := Byte2Int64([]byte{127, 255, 255, 255, 255, 255, 255, 255}) + assert.Equal(t, byte2Int64, int64(math.MaxInt64)) +} + +func TestByte2UInt16(t *testing.T) { + byte2UInt16 := Byte2UInt16([]byte{255, 255}) + assert.Equal(t, byte2UInt16, uint16(math.MaxUint16)) +} + +func TestByte2UInt32(t *testing.T) { + byte2UInt32 := Byte2UInt32([]byte{255, 255, 255, 255}) + assert.Equal(t, byte2UInt32, uint32(math.MaxUint32)) +} + +func TestInt2BytesTo(t *testing.T) { + bytes := make([]byte, 4) + Int2BytesTo(math.MaxInt64, bytes) + assert.Equal(t, bytes, []byte{255, 255, 255, 255}) +} + +func TestInt2Bytes(t *testing.T) { + bytes := Int2Bytes(math.MaxInt64) + assert.Equal(t, bytes, []byte{255, 255, 255, 255}) +} + +func TestInt64ToBytesTo(t *testing.T) { + bytes := make([]byte, 8) + Int64ToBytesTo(math.MaxInt64, bytes) + assert.Equal(t, bytes, []byte{127, 255, 255, 255, 255, 255, 255, 255}) +} + +func TestUint64ToBytesTo(t *testing.T) { + bytes := make([]byte, 8) + Uint64ToBytesTo(math.MaxUint64, bytes) + assert.Equal(t, bytes, []byte{255, 255, 255, 255, 255, 255, 255, 255}) +} + +func TestInt64ToBytes(t *testing.T) { + bytes := Int64ToBytes(math.MaxInt64) + assert.Equal(t, bytes, []byte{127, 255, 255, 255, 255, 255, 255, 255}) +} + +func TestUint32ToBytesTo(t *testing.T) { + bytes := make([]byte, 4) + Uint32ToBytesTo(math.MaxUint32, bytes) + assert.Equal(t, bytes, []byte{255, 255, 255, 255}) +} + +func TestUInt32ToBytes(t *testing.T) { + bytes := UInt32ToBytes(math.MaxUint32) + assert.Equal(t, bytes, []byte{255, 255, 255, 255}) +} + +func TestUint16ToBytesTo(t *testing.T) { + bytes := make([]byte, 2) + Uint16ToBytesTo(math.MaxUint16, bytes) + assert.Equal(t, bytes, []byte{255, 255}) +} + +func TestUInt16ToBytes(t *testing.T) { + bytes := UInt16ToBytes(math.MaxUint16) + assert.Equal(t, bytes, []byte{255, 255}) +} + +func TestUInt64ToBytes(t *testing.T) { + bytes := UInt64ToBytes(math.MaxUint64) + assert.Equal(t, bytes, []byte{255, 255, 255, 255, 255, 255, 255, 255}) +}