[🤖] Add Unit-Tests

langext/maps_test.go

@@ -0,0 +1,146 @@
+package langext
+
+import (
+	"git.blackforestbytes.com/BlackForestBytes/goext/tst"
+	"sort"
+	"testing"
+)
+
+func TestMapKeyArr(t *testing.T) {
+	m := map[string]int{"a": 1, "b": 2, "c": 3}
+	keys := MapKeyArr(m)
+	sort.Strings(keys)
+	tst.AssertArrayEqual(t, keys, []string{"a", "b", "c"})
+}
+
+func TestMapKeyArrEmpty(t *testing.T) {
+	m := map[string]int{}
+	keys := MapKeyArr(m)
+	tst.AssertEqual(t, len(keys), 0)
+}
+
+func TestMapValueArr(t *testing.T) {
+	m := map[string]int{"a": 1, "b": 2, "c": 3}
+	values := MapValueArr(m)
+	sort.Ints(values)
+	tst.AssertArrayEqual(t, values, []int{1, 2, 3})
+}
+
+func TestArrToMap(t *testing.T) {
+	type item struct {
+		key string
+		v   int
+	}
+	arr := []item{{"a", 1}, {"b", 2}}
+	m := ArrToMap(arr, func(i item) string { return i.key })
+	tst.AssertEqual(t, len(m), 2)
+	tst.AssertEqual(t, m["a"].v, 1)
+	tst.AssertEqual(t, m["b"].v, 2)
+}
+
+func TestArrToKVMap(t *testing.T) {
+	arr := []int{1, 2, 3}
+	m := ArrToKVMap(arr,
+		func(v int) int { return v },
+		func(v int) string {
+			return [...]string{"", "one", "two", "three"}[v]
+		},
+	)
+	tst.AssertEqual(t, m[1], "one")
+	tst.AssertEqual(t, m[2], "two")
+	tst.AssertEqual(t, m[3], "three")
+}
+
+func TestArrToSet(t *testing.T) {
+	arr := []string{"a", "b", "a", "c"}
+	set := ArrToSet(arr)
+	tst.AssertEqual(t, len(set), 3)
+	tst.AssertEqual(t, set["a"], true)
+	tst.AssertEqual(t, set["b"], true)
+	tst.AssertEqual(t, set["c"], true)
+	tst.AssertEqual(t, set["d"], false)
+}
+
+func TestMapToArr(t *testing.T) {
+	m := map[string]int{"a": 1, "b": 2}
+	arr := MapToArr(m)
+	tst.AssertEqual(t, len(arr), 2)
+	roundTrip := make(map[string]int)
+	for _, e := range arr {
+		roundTrip[e.Key] = e.Value
+	}
+	tst.AssertEqual(t, roundTrip["a"], 1)
+	tst.AssertEqual(t, roundTrip["b"], 2)
+}
+
+func TestCopyMap(t *testing.T) {
+	src := map[string]int{"a": 1, "b": 2}
+	dst := CopyMap(src)
+	tst.AssertEqual(t, len(dst), 2)
+	tst.AssertEqual(t, dst["a"], 1)
+
+	// Mutating dst should not affect src
+	dst["a"] = 99
+	tst.AssertEqual(t, src["a"], 1)
+}
+
+func TestForceMapNil(t *testing.T) {
+	var m map[string]int
+	res := ForceMap(m)
+	if res == nil {
+		t.Errorf("expected non-nil result")
+	}
+	tst.AssertEqual(t, len(res), 0)
+}
+
+func TestForceMapNonNil(t *testing.T) {
+	m := map[string]int{"x": 1}
+	res := ForceMap(m)
+	tst.AssertEqual(t, res["x"], 1)
+}
+
+func TestForceJsonMapOrPanic(t *testing.T) {
+	type s struct {
+		A int    `json:"a"`
+		B string `json:"b"`
+	}
+	res := ForceJsonMapOrPanic(s{A: 1, B: "x"})
+	if v, ok := res["a"].(float64); !ok || v != 1 {
+		t.Errorf("expected a=1, got %v", res["a"])
+	}
+	if v, ok := res["b"].(string); !ok || v != "x" {
+		t.Errorf("expected b=x, got %v", res["b"])
+	}
+}
+
+func TestForceJsonMapOrPanicPanics(t *testing.T) {
+	defer func() {
+		if r := recover(); r == nil {
+			t.Errorf("expected panic on un-marshalable input")
+		}
+	}()
+	ForceJsonMapOrPanic(make(chan int))
+}
+
+func TestMapMerge(t *testing.T) {
+	base := map[string]int{"a": 1, "b": 2}
+	a := map[string]int{"b": 22, "c": 3}
+	b := map[string]int{"d": 4}
+
+	res := MapMerge(base, a, b)
+	tst.AssertEqual(t, res["a"], 1)
+	tst.AssertEqual(t, res["b"], 22) // overwritten
+	tst.AssertEqual(t, res["c"], 3)
+	tst.AssertEqual(t, res["d"], 4)
+	tst.AssertEqual(t, len(res), 4)
+
+	// base must remain untouched
+	tst.AssertEqual(t, base["b"], 2)
+}
+
+func TestMapMergeNoExtras(t *testing.T) {
+	base := map[string]int{"a": 1}
+	res := MapMerge(base)
+	tst.AssertEqual(t, res["a"], 1)
+	tst.AssertEqual(t, len(res), 1)
+}