From 422496891552240c319ca8e268963dd8bfa2dc84 Mon Sep 17 00:00:00 2001
From: Winni Neessen <wn@neessen.net>
Date: Sun, 1 Sep 2024 16:41:53 +0200
Subject: [PATCH] Add support for additional types in niljson

Enhanced the niljson package to include support for byte slices and float32 types. Updated the test cases to validate these new types and modified method names to be more consistent.
---
 niljson.go      | 19 ++++++++++++++---
 niljson_test.go | 55 ++++++++++++++++++++++++++++++++++---------------
 2 files changed, 54 insertions(+), 20 deletions(-)

diff --git a/niljson.go b/niljson.go
index 6d8b209..527907c 100644
--- a/niljson.go
+++ b/niljson.go
@@ -4,7 +4,9 @@
 
 package niljson
 
-import "encoding/json"
+import (
+	"encoding/json"
+)
 
 // Variable is a generic variable type that can be null.
 type Variable[T any] struct {
@@ -12,11 +14,16 @@ type Variable[T any] struct {
 	notNil bool
 }
 
-// Get the value of the Variable
-func (v *Variable[T]) Get() T {
+// Value returns the value of the Variable
+func (v *Variable[T]) Value() T {
 	return v.value
 }
 
+// Get is an alias method for Value()
+func (v *Variable[T]) Get() T {
+	return v.Value()
+}
+
 // NotNil returns true when a Variable is not nil
 func (v *Variable[T]) NotNil() bool {
 	return v.notNil
@@ -37,12 +44,18 @@ func (v *Variable[T]) Reset() {
 // NilBoolean is an boolean type that can be nil
 type NilBoolean = Variable[bool]
 
+// NilByteSlice is a []byte type that can be nil
+type NilByteSlice = Variable[[]byte]
+
 // NilInt is an int type that can be nil
 type NilInt = Variable[int]
 
 // NilInt64 is an int64 type that can be nil
 type NilInt64 = Variable[int64]
 
+// NilFloat32 is an float32 type that can be nil
+type NilFloat32 = Variable[float32]
+
 // NilFloat64 is an float64 type that can be nil
 type NilFloat64 = Variable[float64]
 
diff --git a/niljson_test.go b/niljson_test.go
index b93a8fc..9b67fa0 100644
--- a/niljson_test.go
+++ b/niljson_test.go
@@ -5,24 +5,38 @@
 package niljson
 
 import (
+	"bytes"
 	"encoding/json"
 	"testing"
 )
 
 func TestVariable_UnmarshalJSON(t *testing.T) {
-	jsonBytes := []byte(`{"string":"test", "int":123, "int64": 12345678901234, "float":123.456, "nil":null, "bool":true}`)
+	jsonBytes := []byte(`{"string":"test", "int":123, "int64": 12345678901234, "float32": 1.6,
+						"float64":123.456, "nil":null, "bool":true, "bytes": "Ynl0ZXM="}`)
 	type JSONType struct {
-		Bool       NilBoolean `json:"bool"`
-		Float64    NilFloat64 `json:"float"`
-		Int        NilInt     `json:"int"`
-		Int64      NilInt64   `json:"int64"`
-		NullString NilString  `json:"nil"`
-		String     NilString  `json:"string"`
+		Bool       NilBoolean   `json:"bool"`
+		ByteSlice  NilByteSlice `json:"bytes"`
+		Float32    NilFloat32   `json:"float32"`
+		Float64    NilFloat64   `json:"float64"`
+		Int        NilInt       `json:"int"`
+		Int64      NilInt64     `json:"int64"`
+		NullString NilString    `json:"nil"`
+		String     NilString    `json:"string"`
 	}
 	var jt JSONType
 	if err := json.Unmarshal(jsonBytes, &jt); err != nil {
 		t.Errorf("failed to unmarshal json with nil types: %v", err)
 	}
+
+	if jt.Bool.IsNil() {
+		t.Errorf("expected not nil bool")
+	}
+	if jt.ByteSlice.IsNil() {
+		t.Errorf("expected not nil byte slice")
+	}
+	if jt.Float32.IsNil() {
+		t.Errorf("expected not nil float32")
+	}
 	if jt.Float64.IsNil() {
 		t.Errorf("expected not nil float64")
 	}
@@ -38,20 +52,27 @@ func TestVariable_UnmarshalJSON(t *testing.T) {
 	if jt.NullString.NotNil() {
 		t.Errorf("expected nil string")
 	}
-	if !jt.Bool.Get() {
-		t.Errorf("expected bool to be true, got %t", jt.Bool.Get())
+
+	if !jt.Bool.Value() {
+		t.Errorf("expected bool to be true, got %t", jt.Bool.Value())
 	}
-	if jt.Float64.Get() != 123.456 {
-		t.Errorf("expected float64 to be 123.456, got %f", jt.Float64.Get())
+	if !bytes.Equal(jt.ByteSlice.Value(), []byte("bytes")) {
+		t.Errorf("expected byte slice to be %q, got %q", "bytes", jt.ByteSlice.Value())
 	}
-	if jt.Int.Get() != 123 {
-		t.Errorf("expected int to be 123, got %d", jt.Int.Get())
+	if jt.Float32.Value() != 1.6 {
+		t.Errorf("expected float64 to be 1.6, got %f", jt.Float32.Value())
 	}
-	if jt.Int64.Get() != 12345678901234 {
-		t.Errorf("expected int to be 12345678901234, got %d", jt.Int64.Get())
+	if jt.Float64.Value() != 123.456 {
+		t.Errorf("expected float64 to be 123.456, got %f", jt.Float64.Value())
 	}
-	if jt.String.Get() != "test" {
-		t.Errorf("expected string to be 'test', got %s", jt.String.Get())
+	if jt.Int.Value() != 123 {
+		t.Errorf("expected int to be 123, got %d", jt.Int.Value())
+	}
+	if jt.Int64.Value() != 12345678901234 {
+		t.Errorf("expected int to be 12345678901234, got %d", jt.Int64.Value())
+	}
+	if jt.String.Value() != "test" {
+		t.Errorf("expected string to be 'test', got %s", jt.String.Value())
 	}
 
 	jt.Bool.Reset()