Coverage tests for utils

utils/datanode_test.go

@@ -19,6 +19,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>
 package utils
 
 import (
+	"fmt"
 	"reflect"
 	"regexp"
 	"strings"
@@ -365,7 +366,7 @@ func TestAppend2(t *testing.T) {
 	dn.Type = NMDataType
 	testPath := []string{"0", "testPath"}
 	val1 := &DataLeaf{
-		Data: "data",
+		AttributeID: "ID1",
 	}
 	if rcv, err := dn.Append(testPath, val1); err != ErrWrongPath {
 		t.Errorf("Expected %v but received %v", ErrWrongPath, err)
@@ -383,6 +384,7 @@ func TestAppend2(t *testing.T) {
 	} else if rcv != 0 {
 		t.Errorf("Expected %+v, received %+v", 0, rcv)
 	}
+	fmt.Println(ToJSON(dn.Map))
 
 	///
 	dn.Type = NMSliceType

utils/orderednavigablemap_test.go

@@ -871,7 +871,7 @@ func TestOrderedNavigableMapOrderedFields(t *testing.T) {
 	}
 }
 
-func TestSetAsSliceErr(t *testing.T) {
+func TestOrderedNavigableMapSetAsSliceErr(t *testing.T) {
 	nm := NewOrderedNavigableMap()
 	err := nm.SetAsSlice(&FullPath{}, []*DataNode{NewLeafNode(10), NewLeafNode(101)})
 	if err == nil || err != ErrWrongPath {
@@ -879,7 +879,7 @@ func TestSetAsSliceErr(t *testing.T) {
 	}
 }
 
-func TestFieldAsString(t *testing.T) {
+func TestOrderedNavigableMapFieldAsStringErr(t *testing.T) {
 	nm := NewOrderedNavigableMap()
 	path := []string{"0", "path"}
 	_, err := nm.FieldAsString(path)
@@ -887,3 +887,74 @@ func TestFieldAsString(t *testing.T) {
 		t.Errorf("Expected %+v, received %+v", ErrNotFound, err)
 	}
 }
+
+func TestOrderedNavigableMapString(t *testing.T) {
+	onm := NewOrderedNavigableMap()
+	onm.nm = &DataNode{
+		Type: NMMapType,
+		Map: map[string]*DataNode{
+			"test1": &DataNode{
+				Value: &DataLeaf{
+					Data: "data!",
+				},
+			},
+		},
+	}
+	onmExpect := `{"Map":{"test1":{"Value":{"Data":"data!"}}}}`
+	// fmt.Println(onm.nm)
+	// fmt.Println(onm.String())
+	if onm.String() != onmExpect {
+		t.Errorf("Expected %s but received %s", onmExpect, onm.String())
+	}
+}
+
+func TestOrderedNavigableMapInterface(t *testing.T) {
+	onm := NewOrderedNavigableMap()
+	onm.nm = &DataNode{
+		Type: NMMapType,
+		Map: map[string]*DataNode{
+			"test1": &DataNode{
+				Value: &DataLeaf{
+					Data: "data!",
+				},
+			},
+		},
+	}
+	if !reflect.DeepEqual(onm.nm, onm.Interface()) {
+		t.Errorf("Expected %v but received %v", onm.nm, onm.Interface())
+	}
+}
+
+func TestOrderedNavigableMapAppend(t *testing.T) {
+	onm := NewOrderedNavigableMap()
+	onm.nm.Type = NMMapType
+	onm.Set(&FullPath{
+		PathSlice: []string{"Field1", "Field2", "0"},
+		Path:      "Field1.Field2[0]",
+	}, NewLeafNode("1003"))
+	if err := onm.Append(&FullPath{
+		PathSlice: []string{"Field1", "Field2", "0"},
+		Path:      "Field1.Field2[0]",
+	}, &DataLeaf{Data: "dataTest"}); err == nil || err != ErrWrongPath {
+		t.Errorf("Expected %v but received %v", ErrWrongPath, err)
+	}
+}
+
+func TestOrderedNavigableMapCompose(t *testing.T) {
+	onm := NewOrderedNavigableMap()
+	onm.nm.Type = NMMapType
+	onm.Set(&FullPath{
+		PathSlice: []string{"Field1", "Field2", "0"},
+		Path:      "Field1.Field2[0]",
+	}, NewLeafNode("1003"))
+	onm.orderRef = make(map[string][]*PathItemElement)
+	onm.orderRef = map[string][]*PathItemElement{
+		"Field1.Field2[0]": []*PathItemElement{&PathItemElement{Value: []string{"test"}}},
+	}
+	if err := onm.Compose(&FullPath{
+		PathSlice: []string{"Field1", "Field2", "0"},
+		Path:      "Field1.Field2[0]",
+	}, &DataLeaf{Data: "dataTest"}); err != nil {
+		t.Error(err)
+	}
+}

utils/reflect_test.go

@@ -24,6 +24,8 @@ import (
 	"strings"
 	"testing"
 	"time"
+
+	"github.com/ericlagergren/decimal"
 )
 
 func TestReflectFieldAsStringOnStruct(t *testing.T) {
@@ -1639,3 +1641,195 @@ func TestMultiplyInt64Error(t *testing.T) {
 		t.Errorf("Expected <strconv.ParseInt: parsing \"cat\": invalid syntax> ,received: <%+v>", err)
 	}
 }
+
+func TestIfaceAsBigTimeDuration(t *testing.T) {
+	itm := 5 * time.Second
+	exp := decimal.New(int64(itm), 0)
+	rcv, err := IfaceAsBig(itm)
+	if err != nil {
+		t.Error(err)
+	} else if !reflect.DeepEqual(exp, rcv) {
+		t.Errorf("Expected %v but received %v", exp, rcv)
+	}
+}
+
+func TestIfaceAsBigInt(t *testing.T) {
+	itm := 20
+	exp := decimal.New(int64(itm), 0)
+	rcv, err := IfaceAsBig(itm)
+	if err != nil {
+		t.Error(err)
+	} else if !reflect.DeepEqual(exp, rcv) {
+		t.Errorf("Expected %v but received %v", exp, rcv)
+	}
+}
+
+func TestIfaceAsBigInt8(t *testing.T) {
+	itm := int8(20)
+	exp := decimal.New(int64(itm), 0)
+	rcv, err := IfaceAsBig(itm)
+	if err != nil {
+		t.Error(err)
+	} else if !reflect.DeepEqual(exp, rcv) {
+		t.Errorf("Expected %v but received %v", exp, rcv)
+	}
+}
+
+func TestIfaceAsBigInt16(t *testing.T) {
+	itm := int16(4363)
+	exp := decimal.New(int64(itm), 0)
+	rcv, err := IfaceAsBig(itm)
+	if err != nil {
+		t.Error(err)
+	} else if !reflect.DeepEqual(exp, rcv) {
+		t.Errorf("Expected %v but received %v", exp, rcv)
+	}
+}
+
+func TestIfaceAsBigInt32(t *testing.T) {
+	itm := int32(4363)
+	exp := decimal.New(int64(itm), 0)
+	rcv, err := IfaceAsBig(itm)
+	if err != nil {
+		t.Error(err)
+	} else if !reflect.DeepEqual(exp, rcv) {
+		t.Errorf("Expected %v but received %v", exp, rcv)
+	}
+}
+
+func TestIfaceAsBigInt64(t *testing.T) {
+	itm := int64(4363)
+	exp := decimal.New(int64(itm), 0)
+	rcv, err := IfaceAsBig(itm)
+	if err != nil {
+		t.Error(err)
+	} else if !reflect.DeepEqual(exp, rcv) {
+		t.Errorf("Expected %v but received %v", exp, rcv)
+	}
+}
+
+func TestIfaceAsBigUint(t *testing.T) {
+	itm := uint(20)
+	exp := new(decimal.Big).SetUint64(uint64(itm))
+	rcv, err := IfaceAsBig(itm)
+	if err != nil {
+		t.Error(err)
+	} else if !reflect.DeepEqual(exp, rcv) {
+		t.Errorf("Expected %v but received %v", exp, rcv)
+	}
+}
+
+func TestIfaceAsBigUint8(t *testing.T) {
+	itm := uint8(20)
+	exp := new(decimal.Big).SetUint64(uint64(itm))
+	rcv, err := IfaceAsBig(itm)
+	if err != nil {
+		t.Error(err)
+	} else if !reflect.DeepEqual(exp, rcv) {
+		t.Errorf("Expected %v but received %v", exp, rcv)
+	}
+}
+
+func TestIfaceAsBigUint16(t *testing.T) {
+	itm := uint16(4363)
+	exp := new(decimal.Big).SetUint64(uint64(itm))
+	rcv, err := IfaceAsBig(itm)
+	if err != nil {
+		t.Error(err)
+	} else if !reflect.DeepEqual(exp, rcv) {
+		t.Errorf("Expected %v but received %v", exp, rcv)
+	}
+}
+
+func TestIfaceAsBigUint32(t *testing.T) {
+	itm := uint32(4363)
+	exp := new(decimal.Big).SetUint64(uint64(itm))
+	rcv, err := IfaceAsBig(itm)
+	if err != nil {
+		t.Error(err)
+	} else if !reflect.DeepEqual(exp, rcv) {
+		t.Errorf("Expected %v but received %v", exp, rcv)
+	}
+}
+
+func TestIfaceAsBigUint64(t *testing.T) {
+	itm := uint64(4363)
+	exp := new(decimal.Big).SetUint64(uint64(itm))
+	rcv, err := IfaceAsBig(itm)
+	if err != nil {
+		t.Error(err)
+	} else if !reflect.DeepEqual(exp, rcv) {
+		t.Errorf("Expected %v but received %v", exp, rcv)
+	}
+}
+
+func TestIfaceAsBigFloat32(t *testing.T) {
+	itm := float32(42.2)
+	exp := new(decimal.Big).SetFloat64(float64(itm))
+	rcv, err := IfaceAsBig(itm)
+	if err != nil {
+		t.Error(err)
+	} else if !reflect.DeepEqual(exp, rcv) {
+		t.Errorf("Expected %v but received %v", exp, rcv)
+	}
+}
+
+func TestIfaceAsBigFloat64(t *testing.T) {
+	itm := float64(42.2)
+	exp := new(decimal.Big).SetFloat64(itm)
+	rcv, err := IfaceAsBig(itm)
+	if err != nil {
+		t.Error(err)
+	} else if !reflect.DeepEqual(exp, rcv) {
+		t.Errorf("Expected %v but received %v", exp, rcv)
+	}
+}
+
+func TestIfaceAsBigString(t *testing.T) {
+	itm := "32ns"
+	exp := new(decimal.Big).SetUint64(32)
+	rcv, err := IfaceAsBig(itm)
+	if err != nil {
+		t.Error(err)
+	} else if !reflect.DeepEqual(exp, rcv) {
+		t.Errorf("Expected %v but received %v", exp, rcv)
+	}
+}
+
+func TestIfaceAsBigStringConvert(t *testing.T) {
+	itm := "1.234"
+	exp, _ := new(decimal.Big).SetString(itm)
+	rcv, err := IfaceAsBig(itm)
+	if err != nil {
+		t.Error(err)
+	} else if !reflect.DeepEqual(exp, rcv) {
+		fmt.Printf("%T and %T", exp, rcv)
+		t.Errorf("Expected %v but received %v", exp, rcv)
+	}
+}
+
+func TestIfaceAsBigStringErr1(t *testing.T) {
+	itm := "32ps"
+	_, err := IfaceAsBig(itm)
+	errExpect := `time: unknown unit "ps" in duration "32ps"`
+	if err == nil || err.Error() != errExpect {
+		t.Errorf("Expected %v but received %v", errExpect, err)
+	}
+}
+
+func TestIfaceAsBigStringErr2(t *testing.T) {
+	itm := "can't convert"
+	_, err := IfaceAsBig(itm)
+	errExpect := "can't convert <can't convert> to decimal"
+	if err == nil || err.Error() != errExpect {
+		t.Errorf("Expected %v but received %v", errExpect, err)
+	}
+}
+func TestIfaceAsBigDefault(t *testing.T) {
+	itm := []string{"defaultCase"}
+	_, err := IfaceAsBig(itm)
+	errExpect := "cannot convert field: [defaultCase] to time.Duration"
+	if err == nil || err.Error() != errExpect {
+		t.Errorf("Expected %v but received %v", errExpect, err)
+	}
+}