backup/showbridge-go
1
0
Fork 0
mirror of https://github.com/jwetzell/showbridge-go.git synced 2026-04-26 21:05:30 +00:00
Code Issues Packages Projects Releases Wiki Activity

move tests to sub folders

Browse Source
This commit is contained in:
Joel Wetzell
2026-02-09 14:38:13 -06:00
parent 3c6d98638e
commit 7015a9d7a2
22 changed files with 0 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
internal/framer/test/framer_test.go Normal file
View File

@@ -0,0 +1,15 @@
package framer_test
import (
"testing"
"github.com/jwetzell/showbridge-go/internal/framer"
)
func TestNilGetFramer(t *testing.T) {
nilFramer := framer.GetFramer("asldfiudchuehrkbjbkjrbb")
if nilFramer != nil {
t.Fatalf("Expected nil framer, got %v", nilFramer)
}
}

78
internal/framer/test/raw_test.go Normal file
View File

@@ -0,0 +1,78 @@
package framer_test
import (
"slices"
"testing"
"github.com/jwetzell/showbridge-go/internal/framer"
)
func TestGoodRawFramerDecode(t *testing.T) {
tests := []struct {
name string
framer framer.Framer
input []byte
expected [][]byte
}{
{
name: "basic raw framer",
framer: framer.GetFramer("RAW"),
input: []byte("Hello\nWorld\nThis is a test\n"),
expected: [][]byte{
[]byte("Hello\nWorld\nThis is a test\n"),
},
},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
frames := test.framer.Decode(test.input)
if len(frames) != len(test.expected) {
t.Fatalf("raw framer got %d frames, expected %d", len(frames), len(test.expected))
}
for i, frame := range frames {
if !slices.Equal(frame, test.expected[i]) {
t.Errorf("raw framer frame %d got %s, expected %s", i, frame, test.expected[i])
}
}
})
}
}
func TestGoodRawFramerEncode(t *testing.T) {
tests := []struct {
name string
framer framer.Framer
expected []byte
input []byte
}{
{
name: "basic raw framer",
framer: framer.GetFramer("RAW"),
expected: []byte("Hello\nWorld\nThis is a test\n"),
input: []byte("Hello\nWorld\nThis is a test\n"),
},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
frame := test.framer.Encode(test.input)
if !slices.Equal(frame, test.expected) {
t.Fatalf("raw frame encode got %s, expected %s", frame, test.expected)
}
})
}
}
func TestRawFramerBuffer(t *testing.T) {
framer := framer.GetFramer("RAW")
framer.Decode([]byte("Hello, World!"))
if !slices.Equal(framer.Buffer(), []byte{}) {
t.Fatalf("raw framer buffer got %s, expected empty", framer.Buffer())
}
framer.Clear()
if !slices.Equal(framer.Buffer(), []byte{}) {
t.Fatalf("raw framer buffer got %s, expected empty after clear", framer.Buffer())
}
}

130
internal/framer/test/separator_test.go Normal file
View File

@@ -0,0 +1,130 @@
package framer_test
import (
"slices"
"testing"
"github.com/jwetzell/showbridge-go/internal/framer"
)
func TestGoodSeparatorFramerDecode(t *testing.T) {
tests := []struct {
name string
framer framer.Framer
input []byte
expected [][]byte
buffer []byte
}{
{
name: "new line separator",
framer: framer.GetFramer("LF"),
input: []byte("Hello\nWorld\nThis is a test\n"),
expected: [][]byte{
[]byte("Hello"),
[]byte("World"),
[]byte("This is a test"),
},
buffer: []byte{},
},
{
name: "CR separator",
framer: framer.GetFramer("CR"),
input: []byte("Hello\rWorld\rThis is a test\r"),
expected: [][]byte{
[]byte("Hello"),
[]byte("World"),
[]byte("This is a test"),
},
buffer: []byte{},
},
{
name: "CRLF separator",
framer: framer.GetFramer("CRLF"),
input: []byte("Hello\r\nWorld\r\nThis is a test\r\n"),
expected: [][]byte{
[]byte("Hello"),
[]byte("World"),
[]byte("This is a test"),
},
buffer: []byte{},
},
{
name: "extra data after separator",
framer: framer.GetFramer("CRLF"),
input: []byte("Hello\r\nWorld\r\nThis is a test\r\nextra"),
expected: [][]byte{
[]byte("Hello"),
[]byte("World"),
[]byte("This is a test"),
},
buffer: []byte("extra"),
},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
frames := test.framer.Decode(test.input)
if len(frames) != len(test.expected) {
t.Fatalf("separator framer got %d frames, expected %d", len(frames), len(test.expected))
}
for i, frame := range frames {
if !slices.Equal(frame, test.expected[i]) {
t.Errorf("separator framer frame %d got %s, expected %s", i, frame, test.expected[i])
}
}
if !slices.Equal(test.framer.Buffer(), test.buffer) {
t.Fatalf("separator framer buffer got %s, expected %s", test.framer.Buffer(), test.buffer)
}
})
}
}
func TestGoodSeparatorFramerEncode(t *testing.T) {
tests := []struct {
name string
framer framer.Framer
input []byte
expected []byte
}{
{
name: "new line separator",
framer: framer.GetFramer("LF"),
input: []byte("Hello"),
expected: []byte("Hello\n"),
},
{
name: "CR separator",
framer: framer.GetFramer("CR"),
input: []byte("Hello"),
expected: []byte("Hello\r"),
},
{
name: "CRLF separator",
framer: framer.GetFramer("CRLF"),
input: []byte("Hello"),
expected: []byte("Hello\r\n"),
},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
frame := test.framer.Encode(test.input)
if !slices.Equal(frame, test.expected) {
t.Fatalf("separator framer got %s, expected %s", frame, test.expected)
}
})
}
}
func TestSeparatorFrameBuffer(t *testing.T) {
framer := framer.GetFramer("LF")
framer.Decode([]byte("Hello\nWorld\nThis is a test\nextra"))
if !slices.Equal(framer.Buffer(), []byte("extra")) {
t.Fatalf("separator framer buffer got %s, expected %s", framer.Buffer(), []byte("extra"))
}
framer.Clear()
if !slices.Equal(framer.Buffer(), []byte{}) {
t.Fatalf("separator framer buffer got %s, expected empty slice", framer.Buffer())
}
}

