wneessen/niljson
1
0
Fork 0
mirror of https://github.com/wneessen/niljson.git synced 2024-11-23 22:20:50 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

Compare commits

base: wneessen:25913bbf9f6f1df2fe80a93e1b499074556fd7eb
Branches Tags
wneessen:main
wneessen:more-cleanup-cleanup
wneessen:v0.1.0
wneessen:v0.0.5
wneessen:v0.0.4
wneessen:v0.0.3
wneessen:v0.0.2
wneessen:v0.0.1
..
compare: wneessen:bdd7efec82b0afdff44972d245815fce83c88a1c
Branches Tags
wneessen:main
wneessen:more-cleanup-cleanup
wneessen:v0.1.0
wneessen:v0.0.5
wneessen:v0.0.4
wneessen:v0.0.3
wneessen:v0.0.2
wneessen:v0.0.1

No commits in common. "25913bbf9f6f1df2fe80a93e1b499074556fd7eb" and "bdd7efec82b0afdff44972d245815fce83c88a1c" have entirely different histories.
25913bbf9f ... bdd7efec82

3 changed files with 81 additions and 343 deletions
Show stats Expand all files Collapse all files

2
go.mod
View file

@ -4,4 +4,4 @@
module github.com/wneessen/niljson module github.com/wneessen/niljson
go 1.18 go 1.23

20
niljson.go
View file

