From 256f0202a28de7956efcd675b994602b89299072 Mon Sep 17 00:00:00 2001
From: "sashakoshka@tebibyte.media" <sashakoshka@tebibyte.media>
Date: Sun, 19 Jan 2025 15:52:11 -0500
Subject: [PATCH] Encoding being placed before decoding everywhere makes sense

---
 metadapta.go      | 24 ++++++++++-----------
 metadapta_test.go | 54 +++++++++++++++++++++++------------------------
 2 files changed, 39 insertions(+), 39 deletions(-)

diff --git a/metadapta.go b/metadapta.go
index b80456e..87cf3f3 100644
--- a/metadapta.go
+++ b/metadapta.go
@@ -173,6 +173,18 @@ type incomingMessage struct {
 	payload []byte
 }
 
+func encodeMessageA(writer io.Writer, trans int64, method uint16, data []byte) error {
+	buffer := make([]byte, 12 + len(data))
+	tape.EncodeI64(buffer[:8], trans)
+	tape.EncodeI16(buffer[8:10], method)
+	length, ok := tape.U16CastSafe(len(data))
+	if !ok { return ErrPayloadTooLarge }
+	tape.EncodeI16(buffer[10:12], length)
+	copy(buffer[12:], data)
+	_, err := writer.Write(buffer)
+	return err
+}
+
 func decodeMessageA(reader io.Reader) (int64, uint16, []byte, error) {
 	headerBuffer := [12]byte { }
 	_, err := io.ReadFull(reader, headerBuffer[:])
@@ -189,18 +201,6 @@ func decodeMessageA(reader io.Reader) (int64, uint16, []byte, error) {
 	return transID, method, payloadBuffer, nil
 }
 
-func encodeMessageA(writer io.Writer, trans int64, method uint16, data []byte) error {
-	buffer := make([]byte, 12 + len(data))
-	tape.EncodeI64(buffer[:8], trans)
-	tape.EncodeI16(buffer[8:10], method)
-	length, ok := tape.U16CastSafe(len(data))
-	if !ok { return ErrPayloadTooLarge }
-	tape.EncodeI16(buffer[10:12], length)
-	copy(buffer[12:], data)
-	_, err := writer.Write(buffer)
-	return err
-}
-
 func partyFromTransID(id int64) Party {
 	return id > 0
 }
diff --git a/metadapta_test.go b/metadapta_test.go
index cb39859..85cab0f 100644
--- a/metadapta_test.go
+++ b/metadapta_test.go
@@ -6,6 +6,33 @@ import "errors"
 import "slices"
 import "testing"
 
+func TestEncodeMessageA(test *testing.T) {
+	buffer := new(bytes.Buffer)
+	payload := []byte { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05 }
+	err := encodeMessageA(buffer, 0x5800FEABC3104F04, 0x6B12, payload)
+	correct := []byte {
+		0x58, 0x00, 0xFE, 0xAB, 0xC3, 0x10, 0x4F, 0x04,
+		0x6B, 0x12,
+		0x00, 0x06,
+		0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
+	}
+	if err != nil {
+		test.Fatal(err)
+	}
+	if got, correct := buffer.Bytes(), correct; !slices.Equal(got, correct) {
+		test.Fatalf("not equal: %v %v", got, correct)
+	}
+}
+
+func TestEncodeMessageAErr(test *testing.T) {
+	buffer := new(bytes.Buffer)
+	payload := make([]byte, 0x10000)
+	err := encodeMessageA(buffer, 0x5800FEABC3104F04, 0x6B12, payload)
+	if !errors.Is(err, ErrPayloadTooLarge) {
+		test.Fatalf("wrong error: %v", err)
+	}
+}
+
 func TestDecodeMessageA(test *testing.T) {
 	transID, method, payload, err := decodeMessageA(bytes.NewReader([]byte {
 		0x58, 0x00, 0xFE, 0xAB, 0xC3, 0x10, 0x4F, 0x04,
@@ -39,30 +66,3 @@ func TestDecodeMessageAErr(test *testing.T) {
 		test.Fatalf("wrong error: %v", err)
 	}
 }
-
-func TestEncodeMessageA(test *testing.T) {
-	buffer := new(bytes.Buffer)
-	payload := []byte { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05 }
-	err := encodeMessageA(buffer, 0x5800FEABC3104F04, 0x6B12, payload)
-	correct := []byte {
-		0x58, 0x00, 0xFE, 0xAB, 0xC3, 0x10, 0x4F, 0x04,
-		0x6B, 0x12,
-		0x00, 0x06,
-		0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
-	}
-	if err != nil {
-		test.Fatal(err)
-	}
-	if got, correct := buffer.Bytes(), correct; !slices.Equal(got, correct) {
-		test.Fatalf("not equal: %v %v", got, correct)
-	}
-}
-
-func TestEncodeMessageAErr(test *testing.T) {
-	buffer := new(bytes.Buffer)
-	payload := make([]byte, 0x10000)
-	err := encodeMessageA(buffer, 0x5800FEABC3104F04, 0x6B12, payload)
-	if !errors.Is(err, ErrPayloadTooLarge) {
-		test.Fatalf("wrong error: %v", err)
-	}
-}