Add test workflow

Update readme file with badges

.forgejo/workflows/test.yml

@@ -0,0 +1,16 @@
+on: [push]
+jobs:
+  build:
+    runs-on: docker
+    steps:
+      # Step 1: Check out the code
+      - uses: actions/checkout@v3
+
+      # Step 2: Set up go environment
+      - uses: actions/setup-go@v4
+        with:
+          go-version-file: '/workspace/FLUX/GoSBHPF/go.mod'
+
+      # Step 3: Set the working directory and run the project tests
+      - run: go test
+        working-directory: /workspace/FLUX/GoSBHPF/SBHPFv1

.gitignore

@@ -0,0 +1,22 @@
+# Binaries for programs and plugins
+*.exe
+*.exe~
+*.dll
+*.so
+*.dylib
+
+# Test binary, built with `go test -c`
+*.test
+
+# Output of the go coverage tool, specifically when used with LiteIDE
+*.out
+
+# Dependency directories (remove the comment below to include it)
+# vendor/
+
+# Go workspace file
+go.work
+go.work.sum
+
+# env file
+.env

.vscode/settings.json

@@ -0,0 +1,10 @@
+{
+    "cSpell.words": [
+        "SBHPF",
+        "sbhpfv",
+        "seekable",
+        "seekablebuffer",
+        "targetbytes",
+        "zervo"
+    ]
+}

README.md

@@ -1,3 +1,6 @@
 # GoSBHPF
 
