package muxer_test import ( "bytes" "encoding/binary" "fmt" "io" "math" "math/rand" "reflect" "strings" "testing" "time" "git.onurgunduz.com/muxer" ) type testCase struct { desc string reads [][]byte expect []any size int } var maxID = uint64(math.Pow(2, 60)) - 1 func TestReadMessage(t *testing.T) { // Run test cases in normal and reversed order. test := func(prefix string, messages []any, bytes [][]byte, bufferSize int) { for _, tt := range makeTestCases(prefix, bufferSize, messages, bytes, io.EOF) { t.Run(tt.desc, func(t *testing.T) { runTest(t, tt) }) } // Reverse. for i := len(messages)/2 - 1; i >= 0; i-- { j := len(messages) - 1 - i messages[i], messages[j] = messages[j], messages[i] bytes[i], bytes[j] = bytes[j], bytes[i] } for _, tt := range makeTestCases(prefix, bufferSize, messages, bytes, io.EOF) { t.Run(tt.desc, func(t *testing.T) { runTest(t, tt) }) } } // Send headers only. func() { var messages []any var bytes [][]byte bufferSize := 16 id := maxID for i := 1; id > 0; id = id / uint64(i*2) { i++ messages = append(messages, newMessage(id, uint8(i%15), 0)) bytes = append(bytes, newBytes(id, uint8(i%15), 0, 0, 0)) } test("header only", messages, bytes, bufferSize) }() // Messages that fill up the entire buffer. func() { var messages []any var bytes [][]byte bufferSize := 16 id := maxID for i := 1; id > 0; id = id / uint64(i*2) { i++ b := newBytes(id, uint8(i%15), 0, 0, 0) messages = append(messages, newMessage(id, uint8(i%15), bufferSize-len(b))) bytes = append(bytes, newBytes(id, uint8(i%15), bufferSize-len(b), 0, 0)) } test("with payload buffer full", messages, bytes, bufferSize) }() // Messages with smaller payloads. func() { var messages []any var bytes [][]byte bufferSize := 16 id := maxID for i := 1; id > 0; id = id / uint64(i*2) { i++ b := newBytes(id, uint8(i%15), 0, 0, 0) messages = append(messages, newMessage(id, uint8(i%15), (bufferSize-len(b))/2)) bytes = append(bytes, newBytes(id, uint8(i%15), (bufferSize-len(b))/2, 0, 0)) } test("with payload buffer half empty", messages, bytes, bufferSize) }() // Arbitrary tests. testCases := []testCase{ { desc: "basic", expect: expecting(newMessage(42, 3, 3), io.EOF), reads: reading(newBytes(42, 3, 3, 0, 0)), size: 16, }, { desc: "smallest header", expect: expecting(newMessage(0, 0, 0), io.EOF), reads: reading(newBytes(0, 0, 0, 0, 0)), size: 16, }, { desc: "smallest header with message", expect: expecting(newMessage(0, 0, 14), io.EOF), reads: reading(newBytes(0, 0, 14, 0, 0)), size: 16, }, { desc: "large header", expect: expecting(newMessage(maxID, 15, 0), io.EOF), reads: reading(newBytes(maxID, 15, 0, 0, 0)), size: 16, }, { desc: "large header with message", expect: expecting(newMessage(maxID, 15, 5), io.EOF), reads: reading(newBytes(maxID, 15, 5, 0, 0)), size: 16, }, { desc: "receive chunked", expect: expecting(newMessage(0, 0, 2), io.EOF), reads: func() [][]byte { payload := newBytes(0, 0, 2, 0, 0) var xs [][]byte for i := range payload { xs = append(xs, payload[i:i+1]) } return reading(xs...) }(), size: 16, }, { desc: "receive chunks in different sizes", expect: expecting(newMessage(42, 3, 130), io.EOF), reads: func() [][]byte { payload := newBytes(42, 3, 130, 0, 0) xs := [][]byte{ payload[0:1], payload[1:3], payload[3:17], payload[17:56], payload[56:89], payload[89:107], payload[107:], } return reading(xs...) }(), size: 256, }, { desc: "receive two in single read", expect: expecting( newMessage(5, 10, 4), newMessage(42, 3, 7), io.EOF, ), reads: func() [][]byte { xs := [][]byte{ newBytes(5, 10, 4, 0, 0), newBytes(42, 3, 7, 0, 0), } return reading(flattened(xs)) }(), size: 16, }, { desc: "receive two with small buffer", expect: expecting( io.ErrShortBuffer, ), reads: func() [][]byte { xs := [][]byte{ newBytes(5, 10, 5, 0, 0), newBytes(42, 3, 7, 0, 0), } return reading(flattened(xs)) }(), size: 16, }, { desc: "receive many in single read", expect: expecting( newMessage(5, 10, 2), newMessage(42, 3, 5), newMessage(27, 1, 8), newMessage(98993, 15, 100), io.EOF, ), reads: func() [][]byte { return reading(flattened([][]byte{ newBytes(5, 10, 2, 0, 0), newBytes(42, 3, 5, 0, 0), newBytes(27, 1, 8, 0, 0), newBytes(98993, 15, 100, 0, 0), })) }(), size: 256, }, { desc: "receive many chunked", expect: expecting( newMessage(5, 10, 2), newMessage(42, 3, 5), newMessage(maxID, 1, 5), io.EOF, ), reads: func() [][]byte { return reading(append( chunksOf(newBytes(5, 10, 2, 0, 0), 1), append( chunksOf(newBytes(42, 3, 5, 0, 0), 2), chunksOf(newBytes(maxID, 1, 5, 0, 0), 1)..., )..., )...) }(), size: 16, }, { desc: "empty write", expect: expecting(io.EOF), }, { desc: "receive two with small buffer", expect: func() []any { return expecting( newMessage(0, 1, 2), io.ErrShortBuffer, ) }(), reads: func() [][]byte { b1 := newBytes(0, 1, 2, 0, 0) b2 := newBytes(42, 3, 14, 0, 0) return reading(b1, b2) }(), size: 16, }, { desc: "receive two chunked with small buffer", expect: func() []any { return expecting( newMessage(0, 1, 2), io.ErrShortBuffer, ) }(), reads: func() [][]byte { b1 := newBytes(0, 1, 2, 0, 0) b2 := newBytes(42, 3, 14, 0, 0) b := append(b1, b2...) xs := chunksOf(b, 2) return reading(xs...) }(), size: 16, }, { desc: "receive many chunked with small buffer", expect: expecting( newMessage(5, 10, 2), newMessage(42, 3, 5), io.ErrShortBuffer, ), reads: func() [][]byte { return reading(append( chunksOf(newBytes(5, 10, 2, 0, 0), 1), append( chunksOf(newBytes(42, 3, 5, 0, 0), 2), chunksOf(newBytes(maxID, 1, 6, 0, 0), 1)..., )..., )...) }(), size: 16, }, { desc: "short buffer", expect: expecting(io.ErrShortBuffer), reads: reading(newBytes(0, 0, 15, 0, 0)), size: 16, }, { desc: "the smallest message to raise no progress error", expect: expecting(io.ErrNoProgress), reads: reading(make([]byte, 2)), size: 16, }, { desc: "the largest message to raise no progress error", expect: expecting(io.ErrNoProgress), reads: reading(make([]byte, 16)), size: 16, }, { desc: "missing the last byte when closed", expect: expecting(io.ErrUnexpectedEOF), reads: reading(newBytes(0, 0, 14, 0, 15)), size: 16, }, { desc: "missing bytes while buffer is full", expect: expecting(io.ErrShortBuffer), reads: reading(newBytes(0, 0, 15, 0, 12)), size: 16, }, { desc: "missing the last byte after many chunked", expect: expecting( newMessage(5, 10, 2), newMessage(42, 3, 5), io.ErrUnexpectedEOF, ), reads: func() [][]byte { return reading(append( chunksOf(newBytes(5, 10, 2, 0, 0), 1), append( chunksOf(newBytes(42, 3, 5, 0, 0), 2), chunksOf(newBytes(0, 0, 14, 0, 15), 1)..., )..., )...) }(), size: 16, }, { desc: "missing the last byte after single read", expect: expecting( newMessage(5, 10, 2), io.ErrUnexpectedEOF, ), reads: reading(newBytes(5, 10, 2, 0, 0), newBytes(0, 0, 14, 0, 15)), size: 16, }, { desc: "missing bytes after single read", expect: expecting( newMessage(5, 10, 2), io.ErrUnexpectedEOF, ), reads: func() [][]byte { xs := reading(newBytes(5, 10, 2, 0, 0), newBytes(maxID, 0, 5, 0, 1)) return xs }(), size: 16, }, { desc: "missing bytes after single read with no payload", expect: expecting( newMessage(5, 10, 2), io.ErrUnexpectedEOF, ), reads: func() [][]byte { xs := reading(newBytes(5, 10, 2, 0, 0), newBytes(0, 0, 0, 0, 1)) return xs }(), size: 16, }, { desc: "max consecutive reads reached", expect: expecting( newMessage(5, 10, 2), io.ErrNoProgress, ), reads: func() [][]byte { xs := chunksOf(newBytes(5, 10, 2, 0, 0), 2) for range 100 { xs = append(xs, make([]byte, 0)) } return xs }(), size: 16, }, { desc: "receive big messages chunked", expect: expecting( newMessage(42, 3, 1e5), newMessage(maxID, 1, 1e5), io.EOF, ), reads: func() [][]byte { xs := reading(append( chunksOf(newBytes(42, 3, 1e5, 0, 0), 2048), chunksOf(newBytes(maxID, 1, 1e5, 0, 0), 3052)..., )...) return xs }(), size: 1e5 + 4096, }, } start := 0 for _, tt := range testCases[start:] { t.Run(tt.desc, func(t *testing.T) { runTest(t, tt) }) } } type testReader struct { q [][]byte } func (r *testReader) Read(p []byte) (n int, err error) { if len(r.q) < 1 { return 0, io.EOF } b := r.q[0] r.q = r.q[1:] copy(p, b) return len(b), nil } func reader(q [][]byte, size int) *muxer.Reader { return muxer.NewReaderSize(&testReader{q: q}, size) } func newMessage(id uint64, ch uint8, l int) *muxer.Message { return &muxer.Message{ ID: id, Type: ch, Data: []byte(fill(l)), } } func newBytes(id uint64, ch uint8, l int, start, end int) []byte { out := send(id, ch, []byte(fill(l))) if end == 0 { return out[start:] } else { return out[start:end] } } func fill(times int) string { var s strings.Builder chars := "abcdefghijklmnopqrstuvwxyz" for i := range times { pos := i % len(chars) s.WriteString(chars[pos : pos+1]) } return s.String() } func runTest(t *testing.T, tt testCase) { r := reader(tt.reads, tt.size) if len(tt.expect) < 1 { panic("must expect a result") } m := &muxer.Message{} for _, v := range tt.expect { err := r.ReadMessage(m) if expectedErr, ok := v.(error); ok { if err == nil || err.Error() != expectedErr.Error() { t.Fatalf("%s: expected error %v, got %v", tt.desc, expectedErr, err) } } else { if err != nil { t.Fatalf("%s: expected message %v, got error %v", tt.desc, v, err) } if expectedMessage, ok := v.(*muxer.Message); ok { if !reflect.DeepEqual(expectedMessage, m) { t.Fatalf("%s: expected message %v, got %v", tt.desc, expectedMessage, m) } } else { t.Fail() } } } } func makeTestCases(prefix string, bufferSize int, messages []any, bytes [][]byte, expectedErr error) (testCases []testCase) { for i := range messages { testCases = append(testCases, testCase{ desc: fmt.Sprintf("%s single read %d", prefix, i), expect: expecting(messages[i], expectedErr), reads: reading(bytes[i]), size: bufferSize, }) } expected := expecting(append(messages, expectedErr)...) testCases = append(testCases, testCase{ desc: fmt.Sprintf("%s multiple reads", prefix), expect: expected, reads: bytes, size: bufferSize, }) flattenedBytes := flattened(bytes) for i := 1; i < 12; i++ { testCases = append(testCases, testCase{ desc: fmt.Sprintf("%s multiple reads chunked %d", prefix, i), expect: expected, reads: chunksOf(flattenedBytes, i), size: bufferSize, }) } testCases = append(testCases, testCase{ desc: fmt.Sprintf("%s single read many messages", prefix), expect: expected, reads: reading(flattenedBytes), size: len(flattenedBytes), }) testCases = append(testCases, testCase{ desc: fmt.Sprintf("%s randomly chunked", prefix), expect: expected, reads: randomChunksOf(flattenedBytes, 1, 11), size: bufferSize, }) return } func flattened(xs [][]byte) []byte { if len(xs) < 1 { panic("invalid argument") } ret := xs[0] if len(xs) == 1 { return ret } for _, x := range xs[1:] { ret = append(ret, x...) } return ret } func chunksOf(xs []byte, chunkSize int) [][]byte { if len(xs) == 0 || chunkSize == 0 { panic("invalid argument") } divided := make([][]byte, (len(xs)+chunkSize-1)/chunkSize) prev := 0 i := 0 till := len(xs) - chunkSize for prev < till { next := prev + chunkSize divided[i] = xs[prev:next] prev = next i++ } divided[i] = xs[prev:] return divided } func randomChunksOf(b []byte, min, max int) [][]byte { if min > len(b) || max <= min || max > len(b) { panic("invalid args") } var out [][]byte for len(b) > 0 { random := int(math.Min(float64(rand.Intn(max-min)+min), float64(len(b)))) out = append(out, b[0:random]) b = b[random:] } return out } func reading(xs ...[]byte) [][]byte { return xs } func expecting(xs ...any) []any { return xs } func init() { rand.Seed(time.Now().UnixNano()) } var ( n1 = uint64(math.Pow(2, 7)) n2 = uint64(math.Pow(2, 14)) n3 = uint64(math.Pow(2, 21)) n4 = uint64(math.Pow(2, 28)) n5 = uint64(math.Pow(2, 35)) n6 = uint64(math.Pow(2, 42)) n7 = uint64(math.Pow(2, 49)) n8 = uint64(math.Pow(2, 56)) n9 = uint64(math.Pow(2, 63)) ) func encodingLength(i uint64) int { if i < n1 { return 1 } else if i < n2 { return 2 } else if i < n3 { return 3 } else if i < n4 { return 4 } else if i < n5 { return 5 } else if i < n6 { return 6 } else if i < n7 { return 7 } else if i < n8 { return 8 } else if i < n9 { return 9 } return 10 } func send(id uint64, ch uint8, data []byte) []byte { if id > maxID { panic("muxer: ID too big") } header := id<<4 | uint64(ch) length := len(data) + encodingLength(header) payload := make([]byte, encodingLength(uint64(length))+length) n := binary.PutUvarint(payload, uint64(length)) n += binary.PutUvarint(payload[n:], header) copy(payload[n:], data) return payload } func TestReaderReset(t *testing.T) { initialData := newBytes(42, 3, 5, 0, 0) r := muxer.NewReaderSize(bytes.NewReader(initialData), 64) m := &muxer.Message{} err := r.ReadMessage(m) if err != nil { t.Fatalf("expected message %v, got error %v", initialData, err) } if m.ID != 42 || m.Type != 3 || len(m.Data) != 5 { t.Fatalf("expected message with ID=42, Type=3, Data length=5, got ID=%d, Type=%d, Data length=%d", m.ID, m.Type, len(m.Data)) } newData := newBytes(99, 7, 10, 0, 0) r.Reset(bytes.NewReader(newData)) err = r.ReadMessage(m) if err != nil { t.Fatalf("expected message %v, got error %v", newData, err) } if m.ID != 99 || m.Type != 7 || len(m.Data) != 10 { t.Fatalf("expected message with ID=99, Type=7, Data length=10, got ID=%d, Type=%d, Data length=%d", m.ID, m.Type, len(m.Data)) } } func TestReaderResetNilBuffer(t *testing.T) { r := &muxer.Reader{} data := newBytes(42, 3, 5, 0, 0) r.Reset(bytes.NewReader(data)) m := &muxer.Message{} err := r.ReadMessage(m) if err != nil { t.Fatalf("expected message %v, got error %v", data, err) } if m.ID != 42 || m.Type != 3 || len(m.Data) != 5 { t.Fatalf("expected message with ID=42, Type=3, Data length=5, got ID=%d, Type=%d, Data length=%d", m.ID, m.Type, len(m.Data)) } } // Test varint overflow: header varint with 11 continuation bytes triggers ErrMessageMalformed. // A valid 1-byte length varint is followed by 11 bytes with the continuation bit set. // readVarint processes all 11 bytes in one pass, then the consumed >= 11 check fires. func TestReadVarintOverflow(t *testing.T) { buf := make([]byte, 12) buf[0] = 20 // valid length varint (single byte, < 128) for i := 1; i <= 11; i++ { buf[i] = 0xFF // continuation bit set } r := muxer.NewReaderSize(bytes.NewReader(buf), 64) m := &muxer.Message{} err := r.ReadMessage(m) if err != muxer.ErrMessageMalformed { t.Fatalf("expected error %v, got %v", muxer.ErrMessageMalformed, err) } } // Test message size exceeding max func TestMessageSizeExceeded(t *testing.T) { maxSize := 8 * 1024 * 1024 buf := make([]byte, 20) totalLen := uint64(maxSize + 1000) n := binary.PutUvarint(buf, totalLen) header := uint64(42<<4 | 3) n += binary.PutUvarint(buf[n:], header) r := muxer.NewReaderSize(bytes.NewReader(buf[:n]), 4096) m := &muxer.Message{} err := r.ReadMessage(m) if err != muxer.ErrMessageSizeExceeded { t.Fatalf("expected error %v, got %v", muxer.ErrMessageSizeExceeded, err) } }