aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorOnur Gündüz <ogunduz@gmail.com>2026-02-10 13:55:16 +0100
committerOnur Gündüz <ogunduz@gmail.com>2026-02-10 13:55:16 +0100
commiteb2aedac336c9d7b98d1238af4d4185a943157d0 (patch)
tree882540987d3ebae2233083110875b952e081463a
parente04a00a428fcc0062aee13a64f02abd3f582484a (diff)
downloadmuxer-eb2aedac336c9d7b98d1238af4d4185a943157d0.tar.gz
muxer-eb2aedac336c9d7b98d1238af4d4185a943157d0.zip
Add more tests
-rw-r--r--reader_test.go69
-rw-r--r--writer_test.go78
2 files changed, 144 insertions, 3 deletions
diff --git a/reader_test.go b/reader_test.go
index e908838..e1404da 100644
--- a/reader_test.go
+++ b/reader_test.go
@@ -1,11 +1,13 @@
package binproto_test
import (
+ "bytes"
"encoding/binary"
"fmt"
"io"
"math"
"math/rand"
+ "strings"
"testing"
"time"
@@ -444,13 +446,13 @@ func newBytes(id uint64, ch uint8, l int, start, end int) []byte {
}
func fill(times int) string {
- s := ""
+ var s strings.Builder
chars := "abcdefghijklmnopqrstuvwxyz"
for i := 0; i < times; i++ {
pos := i % len(chars)
- s += chars[pos : pos+1]
+ s.WriteString(chars[pos : pos+1])
}
- return s
+ return s.String()
}
func runTest(t *testing.T, tt testCase) {
@@ -625,3 +627,64 @@ func send(id uint64, ch uint8, data []byte) []byte {
copy(payload[n:], data)
return payload
}
+
+func TestReaderReset(t *testing.T) {
+ initialData := newBytes(42, 3, 5, 0, 0)
+ r := binproto.NewReaderSize(bytes.NewReader(initialData), 64)
+
+ m := &binproto.Message{}
+ err := r.ReadMessage(m)
+ assert.NoError(t, err)
+ assert.Equal(t, uint64(42), m.ID)
+
+ newData := newBytes(99, 7, 10, 0, 0)
+ r.Reset(bytes.NewReader(newData))
+
+ err = r.ReadMessage(m)
+ assert.NoError(t, err)
+ assert.Equal(t, uint64(99), m.ID)
+ assert.Equal(t, uint8(7), m.Channel)
+ assert.Equal(t, 10, len(m.Data))
+}
+
+func TestReaderResetNilBuffer(t *testing.T) {
+ r := &binproto.Reader{}
+ data := newBytes(42, 3, 5, 0, 0)
+ r.Reset(bytes.NewReader(data))
+
+ m := &binproto.Message{}
+ err := r.ReadMessage(m)
+ assert.NoError(t, err)
+ assert.Equal(t, uint64(42), m.ID)
+}
+
+// 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 := binproto.NewReaderSize(bytes.NewReader(buf), 64)
+ m := &binproto.Message{}
+ err := r.ReadMessage(m)
+ assert.Equal(t, binproto.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 := binproto.NewReaderSize(bytes.NewReader(buf[:n]), 4096)
+ m := &binproto.Message{}
+ err := r.ReadMessage(m)
+ assert.Equal(t, binproto.ErrMessageSizeExceeded, err)
+}
diff --git a/writer_test.go b/writer_test.go
index 9f20f80..90392d1 100644
--- a/writer_test.go
+++ b/writer_test.go
@@ -3,8 +3,11 @@ package binproto_test
import (
"bufio"
"bytes"
+ "errors"
+ "io"
"testing"
+ "github.com/stretchr/testify/assert"
"github.com/tetsuo/binproto"
)
@@ -26,3 +29,78 @@ func TestSendBatch(t *testing.T) {
t.Fatalf("s=%q; err=%s", s, err)
}
}
+
+func TestWriteMessageNilData(t *testing.T) {
+ buf := new(bytes.Buffer)
+ bw := bufio.NewWriter(buf)
+ w := binproto.NewWriter(bw)
+
+ msg := binproto.NewMessage(100, 5, nil)
+ err := w.WriteMessage(msg)
+ assert.NoError(t, err)
+
+ r := binproto.NewReaderSize(bytes.NewReader(buf.Bytes()), 64)
+ m := &binproto.Message{}
+ err = r.ReadMessage(m)
+ assert.NoError(t, err)
+ assert.Equal(t, uint64(100), m.ID)
+ assert.Equal(t, uint8(5), m.Channel)
+ assert.Equal(t, 0, len(m.Data))
+}
+
+func TestConnClose(t *testing.T) {
+ type mockConn struct {
+ *bytes.Buffer
+ closed bool
+ }
+
+ buf := &mockConn{Buffer: &bytes.Buffer{}}
+
+ data := []byte{0x04, 0xa3, 0x05, 'a', 'b'}
+ buf.Write(data)
+
+ conn := binproto.NewConn(struct {
+ io.Reader
+ io.Writer
+ io.Closer
+ }{
+ Reader: buf,
+ Writer: buf,
+ Closer: io.NopCloser(buf),
+ })
+
+ err := conn.Close()
+ assert.NoError(t, err)
+}
+
+// Test Send error path when WriteMessage fails
+type failWriter struct {
+ *bytes.Buffer
+}
+
+func (f *failWriter) Close() error {
+ return nil
+}
+
+func (f *failWriter) Read(p []byte) (int, error) {
+ return 0, io.EOF
+}
+
+func (f *failWriter) Write(p []byte) (int, error) {
+ return 0, errors.New("write failed")
+}
+
+func TestSendWriteError(t *testing.T) {
+ fw := &failWriter{Buffer: &bytes.Buffer{}}
+ conn := binproto.NewConn(fw)
+
+ msg := binproto.NewMessage(42, 3, []byte("test"))
+ _, err := conn.Send(msg)
+ assert.Error(t, err)
+ assert.Contains(t, err.Error(), "write failed")
+}
+
+func TestDialError(t *testing.T) {
+ _, err := binproto.Dial("tcp", "invalid:99999999")
+ assert.Error(t, err)
+}