From 4d568cb49862ffe0bb429a1dc3eb4ca1ddf624a3 Mon Sep 17 00:00:00 2001
From: nickolasdaniel <nickolas.filip@itsyscom.com>
Date: Fri, 2 Apr 2021 14:11:40 +0300
Subject: [PATCH] Coverage tests for utils

---
 utils/datanode_test.go            |  4 ----
 utils/decimal_test.go             | 33 +++++++++++++++++++++++++++++++
 utils/dynamicweight_test.go       | 10 +++++++++-
 utils/orderednavigablemap_test.go | 17 ++++++++++++++++
 4 files changed, 59 insertions(+), 5 deletions(-)

diff --git a/utils/datanode_test.go b/utils/datanode_test.go
index 5ba2f36bc..6a392ce9f 100644
--- a/utils/datanode_test.go
+++ b/utils/datanode_test.go
@@ -19,7 +19,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>
 package utils
 
 import (
-	"fmt"
 	"reflect"
 	"regexp"
 	"strings"
@@ -378,13 +377,10 @@ func TestAppend2(t *testing.T) {
 	dn.Type = NMMapType
 	dn.Slice = nil
 	dn.Map = map[string]*DataNode{}
-	dnExpect := NewDataNode(testPath)
 
 	if _, err := dn.Append(testPath, val1); err != nil {
 		t.Error(err)
 	}
-	fmt.Println(ToJSON(dn.Map["0"]))
-	fmt.Println(ToJSON(dnExpect))
 
 	///
 	dn.Type = NMSliceType
diff --git a/utils/decimal_test.go b/utils/decimal_test.go
index 4b79efb59..fb313cf7c 100644
--- a/utils/decimal_test.go
+++ b/utils/decimal_test.go
@@ -20,6 +20,7 @@ package utils
 
 import (
 	"reflect"
+	"strconv"
 	"testing"
 
 	"github.com/ericlagergren/decimal"
@@ -173,3 +174,35 @@ func TestDecimalNewDecimalFromStringFail(t *testing.T) {
 		t.Errorf("\nExpected: <%+v>, \nReceived: <%+v>", expected, err)
 	}
 }
+
+func TestDivideBigWithReminder(t *testing.T) {
+	x := new(decimal.Big).SetUint64(10)
+	y := new(decimal.Big).SetUint64(5)
+	qExpected := new(decimal.Big).SetUint64(2)
+	rExpected := new(decimal.Big).SetUint64(0)
+	qReceived, rReceived := DivideBigWithReminder(x, y)
+	if !reflect.DeepEqual(qExpected, qReceived) {
+		t.Errorf("Expected divident <+%v> but received <+%v>", qExpected, qReceived)
+	} else if !reflect.DeepEqual(rExpected, rReceived) {
+		t.Errorf("Expected divident <+%v> but received <+%v>", rExpected, rReceived)
+	}
+}
+
+func TestNewDecimalFromFloat64(t *testing.T) {
+	x := 21.5
+	xExp, _ := new(decimal.Big).SetString(strconv.FormatFloat(x, 'f', -1, 64))
+	expected := &Decimal{xExp}
+	// fmt.Printf("%v of type %T", expected, expected)
+	rcv := NewDecimalFromFloat64(x)
+	if !reflect.DeepEqual(rcv, expected) {
+		t.Errorf("Expected <+%v> but received <+%v>", xExp, rcv)
+	}
+}
+
+func TestDecimalClone(t *testing.T) {
+	d := &Decimal{new(decimal.Big).SetUint64(3)}
+	rcv := d.Clone()
+	if !reflect.DeepEqual(d, rcv) {
+		t.Errorf("Expected <+%v> but received <+%v>", d, rcv)
+	}
+}
diff --git a/utils/dynamicweight_test.go b/utils/dynamicweight_test.go
index 3c5732f4a..ece3623e8 100644
--- a/utils/dynamicweight_test.go
+++ b/utils/dynamicweight_test.go
@@ -43,6 +43,14 @@ func TestNewDynamicWeightsFromString(t *testing.T) {
 	} else if !reflect.DeepEqual(eDws, dws) {
 		t.Errorf("expecting: %+v, received: %+v", ToJSON(eDws), ToJSON(dws))
 	}
+
+	///
+	dwsStr = "fltr1&fltr2;20;30;fltr3;30;fltr4&fltr5;50"
+	expected := "invalid DynamicWeight format for string <fltr1&fltr2;20;30;fltr3;30;fltr4&fltr5;50>"
+	if _, err := NewDynamicWeightsFromString(dwsStr, ";", "&"); err == nil || err.Error() != expected {
+		t.Errorf("expecting: %+v, received: %+v", expected, err)
+	}
+
 	eDws = DynamicWeights{
 		{
 			FilterIDs: []string{"fltr1", "fltr2"},
@@ -86,7 +94,7 @@ func TestNewDynamicWeightsFromString(t *testing.T) {
 	}
 
 	dwsStr = "fltr1&fltr2;not_a_float64"
-	expected := "invalid Weight <not_a_float64> in string: <fltr1&fltr2;not_a_float64>"
+	expected = "invalid Weight <not_a_float64> in string: <fltr1&fltr2;not_a_float64>"
 	if _, err := NewDynamicWeightsFromString(dwsStr, ";", "&"); err == nil || err.Error() != expected {
 		t.Errorf("expecting: %+v, received: %+v", expected, err)
 	}
diff --git a/utils/orderednavigablemap_test.go b/utils/orderednavigablemap_test.go
index e38dffec1..bf8295d49 100644
--- a/utils/orderednavigablemap_test.go
+++ b/utils/orderednavigablemap_test.go
@@ -870,3 +870,20 @@ func TestOrderedNavigableMapOrderedFields(t *testing.T) {
 		t.Errorf("Expected %+v, received %+v", exp2, rcv2)
 	}
 }
+
+func TestSetAsSliceErr(t *testing.T) {
+	nm := NewOrderedNavigableMap()
+	err := nm.SetAsSlice(&FullPath{}, []*DataNode{NewLeafNode(10), NewLeafNode(101)})
+	if err == nil || err != ErrWrongPath {
+		t.Errorf("Expected %+v, received %+v", ErrWrongPath, err)
+	}
+}
+
+func TestFieldAsString(t *testing.T) {
+	nm := NewOrderedNavigableMap()
+	path := []string{"0", "path"}
+	_, err := nm.FieldAsString(path)
+	if err == nil || err != ErrNotFound {
+		t.Errorf("Expected %+v, received %+v", ErrNotFound, err)
+	}
+}