110
internal/framer/test/slip_test.go Normal file
View File

@@ -0,0 +1,110 @@
package framer_test
import (
"slices"
"testing"
"github.com/jwetzell/showbridge-go/internal/framer"
)
func TestGoodSLIPFramerDecode(t *testing.T) {
tests := []struct {
name string
framer framer.Framer
input []byte
expected [][]byte
buffer []byte
}{
{
name: "OSC SLIP messages",
framer: framer.GetFramer("SLIP"),
input: []byte{0xc0, 0x2f, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x00, 0x00, 0x2c, 0x00, 0x00, 0x00, 0xc0},
expected: [][]byte{
{0x2f, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x00, 0x00, 0x2c, 0x00, 0x00, 0x00},
},
buffer: []byte{},
},
{
name: "SLIP decode escaped end",
framer: framer.GetFramer("SLIP"),
expected: [][]byte{{0xc0}},
input: []byte{0xc0, 0xdb, 0xdc, 0xc0},
buffer: []byte{},
},
{
name: "SLIP decode escaped escape",
framer: framer.GetFramer("SLIP"),
expected: [][]byte{{0xdb}},
input: []byte{0xc0, 0xdb, 0xdd, 0xc0},
buffer: []byte{},
},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
frames := test.framer.Decode(test.input)
if len(frames) != len(test.expected) {
t.Fatalf("SLIP framer got %d frames, expected %d", len(frames), len(test.expected))
}
for i, frame := range frames {
if !slices.Equal(frame, test.expected[i]) {
t.Errorf("SLIP framer frame %d got %s, expected %s", i, frame, test.expected[i])
}
}
if !slices.Equal(test.framer.Buffer(), test.buffer) {
t.Fatalf("SLIP framer buffer got %s, expected %s", test.framer.Buffer(), test.buffer)
}
})
}
}
func TestGoodSLIPFramerEncode(t *testing.T) {
tests := []struct {
name string
framer framer.Framer
input []byte
expected []byte
}{
{
name: "OSC SLIP messages",
framer: framer.GetFramer("SLIP"),
input: []byte{
0x2f, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x00, 0x00, 0x2c, 0x00, 0x00, 0x00,
},
expected: []byte{0xc0, 0x2f, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x00, 0x00, 0x2c, 0x00, 0x00, 0x00, 0xc0},
},
{
name: "SLIP encode end",
framer: framer.GetFramer("SLIP"),
input: []byte{0xc0},
expected: []byte{0xc0, 0xdb, 0xdc, 0xc0},
},
{
name: "SLIP encode esc",
framer: framer.GetFramer("SLIP"),
input: []byte{0xdb},
expected: []byte{0xc0, 0xdb, 0xdd, 0xc0},
},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
frame := test.framer.Encode(test.input)
if !slices.Equal(frame, test.expected) {
t.Fatalf("SLIP framer frame got %s, expected %s", frame, test.expected)
}
})
}
}
func TestSlipFramerBuffer(t *testing.T) {
framer := framer.GetFramer("SLIP")
framer.Decode([]byte{0xc0, 0x2f, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x00, 0x00, 0x2c, 0x00, 0x00, 0x00, 0xc0, 0xc0, 0x45})
if !slices.Equal(framer.Buffer(), []byte{0x45}) {
t.Fatalf("SLIP framer buffer got %s, expected %s", framer.Buffer(), []byte{0x45})
}
framer.Clear()
if !slices.Equal(framer.Buffer(), []byte{}) {
t.Fatalf("SLIP framer buffer got %s, expected empty slice", framer.Buffer())
}
}