@ -19,6 +19,11 @@ func (v *Variable[T]) Value() T {
return v.value 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 // NotNil returns true when a Variable is not nil
func (v *Variable[T]) NotNil() bool { func (v *Variable[T]) NotNil() bool {
return v.notNil return v.notNil
@ -48,21 +53,6 @@ type NilInt = Variable[int]
// NilInt64 is an int64 type that can be nil // NilInt64 is an int64 type that can be nil
type NilInt64 = Variable[int64] type NilInt64 = Variable[int64]
// NilUInt is an uint type that can be nil
type NilUInt = Variable[uint]
// NilUInt8 is an uint8 type that can be nil
type NilUInt8 = Variable[uint8]
// NilUInt16 is an uint16 type that can be nil
type NilUInt16 = Variable[uint16]
// NilUInt32 is an uint32 type that can be nil
type NilUInt32 = Variable[uint32]
// NilUInt64 is an uint64 type that can be nil
type NilUInt64 = Variable[uint64]
// NilFloat32 is an float32 type that can be nil // NilFloat32 is an float32 type that can be nil
type NilFloat32 = Variable[float32] type NilFloat32 = Variable[float32]

402
niljson_test.go
View file

@ -12,354 +12,102 @@ import (
"testing" "testing"
) )
var jsonBytes = []byte( func TestVariable_UnmarshalJSON(t *testing.T) {
`{ jsonBytes := []byte(`{"string":"test", "int":123, "int64": 12345678901234, "float32": 1.6,
"bool": true, "float64":123.456, "nil":null, "bool":true, "bytes": "Ynl0ZXM="}`)
"bytes": "Ynl0ZXM=",
"float32": 1.6,
"float64": 123.456,
"int": 123,
"int64": 12345678901234,
"nilvalue": null,
"string": "test",
"uint": 1,
"uint8": 2,
"uint16": 3,
"uint32": 4,
"uint64": 5
}`)
func TestVariable_UnmarshalJSON_Boolean(t *testing.T) {
type JSONType struct { type JSONType struct {
Value NilBoolean `json:"bool"` Bool NilBoolean `json:"bool"`
NilValue NilBoolean `json:"nilvalue,omitempty"` 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 var jt JSONType
if err := json.Unmarshal(jsonBytes, &jt); err != nil { if err := json.Unmarshal(jsonBytes, &jt); err != nil {
t.Errorf("failed to unmarshal json with nil types: %s", err) t.Errorf("failed to unmarshal json with nil types: %v", err)
} }
if jt.Value.IsNil() { if jt.Bool.IsNil() {
t.Errorf("expected value, but got nil") t.Errorf("expected not nil bool")
} }
if jt.NilValue.NotNil() { if jt.ByteSlice.IsNil() {
t.Errorf("expected nil, but got value") t.Errorf("expected not nil byte slice")
} }
if !jt.Value.Value() { if jt.Float32.IsNil() {
t.Errorf("expected value to be true, got %t", jt.Value.Value()) t.Errorf("expected not nil float32")
}
if jt.Float64.IsNil() {
t.Errorf("expected not nil float64")
}
if jt.Int.IsNil() {
t.Errorf("expected not nil int")
}
if jt.Int64.IsNil() {
t.Errorf("expected not nil int64")
}
if jt.String.IsNil() {
t.Errorf("expected not nil string")
}
if jt.NullString.NotNil() {
t.Errorf("expected nil string")
} }
jt.Value.Reset() if !jt.Bool.Value() {
if jt.Value.NotNil() { t.Errorf("expected bool to be true, got %t", jt.Bool.Value())
t.Errorf("expected value to be nil after reset")
} }
} if !bytes.Equal(jt.ByteSlice.Value(), []byte("bytes")) {
t.Errorf("expected byte slice to be %q, got %q", "bytes", jt.ByteSlice.Value())
func TestVariable_UnmarshalJSON_ByteSlice(t *testing.T) { }
type JSONType struct { if jt.Float32.Value() != 1.6 {
Value NilByteSlice `json:"bytes"` t.Errorf("expected float64 to be 1.6, got %f", jt.Float32.Value())
NilValue NilBoolean `json:"nilvalue,omitempty"` }
if jt.Float64.Value() != 123.456 {
t.Errorf("expected float64 to be 123.456, got %f", jt.Float64.Value())
}
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())
} }
var jt JSONType if jt.String.Get() != "test" {
if err := json.Unmarshal(jsonBytes, &jt); err != nil { t.Errorf("expected string to be 'test', got %s", jt.String.Get())
t.Errorf("failed to unmarshal json with nil types: %s", err)
} }
if jt.Value.IsNil() { jt.Bool.Reset()
t.Errorf("expected value, but got nil") if jt.Bool.NotNil() {
t.Errorf("expected bool to be nil after reset")
} }
if jt.NilValue.NotNil() { jt.ByteSlice.Reset()
t.Errorf("expected nil, but got value") if jt.ByteSlice.NotNil() {
t.Errorf("expected byte slice to be nil after reset")
} }
if !bytes.Equal(jt.Value.Value(), []byte("bytes")) { jt.Float32.Reset()
t.Errorf("expected value to be %q, got %q", "bytes", jt.Value.Value()) if jt.Float32.NotNil() {
t.Errorf("expected float32 to be nil after reset")
} }
jt.Float64.Reset()
jt.Value.Reset() if jt.Float64.NotNil() {
if jt.Value.NotNil() { t.Errorf("expected float64 to be nil after reset")
t.Errorf("expected value to be nil after reset")
} }
} jt.Int.Reset()
if jt.Int.NotNil() {
func TestVariable_UnmarshalJSON_Float32(t *testing.T) { t.Errorf("expected int to be nil after reset")
type JSONType struct {
Value NilFloat32 `json:"float32"`
NilValue NilBoolean `json:"nilvalue,omitempty"`
} }
expected := float32(1.6) jt.Int64.Reset()
if jt.Int64.NotNil() {
var jt JSONType t.Errorf("expected int64 to be nil after reset")
if err := json.Unmarshal(jsonBytes, &jt); err != nil {
t.Errorf("failed to unmarshal json with nil types: %s", err)
} }
jt.String.Reset()
if jt.Value.IsNil() { if jt.String.NotNil() {
t.Errorf("expected value, but got nil") t.Errorf("expected string to be nil after reset")
}
if jt.NilValue.NotNil() {
t.Errorf("expected nil, but got value")
}
if jt.Value.Value() != expected {
t.Errorf("expected value to be %f, got %f", expected, jt.Value.Value())
}
jt.Value.Reset()
if jt.Value.NotNil() {
t.Errorf("expected value to be nil after reset")
}
}
func TestVariable_UnmarshalJSON_Float64(t *testing.T) {
type JSONType struct {
Value NilFloat64 `json:"float64"`
NilValue NilBoolean `json:"nilvalue,omitempty"`
}
expected := 123.456
var jt JSONType
if err := json.Unmarshal(jsonBytes, &jt); err != nil {
t.Errorf("failed to unmarshal json with nil types: %s", err)
}
if jt.Value.IsNil() {
t.Errorf("expected value, but got nil")
}
if jt.NilValue.NotNil() {
t.Errorf("expected nil, but got value")
}
if jt.Value.Value() != expected {
t.Errorf("expected value to be %f, got %f", expected, jt.Value.Value())
}
jt.Value.Reset()
if jt.Value.NotNil() {
t.Errorf("expected value to be nil after reset")
}
}
func TestVariable_UnmarshalJSON_Int(t *testing.T) {
type JSONType struct {
Value NilInt `json:"int"`
NilValue NilBoolean `json:"nilvalue,omitempty"`
}
expected := 123
var jt JSONType
if err := json.Unmarshal(jsonBytes, &jt); err != nil {
t.Errorf("failed to unmarshal json with nil types: %s", err)
}
if jt.Value.IsNil() {
t.Errorf("expected value, but got nil")
}
if jt.NilValue.NotNil() {
t.Errorf("expected nil, but got value")
}
if jt.Value.Value() != expected {
t.Errorf("expected value to be %d, got %d", expected, jt.Value.Value())
}
jt.Value.Reset()
if jt.Value.NotNil() {
t.Errorf("expected value to be nil after reset")
}
}
func TestVariable_UnmarshalJSON_Int64(t *testing.T) {
type JSONType struct {
Value NilInt64 `json:"int64"`
NilValue NilBoolean `json:"nilvalue,omitempty"`
}
expected := int64(12345678901234)
var jt JSONType
if err := json.Unmarshal(jsonBytes, &jt); err != nil {
t.Errorf("failed to unmarshal json with nil types: %s", err)
}
if jt.Value.IsNil() {
t.Errorf("expected value, but got nil")
}
if jt.NilValue.NotNil() {
t.Errorf("expected nil, but got value")
}
if jt.Value.Value() != expected {
t.Errorf("expected value to be %d, got %d", expected, jt.Value.Value())
}
jt.Value.Reset()
if jt.Value.NotNil() {
t.Errorf("expected value to be nil after reset")
}
}
func TestVariable_UnmarshalJSON_String(t *testing.T) {
type JSONType struct {
Value NilString `json:"string"`
NilValue NilBoolean `json:"nilvalue,omitempty"`
}
expected := "test"
var jt JSONType
if err := json.Unmarshal(jsonBytes, &jt); err != nil {
t.Errorf("failed to unmarshal json with nil types: %s", err)
}
if jt.Value.IsNil() {
t.Errorf("expected value, but got nil")
}
if jt.NilValue.NotNil() {
t.Errorf("expected nil, but got value")
}
if jt.Value.Value() != expected {
t.Errorf("expected value to be %s, got %s", expected, jt.Value.Value())
}
jt.Value.Reset()
if jt.Value.NotNil() {
t.Errorf("expected value to be nil after reset")
}
}
func TestVariable_UnmarshalJSON_UInt(t *testing.T) {
type JSONType struct {
Value NilUInt `json:"uint"`
NilValue NilBoolean `json:"nilvalue,omitempty"`
}
expected := uint(1)
var jt JSONType
if err := json.Unmarshal(jsonBytes, &jt); err != nil {
t.Errorf("failed to unmarshal json with nil types: %s", err)
}
if jt.Value.IsNil() {
t.Errorf("expected value, but got nil")
}
if jt.NilValue.NotNil() {
t.Errorf("expected nil, but got value")
}
if jt.Value.Value() != expected {
t.Errorf("expected value to be %d, got %d", expected, jt.Value.Value())
}
jt.Value.Reset()
if jt.Value.NotNil() {
t.Errorf("expected value to be nil after reset")
}
}
func TestVariable_UnmarshalJSON_UInt8(t *testing.T) {
type JSONType struct {
Value NilUInt8 `json:"uint8"`
NilValue NilBoolean `json:"nilvalue,omitempty"`
}
expected := uint8(2)
var jt JSONType
if err := json.Unmarshal(jsonBytes, &jt); err != nil {
t.Errorf("failed to unmarshal json with nil types: %s", err)
}
if jt.Value.IsNil() {
t.Errorf("expected value, but got nil")
}
if jt.NilValue.NotNil() {
t.Errorf("expected nil, but got value")
}
if jt.Value.Value() != expected {
t.Errorf("expected value to be %d, got %d", expected, jt.Value.Value())
}
jt.Value.Reset()
if jt.Value.NotNil() {
t.Errorf("expected value to be nil after reset")
}
}
func TestVariable_UnmarshalJSON_UInt16(t *testing.T) {
type JSONType struct {
Value NilUInt16 `json:"uint16"`
NilValue NilBoolean `json:"nilvalue,omitempty"`
}
expected := uint16(3)
var jt JSONType
if err := json.Unmarshal(jsonBytes, &jt); err != nil {
t.Errorf("failed to unmarshal json with nil types: %s", err)
}
if jt.Value.IsNil() {
t.Errorf("expected value, but got nil")
}
if jt.NilValue.NotNil() {
t.Errorf("expected nil, but got value")
}
if jt.Value.Value() != expected {
t.Errorf("expected value to be %d, got %d", expected, jt.Value.Value())
}
jt.Value.Reset()
if jt.Value.NotNil() {
t.Errorf("expected value to be nil after reset")
}
}
func TestVariable_UnmarshalJSON_UInt32(t *testing.T) {
type JSONType struct {
Value NilUInt32 `json:"uint32"`
NilValue NilBoolean `json:"nilvalue,omitempty"`
}
expected := uint32(4)
var jt JSONType
if err := json.Unmarshal(jsonBytes, &jt); err != nil {
t.Errorf("failed to unmarshal json with nil types: %s", err)
}
if jt.Value.IsNil() {
t.Errorf("expected value, but got nil")
}
if jt.NilValue.NotNil() {
t.Errorf("expected nil, but got value")
}
if jt.Value.Value() != expected {
t.Errorf("expected value to be %d, got %d", expected, jt.Value.Value())
}
jt.Value.Reset()
if jt.Value.NotNil() {
t.Errorf("expected value to be nil after reset")
}
}
func TestVariable_UnmarshalJSON_UInt64(t *testing.T) {
type JSONType struct {
Value NilUInt64 `json:"uint64"`
NilValue NilBoolean `json:"nilvalue,omitempty"`
}
expected := uint64(5)
var jt JSONType
if err := json.Unmarshal(jsonBytes, &jt); err != nil {
t.Errorf("failed to unmarshal json with nil types: %s", err)
}
if jt.Value.IsNil() {
t.Errorf("expected value, but got nil")
}
if jt.NilValue.NotNil() {
t.Errorf("expected nil, but got value")
}
if jt.Value.Value() != expected {
t.Errorf("expected value to be %d, got %d", expected, jt.Value.Value())
}
jt.Value.Reset()
if jt.Value.NotNil() {
t.Errorf("expected value to be nil after reset")
} }
} }