-Go implementation of the SBHPF binary format.
+![Test status](https://git.zervo.org/FLUX/GoSBHPF/badges/workflows/test.yml/badge.svg)
+![Stars status](https://git.zervo.org/FLUX/GoSBHPF/badges/stars.svg)
+
+GoSBHPF is a go library implementing the SBHPF binary format.

SBHPFv1/buffered_serializer.go

@@ -0,0 +1,33 @@
+package sbhpfv1
+
+import (
+	"io"
+
+	"git.zervo.org/FLUX/GoSBHPF/pkg/seekablebuffer"
+)
+
+// SerializeNodeBuffered serializes a node object into a SBHPF node.
+// It is a wrapper around SerializeNode that temporarily stores the serialized nodes in a seekable memory buffer.
+// This provides serialization compatibility with non-seekable writers, at the cost of increased memory usage.
+func SerializeNodeBuffered(w io.Writer, node *Node) error {
+	buf := &seekablebuffer.Buffer{}
+	if err := SerializeNode(buf, node); err != nil {
+		return err
+	}
+
+	_, err := io.Copy(w, buf)
+	return err
+}
+
+// SerializeBuffered serializes a root node object into a complete SBHPF tree.
+// It is a wrapper around Serialize that temporarily stores the serialized data in a seekable memory buffer.
+// This provides serialization compatibility with non-seekable writers, at the cost of increased memory usage.
+func SerializeBuffered(w io.Writer, node *Node) error {
+	buf := &seekablebuffer.Buffer{}
+	if err := Serialize(buf, node); err != nil {
+		return err
+	}
+
+	_, err := io.Copy(w, buf)
+	return err
+}

SBHPFv1/constants.go

@@ -2,7 +2,7 @@ package sbhpfv1
 
 // Constants for file format.
 // These are statically set in version 1 of SBHPF,
-// but can be used to achieve an extended featureset in future versions,
+// but can be used to achieve an extended feature-set in future versions,
 // while maintaining backwards compatibility.
 const (
 	FormatVersion       = 0x01 // Current version

SBHPFv1/serializer.go

@@ -6,8 +6,9 @@ import (
 	"io"
 )
 
-// Serialize writes a full binary property file from a root node object.
+// Serialize serializes a root node object into a complete SBHPF tree.
 // This includes the start headers necessary for proper deserialization of raw files.
+// NOTE: Writer must support seeking. If this is not possible, use the SerializeBuffered wrapper.
 func Serialize(w io.Writer, root *Node) error {
 	// Write file header (version + feature flag).
 	if err := binary.Write(w, binary.LittleEndian, uint8(FormatVersion)); err != nil {
@@ -22,7 +23,7 @@ func Serialize(w io.Writer, root *Node) error {
 }
 
 // SerializeNode serializes a node object into a SBHPF node.
-// NOTE: Writer must support seeking. If this is not possible, use SerializeNodeStream.
+// NOTE: Writer must support seeking. If this is not possible, use the SerializeNodeBuffered wrapper.
 func SerializeNode(w io.Writer, node *Node) error {
 	// Reserve space for node size ("Node Size" node header).
 	sizePos := getWriterPosition(w)                                         // Save current position.

SBHPFv1/serializer_test.go

@@ -18,12 +18,14 @@ var (
 	}
 
 	node_ser_targetbytes = []byte{
-		// ROOT NODE
+		// -- ROOT NODE: HEADER
 		0x33, 0x00, 0x00, 0x00, // Node size = 33
 		0x02, 0x00, // Property count = 2
 		0x01, 0x00, // Child count = 1
-		0x06,                               // Name length = 6
+		0x06, // Name length = 6
+		// -- ROOT NODE: NAME
 		0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, // Node name = "player"
+		// -- ROOT NODE: PROPERTIES
 		// ROOT NODE -> PROPERTY A
 		0x06,                               // Key length = 6
 		0x0b,                               // Value type = bool
@@ -34,6 +36,7 @@ var (
 		0x03,                         // Value type = 16-bit signed int
 		0x6c, 0x65, 0x76, 0x65, 0x6c, // Key = "level"
 		0x1b, 0x00, // Value = 27
+		// -- ROOT NODE: CHILDREN
 		// ROOT NODE -> CHILD NODE
 		0x12, 0x00, 0x00, 0x00, // Node size = 12
 		0x00, 0x00, // Property count = 0
@@ -41,6 +44,25 @@ var (
 		0x09,                                                 // Name length = 9
 		0x69, 0x6e, 0x76, 0x65, 0x6e, 0x74, 0x6f, 0x72, 0x79, // Node name = "inventory"
 	}
+
+	full_ser_targetbytes = []byte{
+		// -- FILE HEADER
+		0x01, // Version flag = 1
+		0x00, // Feature flag = 0
+		// -- ROOT NODE: HEADER
+		0x16, 0x00, 0x00, 0x00, // Node size = 16
+		0x01, 0x00, // Property count = 1
+		0x00, 0x00, // Child count = 0
+		0x04, // Name length = 4
+		// -- ROOT NODE: NAME
+		0x75, 0x73, 0x65, 0x72, // Node name = "user"
+		// -- ROOT NODE: PROPERTIES
+		// ROOT NODE -> PROPERTY
+		0x06,                               // Key length = 6
+		0x0b,                               // Value type = bool
+		0x61, 0x63, 0x74, 0x69, 0x76, 0x65, // Key = "active"
+		0x01, // Value = true
+	}
 )
 
 func TestPropertySerialization(t *testing.T) {
@@ -50,8 +72,8 @@ func TestPropertySerialization(t *testing.T) {
 		Value: "zervo",
 	}
 
-	buf := &bytes.Buffer{}
+	var buf bytes.Buffer
-	err := sbhpfv1.SerializeProperty(buf, prop)
+	err := sbhpfv1.SerializeProperty(&buf, prop)
 	if err != nil {
 		t.Fatalf("Property serialization failed: %v", err)
 	}
@@ -89,13 +111,38 @@ func TestNodeSerialization(t *testing.T) {
 		},
 	}
 
-	var w bytes.Buffer
+	var buf bytes.Buffer
-	err := sbhpfv1.SerializeNodeStream(&w, &node)
+	err := sbhpfv1.SerializeNodeBuffered(&buf, &node)
 	if err != nil {
 		t.Fatalf("Node serialization failed: %v", err)
 	}
 
-	if !slices.Equal(w.Bytes(), node_ser_targetbytes) {
+	if !slices.Equal(buf.Bytes(), node_ser_targetbytes) {
-		t.Fatalf("Node serialization generated bad data: %v", w.Bytes())
+		t.Fatalf("Node serialization generated bad data: %v", buf.Bytes())
+	}
+}
+
+func TestFullSerialization(t *testing.T) {
+	prop := sbhpfv1.Property{
+		Key:   "active",
+		Type:  sbhpfv1.TypeBool,
+		Value: true,
+	}
+
+	node := sbhpfv1.Node{
+		Name: "user",
+		Properties: []sbhpfv1.Property{
+			prop,
+		},
+	}
+
+	var buf bytes.Buffer
+	err := sbhpfv1.SerializeBuffered(&buf, &node)
+	if err != nil {
+		t.Fatalf("Full tree serialization failed: %v", err)
+	}
+
+	if !slices.Equal(buf.Bytes(), full_ser_targetbytes) {
+		t.Fatalf("Full tree serialization generated bad data: %v", buf.Bytes())
 	}
 }

SBHPFv1/streamed_serializer.go

@@ -1,20 +0,0 @@
-package sbhpfv1
-
-import (
-	"io"
-
-	"git.zervo.org/FLUX/GoSBHPF/pkg/seekablebuffer"
-)
-
-// SerializeNodeStream serializes a node object into a SBHPF node.
-// It is a wrapper around SerializeNode that temporarily stores the serialized nodes in a seekable memory buffer.
-// This is less efficient, but provides compatibility with writers that lack seeking support.
-func SerializeNodeStream(w io.Writer, node *Node) error {
-	buf := &seekablebuffer.Buffer{}
-	if err := SerializeNode(buf, node); err != nil {
-		return err
-	}
-
-	_, err := io.Copy(w, buf)
-	return err
-}

main.go

@@ -1,48 +0,0 @@
-package main
-
-import (
-	"log"
-	"os"
-
-	sbhpfv1 "git.zervo.org/FLUX/GoSBHPF/SBHPFv1"
-)
-
-func main() {
-	file, err := os.Create("test.bin")
-	if err != nil {
-		log.Fatal(err)
-	}
-	defer file.Close()
-
-	prop_a := sbhpfv1.Property{
-		Key:   "active",
-		Type:  sbhpfv1.TypeBool,
-		Value: true,
-	}
-
-	prop_b := sbhpfv1.Property{
-		Key:   "level",
-		Type:  sbhpfv1.TypeInt16,
-		Value: int16(27),
-	}
-
-	child_node := sbhpfv1.Node{
-		Name: "inventory",
-	}
-
-	node := sbhpfv1.Node{
-		Name: "player",
-		Properties: []sbhpfv1.Property{
-			prop_a,
-			prop_b,
-		},
-		Children: []*sbhpfv1.Node{
-			&child_node,
-		},
-	}
-
-	err = sbhpfv1.SerializeNode(file, &node)
-	if err != nil {
-		log.Fatal(err)
-	}
-}