From 7dd6d45a08761afab1bf885da00cd23ba92e1dbe Mon Sep 17 00:00:00 2001 From: Joel Wetzell Date: Fri, 17 Oct 2025 12:42:17 -0500 Subject: [PATCH] add tests for encoding data tracker fields --- .../encoders/data_tracker_accel_chunk_test.go | 40 +++++++++++++++++++ .../encoders/data_tracker_ori_chunk_test.go | 40 +++++++++++++++++++ .../encoders/data_tracker_pos_chunk_test.go | 40 +++++++++++++++++++ .../encoders/data_tracker_speed_chunk_test.go | 40 +++++++++++++++++++ .../data_tracker_status_chunk_test.go | 38 ++++++++++++++++++ .../data_tracker_timestamp_chunk_test.go | 38 ++++++++++++++++++ .../data_tracker_trgtpos_chunk_test.go | 40 +++++++++++++++++++ 7 files changed, 276 insertions(+) create mode 100644 internal/encoders/data_tracker_accel_chunk_test.go create mode 100644 internal/encoders/data_tracker_ori_chunk_test.go create mode 100644 internal/encoders/data_tracker_pos_chunk_test.go create mode 100644 internal/encoders/data_tracker_speed_chunk_test.go create mode 100644 internal/encoders/data_tracker_status_chunk_test.go create mode 100644 internal/encoders/data_tracker_timestamp_chunk_test.go create mode 100644 internal/encoders/data_tracker_trgtpos_chunk_test.go diff --git a/internal/encoders/data_tracker_accel_chunk_test.go b/internal/encoders/data_tracker_accel_chunk_test.go new file mode 100644 index 0000000..40af5e7 --- /dev/null +++ b/internal/encoders/data_tracker_accel_chunk_test.go @@ -0,0 +1,40 @@ +package encoders + +import ( + "fmt" + "reflect" + "testing" + + "github.com/jwetzell/psn-go/internal/decoders" +) + +func TestDataTrackerAccelChunkEncoding(t *testing.T) { + testCases := []struct { + description string + expected []byte + data decoders.DataTrackerXYZChunkData + }{ + { + description: "basic acceleration", + expected: []byte{ + 4, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, + }, + data: decoders.DataTrackerXYZChunkData{ + X: 1, + Y: 2, + Z: 3, + }, + }, + } + + for _, testCase := range testCases { + + actual := EncodeDataTrackerAccelChunk(testCase.data.X, testCase.data.Y, testCase.data.Z) + + if !reflect.DeepEqual(actual, testCase.expected) { + t.Errorf("Test '%s' failed to encode chunk properly", testCase.description) + fmt.Printf("expected: %v\n", testCase.expected) + fmt.Printf("actual: %v\n", actual) + } + } +} diff --git a/internal/encoders/data_tracker_ori_chunk_test.go b/internal/encoders/data_tracker_ori_chunk_test.go new file mode 100644 index 0000000..dd8c8fb --- /dev/null +++ b/internal/encoders/data_tracker_ori_chunk_test.go @@ -0,0 +1,40 @@ +package encoders + +import ( + "fmt" + "reflect" + "testing" + + "github.com/jwetzell/psn-go/internal/decoders" +) + +func TestDataTrackerOriChunkEncoding(t *testing.T) { + testCases := []struct { + description string + expected []byte + data decoders.DataTrackerXYZChunkData + }{ + { + description: "basic orientation", + expected: []byte{ + 2, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, + }, + data: decoders.DataTrackerXYZChunkData{ + X: 1, + Y: 2, + Z: 3, + }, + }, + } + + for _, testCase := range testCases { + + actual := EncodeDataTrackerOriChunk(testCase.data.X, testCase.data.Y, testCase.data.Z) + + if !reflect.DeepEqual(actual, testCase.expected) { + t.Errorf("Test '%s' failed to encode chunk properly", testCase.description) + fmt.Printf("expected: %v\n", testCase.expected) + fmt.Printf("actual: %v\n", actual) + } + } +} diff --git a/internal/encoders/data_tracker_pos_chunk_test.go b/internal/encoders/data_tracker_pos_chunk_test.go new file mode 100644 index 0000000..99b5365 --- /dev/null +++ b/internal/encoders/data_tracker_pos_chunk_test.go @@ -0,0 +1,40 @@ +package encoders + +import ( + "fmt" + "reflect" + "testing" + + "github.com/jwetzell/psn-go/internal/decoders" +) + +func TestDataTrackerPosChunkEncoding(t *testing.T) { + testCases := []struct { + description string + expected []byte + data decoders.DataTrackerXYZChunkData + }{ + { + description: "basic position", + expected: []byte{ + 0, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, + }, + data: decoders.DataTrackerXYZChunkData{ + X: 1, + Y: 2, + Z: 3, + }, + }, + } + + for _, testCase := range testCases { + + actual := EncodeDataTrackerPosChunk(testCase.data.X, testCase.data.Y, testCase.data.Z) + + if !reflect.DeepEqual(actual, testCase.expected) { + t.Errorf("Test '%s' failed to encode chunk properly", testCase.description) + fmt.Printf("expected: %v\n", testCase.expected) + fmt.Printf("actual: %v\n", actual) + } + } +} diff --git a/internal/encoders/data_tracker_speed_chunk_test.go b/internal/encoders/data_tracker_speed_chunk_test.go new file mode 100644 index 0000000..61bc902 --- /dev/null +++ b/internal/encoders/data_tracker_speed_chunk_test.go @@ -0,0 +1,40 @@ +package encoders + +import ( + "fmt" + "reflect" + "testing" + + "github.com/jwetzell/psn-go/internal/decoders" +) + +func TestDataTrackerSpeedChunkEncoding(t *testing.T) { + testCases := []struct { + description string + expected []byte + data decoders.DataTrackerXYZChunkData + }{ + { + description: "basic speed", + expected: []byte{ + 1, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, + }, + data: decoders.DataTrackerXYZChunkData{ + X: 1, + Y: 2, + Z: 3, + }, + }, + } + + for _, testCase := range testCases { + + actual := EncodeDataTrackerSpeedChunk(testCase.data.X, testCase.data.Y, testCase.data.Z) + + if !reflect.DeepEqual(actual, testCase.expected) { + t.Errorf("Test '%s' failed to encode chunk properly", testCase.description) + fmt.Printf("expected: %v\n", testCase.expected) + fmt.Printf("actual: %v\n", actual) + } + } +} diff --git a/internal/encoders/data_tracker_status_chunk_test.go b/internal/encoders/data_tracker_status_chunk_test.go new file mode 100644 index 0000000..faeb2f2 --- /dev/null +++ b/internal/encoders/data_tracker_status_chunk_test.go @@ -0,0 +1,38 @@ +package encoders + +import ( + "fmt" + "reflect" + "testing" + + "github.com/jwetzell/psn-go/internal/decoders" +) + +func TestDataTrackerStatusChunkEncoding(t *testing.T) { + testCases := []struct { + description string + expected []byte + data decoders.DataTrackerStatusChunkData + }{ + { + description: "basic status", + expected: []byte{ + 3, 0, 4, 0, 0, 0, 128, 63, + }, + data: decoders.DataTrackerStatusChunkData{ + Validity: 1, + }, + }, + } + + for _, testCase := range testCases { + + actual := EncodeDataTrackerStatusChunk(testCase.data.Validity) + + if !reflect.DeepEqual(actual, testCase.expected) { + t.Errorf("Test '%s' failed to encode chunk properly", testCase.description) + fmt.Printf("expected: %v\n", testCase.expected) + fmt.Printf("actual: %v\n", actual) + } + } +} diff --git a/internal/encoders/data_tracker_timestamp_chunk_test.go b/internal/encoders/data_tracker_timestamp_chunk_test.go new file mode 100644 index 0000000..7d2569b --- /dev/null +++ b/internal/encoders/data_tracker_timestamp_chunk_test.go @@ -0,0 +1,38 @@ +package encoders + +import ( + "fmt" + "reflect" + "testing" + + "github.com/jwetzell/psn-go/internal/decoders" +) + +func TestDataTrackerTimestampChunkEncoding(t *testing.T) { + testCases := []struct { + description string + expected []byte + data decoders.DataTrackerTimestampChunkData + }{ + { + description: "basic timestamp", + expected: []byte{ + 6, 0, 8, 0, 210, 2, 150, 73, 0, 0, 0, 0, + }, + data: decoders.DataTrackerTimestampChunkData{ + Timestamp: 1234567890, + }, + }, + } + + for _, testCase := range testCases { + + actual := EncodeDataTrackerTimestampChunk(testCase.data.Timestamp) + + if !reflect.DeepEqual(actual, testCase.expected) { + t.Errorf("Test '%s' failed to encode chunk properly", testCase.description) + fmt.Printf("expected: %v\n", testCase.expected) + fmt.Printf("actual: %v\n", actual) + } + } +} diff --git a/internal/encoders/data_tracker_trgtpos_chunk_test.go b/internal/encoders/data_tracker_trgtpos_chunk_test.go new file mode 100644 index 0000000..624a862 --- /dev/null +++ b/internal/encoders/data_tracker_trgtpos_chunk_test.go @@ -0,0 +1,40 @@ +package encoders + +import ( + "fmt" + "reflect" + "testing" + + "github.com/jwetzell/psn-go/internal/decoders" +) + +func TestDataTrackerTrgtPosChunkEncoding(t *testing.T) { + testCases := []struct { + description string + expected []byte + data decoders.DataTrackerXYZChunkData + }{ + { + description: "basic target position", + expected: []byte{ + 5, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, + }, + data: decoders.DataTrackerXYZChunkData{ + X: 1, + Y: 2, + Z: 3, + }, + }, + } + + for _, testCase := range testCases { + + actual := EncodeDataTrackerTrgtPosChunk(testCase.data.X, testCase.data.Y, testCase.data.Z) + + if !reflect.DeepEqual(actual, testCase.expected) { + t.Errorf("Test '%s' failed to encode chunk properly", testCase.description) + fmt.Printf("expected: %v\n", testCase.expected) + fmt.Printf("actual: %v\n", actual) + } + } +}