mirror of
https://github.com/Mezeporta/Erupe.git
synced 2026-03-22 07:32:32 +01:00
test: add unit tests for core packages
Add comprehensive test coverage for: - common/token: token generation and RNG tests - common/stringsupport: string encoding, CSV operations - common/byteframe: binary read/write operations - common/mhfcourse: course/subscription logic - network/crypt_packet: packet header parsing - network/binpacket: binary packet round-trips - network/mhfpacket: packet interface and opcode mapping - config: configuration struct and loading - server/entranceserver: response building - server/signserver: response ID constants - server/signv2server: HTTP endpoint validation - server/channelserver: session, semaphore, and handler tests All tests pass with race detector enabled.
This commit is contained in:
Houmgaor
467
common/byteframe/byteframe_test.go
Normal file
467
common/byteframe/byteframe_test.go
Normal file
@@ -0,0 +1,467 @@
|
||||
package byteframe
|
||||
|
||||
import (
|
||||
"io"
|
||||
"math"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestNewByteFrame(t *testing.T) {
|
||||
bf := NewByteFrame()
|
||||
|
||||
if bf == nil {
|
||||
t.Fatal("NewByteFrame() returned nil")
|
||||
}
|
||||
if len(bf.Data()) != 0 {
|
||||
t.Errorf("NewByteFrame().Data() len = %d, want 0", len(bf.Data()))
|
||||
}
|
||||
}
|
||||
|
||||
func TestNewByteFrameFromBytes(t *testing.T) {
|
||||
data := []byte{1, 2, 3, 4, 5}
|
||||
bf := NewByteFrameFromBytes(data)
|
||||
|
||||
if bf == nil {
|
||||
t.Fatal("NewByteFrameFromBytes() returned nil")
|
||||
}
|
||||
if len(bf.Data()) != len(data) {
|
||||
t.Errorf("NewByteFrameFromBytes().Data() len = %d, want %d", len(bf.Data()), len(data))
|
||||
}
|
||||
|
||||
// Verify data is copied, not referenced
|
||||
data[0] = 99
|
||||
if bf.Data()[0] == 99 {
|
||||
t.Error("NewByteFrameFromBytes() did not copy data")
|
||||
}
|
||||
}
|
||||
|
||||
func TestWriteReadUint8(t *testing.T) {
|
||||
tests := []uint8{0, 1, 127, 128, 255}
|
||||
|
||||
for _, val := range tests {
|
||||
t.Run("", func(t *testing.T) {
|
||||
bf := NewByteFrame()
|
||||
bf.WriteUint8(val)
|
||||
bf.Seek(0, io.SeekStart)
|
||||
got := bf.ReadUint8()
|
||||
if got != val {
|
||||
t.Errorf("Write/ReadUint8(%d) = %d", val, got)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestWriteReadUint16(t *testing.T) {
|
||||
tests := []uint16{0, 1, 255, 256, 32767, 65535}
|
||||
|
||||
for _, val := range tests {
|
||||
t.Run("", func(t *testing.T) {
|
||||
bf := NewByteFrame()
|
||||
bf.WriteUint16(val)
|
||||
bf.Seek(0, io.SeekStart)
|
||||
got := bf.ReadUint16()
|
||||
if got != val {
|
||||
t.Errorf("Write/ReadUint16(%d) = %d", val, got)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestWriteReadUint32(t *testing.T) {
|
||||
tests := []uint32{0, 1, 255, 65535, 2147483647, 4294967295}
|
||||
|
||||
for _, val := range tests {
|
||||
t.Run("", func(t *testing.T) {
|
||||
bf := NewByteFrame()
|
||||
bf.WriteUint32(val)
|
||||
bf.Seek(0, io.SeekStart)
|
||||
got := bf.ReadUint32()
|
||||
if got != val {
|
||||
t.Errorf("Write/ReadUint32(%d) = %d", val, got)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestWriteReadUint64(t *testing.T) {
|
||||
tests := []uint64{0, 1, 255, 65535, 4294967295, 18446744073709551615}
|
||||
|
||||
for _, val := range tests {
|
||||
t.Run("", func(t *testing.T) {
|
||||
bf := NewByteFrame()
|
||||
bf.WriteUint64(val)
|
||||
bf.Seek(0, io.SeekStart)
|
||||
got := bf.ReadUint64()
|
||||
if got != val {
|
||||
t.Errorf("Write/ReadUint64(%d) = %d", val, got)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestWriteReadInt8(t *testing.T) {
|
||||
tests := []int8{-128, -1, 0, 1, 127}
|
||||
|
||||
for _, val := range tests {
|
||||
t.Run("", func(t *testing.T) {
|
||||
bf := NewByteFrame()
|
||||
bf.WriteInt8(val)
|
||||
bf.Seek(0, io.SeekStart)
|
||||
got := bf.ReadInt8()
|
||||
if got != val {
|
||||
t.Errorf("Write/ReadInt8(%d) = %d", val, got)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestWriteReadInt16(t *testing.T) {
|
||||
tests := []int16{-32768, -1, 0, 1, 32767}
|
||||
|
||||
for _, val := range tests {
|
||||
t.Run("", func(t *testing.T) {
|
||||
bf := NewByteFrame()
|
||||
bf.WriteInt16(val)
|
||||
bf.Seek(0, io.SeekStart)
|
||||
got := bf.ReadInt16()
|
||||
if got != val {
|
||||
t.Errorf("Write/ReadInt16(%d) = %d", val, got)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestWriteReadInt32(t *testing.T) {
|
||||
tests := []int32{-2147483648, -1, 0, 1, 2147483647}
|
||||
|
||||
for _, val := range tests {
|
||||
t.Run("", func(t *testing.T) {
|
||||
bf := NewByteFrame()
|
||||
bf.WriteInt32(val)
|
||||
bf.Seek(0, io.SeekStart)
|
||||
got := bf.ReadInt32()
|
||||
if got != val {
|
||||
t.Errorf("Write/ReadInt32(%d) = %d", val, got)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestWriteReadInt64(t *testing.T) {
|
||||
tests := []int64{-9223372036854775808, -1, 0, 1, 9223372036854775807}
|
||||
|
||||
for _, val := range tests {
|
||||
t.Run("", func(t *testing.T) {
|
||||
bf := NewByteFrame()
|
||||
bf.WriteInt64(val)
|
||||
bf.Seek(0, io.SeekStart)
|
||||
got := bf.ReadInt64()
|
||||
if got != val {
|
||||
t.Errorf("Write/ReadInt64(%d) = %d", val, got)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestWriteReadFloat32(t *testing.T) {
|
||||
tests := []float32{0, 1.5, -1.5, 3.14159, math.MaxFloat32, math.SmallestNonzeroFloat32}
|
||||
|
||||
for _, val := range tests {
|
||||
t.Run("", func(t *testing.T) {
|
||||
bf := NewByteFrame()
|
||||
bf.WriteFloat32(val)
|
||||
bf.Seek(0, io.SeekStart)
|
||||
got := bf.ReadFloat32()
|
||||
if got != val {
|
||||
t.Errorf("Write/ReadFloat32(%f) = %f", val, got)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestWriteReadFloat64(t *testing.T) {
|
||||
tests := []float64{0, 1.5, -1.5, 3.14159265358979, math.MaxFloat64, math.SmallestNonzeroFloat64}
|
||||
|
||||
for _, val := range tests {
|
||||
t.Run("", func(t *testing.T) {
|
||||
bf := NewByteFrame()
|
||||
bf.WriteFloat64(val)
|
||||
bf.Seek(0, io.SeekStart)
|
||||
got := bf.ReadFloat64()
|
||||
if got != val {
|
||||
t.Errorf("Write/ReadFloat64(%f) = %f", val, got)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestWriteReadBool(t *testing.T) {
|
||||
tests := []bool{true, false}
|
||||
|
||||
for _, val := range tests {
|
||||
t.Run("", func(t *testing.T) {
|
||||
bf := NewByteFrame()
|
||||
bf.WriteBool(val)
|
||||
bf.Seek(0, io.SeekStart)
|
||||
got := bf.ReadBool()
|
||||
if got != val {
|
||||
t.Errorf("Write/ReadBool(%v) = %v", val, got)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestWriteReadBytes(t *testing.T) {
|
||||
tests := [][]byte{
|
||||
{},
|
||||
{1},
|
||||
{1, 2, 3, 4, 5},
|
||||
{0, 255, 128, 64, 32},
|
||||
}
|
||||
|
||||
for _, val := range tests {
|
||||
t.Run("", func(t *testing.T) {
|
||||
bf := NewByteFrame()
|
||||
bf.WriteBytes(val)
|
||||
bf.Seek(0, io.SeekStart)
|
||||
got := bf.ReadBytes(uint(len(val)))
|
||||
if len(got) != len(val) {
|
||||
t.Errorf("Write/ReadBytes len = %d, want %d", len(got), len(val))
|
||||
return
|
||||
}
|
||||
for i := range got {
|
||||
if got[i] != val[i] {
|
||||
t.Errorf("Write/ReadBytes[%d] = %d, want %d", i, got[i], val[i])
|
||||
}
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestWriteReadNullTerminatedBytes(t *testing.T) {
|
||||
tests := [][]byte{
|
||||
{},
|
||||
{65},
|
||||
{65, 66, 67},
|
||||
}
|
||||
|
||||
for _, val := range tests {
|
||||
t.Run("", func(t *testing.T) {
|
||||
bf := NewByteFrame()
|
||||
bf.WriteNullTerminatedBytes(val)
|
||||
bf.Seek(0, io.SeekStart)
|
||||
got := bf.ReadNullTerminatedBytes()
|
||||
if len(got) != len(val) {
|
||||
t.Errorf("Write/ReadNullTerminatedBytes len = %d, want %d", len(got), len(val))
|
||||
return
|
||||
}
|
||||
for i := range got {
|
||||
if got[i] != val[i] {
|
||||
t.Errorf("Write/ReadNullTerminatedBytes[%d] = %d, want %d", i, got[i], val[i])
|
||||
}
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestSeek(t *testing.T) {
|
||||
bf := NewByteFrame()
|
||||
bf.WriteUint32(0x12345678)
|
||||
bf.WriteUint32(0xDEADBEEF)
|
||||
|
||||
// SeekStart
|
||||
pos, err := bf.Seek(0, io.SeekStart)
|
||||
if err != nil {
|
||||
t.Errorf("Seek(0, SeekStart) error = %v", err)
|
||||
}
|
||||
if pos != 0 {
|
||||
t.Errorf("Seek(0, SeekStart) pos = %d, want 0", pos)
|
||||
}
|
||||
|
||||
val := bf.ReadUint32()
|
||||
if val != 0x12345678 {
|
||||
t.Errorf("After Seek(0, SeekStart) ReadUint32() = %x, want 0x12345678", val)
|
||||
}
|
||||
|
||||
// SeekCurrent
|
||||
pos, err = bf.Seek(-4, io.SeekCurrent)
|
||||
if err != nil {
|
||||
t.Errorf("Seek(-4, SeekCurrent) error = %v", err)
|
||||
}
|
||||
if pos != 0 {
|
||||
t.Errorf("Seek(-4, SeekCurrent) pos = %d, want 0", pos)
|
||||
}
|
||||
|
||||
// SeekEnd
|
||||
pos, err = bf.Seek(-4, io.SeekEnd)
|
||||
if err != nil {
|
||||
t.Errorf("Seek(-4, SeekEnd) error = %v", err)
|
||||
}
|
||||
if pos != 4 {
|
||||
t.Errorf("Seek(-4, SeekEnd) pos = %d, want 4", pos)
|
||||
}
|
||||
|
||||
val = bf.ReadUint32()
|
||||
if val != 0xDEADBEEF {
|
||||
t.Errorf("After Seek(-4, SeekEnd) ReadUint32() = %x, want 0xDEADBEEF", val)
|
||||
}
|
||||
}
|
||||
|
||||
func TestSeekErrors(t *testing.T) {
|
||||
bf := NewByteFrame()
|
||||
bf.WriteUint32(0x12345678)
|
||||
|
||||
// Seek beyond end
|
||||
_, err := bf.Seek(100, io.SeekStart)
|
||||
if err == nil {
|
||||
t.Error("Seek(100, SeekStart) should return error")
|
||||
}
|
||||
|
||||
// Seek before start
|
||||
_, err = bf.Seek(-100, io.SeekCurrent)
|
||||
if err == nil {
|
||||
t.Error("Seek(-100, SeekCurrent) should return error")
|
||||
}
|
||||
|
||||
// Seek before start from end
|
||||
_, err = bf.Seek(-100, io.SeekEnd)
|
||||
if err == nil {
|
||||
t.Error("Seek(-100, SeekEnd) should return error")
|
||||
}
|
||||
}
|
||||
|
||||
func TestEndianness(t *testing.T) {
|
||||
// Test big endian (default)
|
||||
bf := NewByteFrame()
|
||||
bf.WriteUint16(0x1234)
|
||||
data := bf.Data()
|
||||
if data[0] != 0x12 || data[1] != 0x34 {
|
||||
t.Errorf("Big endian WriteUint16(0x1234) = %v, want [0x12, 0x34]", data)
|
||||
}
|
||||
|
||||
// Test little endian
|
||||
bf = NewByteFrame()
|
||||
bf.SetLE()
|
||||
bf.WriteUint16(0x1234)
|
||||
data = bf.Data()
|
||||
if data[0] != 0x34 || data[1] != 0x12 {
|
||||
t.Errorf("Little endian WriteUint16(0x1234) = %v, want [0x34, 0x12]", data)
|
||||
}
|
||||
|
||||
// Test switching back to big endian
|
||||
bf = NewByteFrame()
|
||||
bf.SetLE()
|
||||
bf.SetBE()
|
||||
bf.WriteUint16(0x1234)
|
||||
data = bf.Data()
|
||||
if data[0] != 0x12 || data[1] != 0x34 {
|
||||
t.Errorf("Switched back to big endian WriteUint16(0x1234) = %v, want [0x12, 0x34]", data)
|
||||
}
|
||||
}
|
||||
|
||||
func TestDataFromCurrent(t *testing.T) {
|
||||
bf := NewByteFrame()
|
||||
bf.WriteUint8(1)
|
||||
bf.WriteUint8(2)
|
||||
bf.WriteUint8(3)
|
||||
bf.WriteUint8(4)
|
||||
|
||||
bf.Seek(2, io.SeekStart)
|
||||
remaining := bf.DataFromCurrent()
|
||||
|
||||
if len(remaining) != 2 {
|
||||
t.Errorf("DataFromCurrent() len = %d, want 2", len(remaining))
|
||||
}
|
||||
if remaining[0] != 3 || remaining[1] != 4 {
|
||||
t.Errorf("DataFromCurrent() = %v, want [3, 4]", remaining)
|
||||
}
|
||||
}
|
||||
|
||||
func TestBufferGrowth(t *testing.T) {
|
||||
bf := NewByteFrame()
|
||||
|
||||
// Write more data than initial buffer size (4 bytes)
|
||||
for i := 0; i < 100; i++ {
|
||||
bf.WriteUint32(uint32(i))
|
||||
}
|
||||
|
||||
if len(bf.Data()) != 400 {
|
||||
t.Errorf("After writing 100 uint32s, Data() len = %d, want 400", len(bf.Data()))
|
||||
}
|
||||
|
||||
// Verify data integrity
|
||||
bf.Seek(0, io.SeekStart)
|
||||
for i := 0; i < 100; i++ {
|
||||
val := bf.ReadUint32()
|
||||
if val != uint32(i) {
|
||||
t.Errorf("After growth, ReadUint32()[%d] = %d, want %d", i, val, i)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestMultipleWrites(t *testing.T) {
|
||||
bf := NewByteFrame()
|
||||
|
||||
bf.WriteUint8(0x01)
|
||||
bf.WriteUint16(0x0203)
|
||||
bf.WriteUint32(0x04050607)
|
||||
bf.WriteUint64(0x08090A0B0C0D0E0F)
|
||||
|
||||
expected := []byte{
|
||||
0x01,
|
||||
0x02, 0x03,
|
||||
0x04, 0x05, 0x06, 0x07,
|
||||
0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
|
||||
}
|
||||
|
||||
data := bf.Data()
|
||||
if len(data) != len(expected) {
|
||||
t.Errorf("Multiple writes Data() len = %d, want %d", len(data), len(expected))
|
||||
return
|
||||
}
|
||||
|
||||
for i := range expected {
|
||||
if data[i] != expected[i] {
|
||||
t.Errorf("Multiple writes Data()[%d] = %x, want %x", i, data[i], expected[i])
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestReadPanicsOnOverflow(t *testing.T) {
|
||||
defer func() {
|
||||
if r := recover(); r == nil {
|
||||
t.Error("ReadUint32 on empty buffer should panic")
|
||||
}
|
||||
}()
|
||||
|
||||
bf := NewByteFrame()
|
||||
bf.ReadUint32()
|
||||
}
|
||||
|
||||
func TestReadBoolNonZero(t *testing.T) {
|
||||
// Test that any non-zero value is considered true
|
||||
bf := NewByteFrameFromBytes([]byte{0, 1, 2, 255})
|
||||
|
||||
if bf.ReadBool() != false {
|
||||
t.Error("ReadBool(0) should be false")
|
||||
}
|
||||
if bf.ReadBool() != true {
|
||||
t.Error("ReadBool(1) should be true")
|
||||
}
|
||||
if bf.ReadBool() != true {
|
||||
t.Error("ReadBool(2) should be true")
|
||||
}
|
||||
if bf.ReadBool() != true {
|
||||
t.Error("ReadBool(255) should be true")
|
||||
}
|
||||
}
|
||||
|
||||
func TestReadNullTerminatedBytesNoTerminator(t *testing.T) {
|
||||
// Test behavior when there's no null terminator
|
||||
bf := NewByteFrameFromBytes([]byte{65, 66, 67})
|
||||
result := bf.ReadNullTerminatedBytes()
|
||||
|
||||
if len(result) != 0 {
|
||||
t.Errorf("ReadNullTerminatedBytes with no terminator should return empty, got %v", result)
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user