Shit ton of tests

sliceutils/sliceUtils_test.go

@@ -0,0 +1,243 @@
+package sliceutils_test
+
+import (
+	"reflect"
+	"testing"
+
+	"git.mstar.dev/mstar/goutils/sliceutils"
+)
+
+func TestMap(t *testing.T) {
+	in := []int8{1, 2, 3, 4}
+	out := []int16{2, 4, 6, 8}
+	got := sliceutils.Map(in, func(t int8) int16 { return int16(t) * 2 })
+	if !reflect.DeepEqual(out, got) {
+		t.Fatalf("Map() = %v, want %v", got, out)
+	}
+}
+
+func TestFilter(t *testing.T) {
+	in := []int8{1, 2, 3, 4}
+	out := []int8{2, 4}
+	got := sliceutils.Filter(in, func(t int8) bool { return t%2 == 0 })
+	if !reflect.DeepEqual(out, got) {
+		t.Fatalf("Map() = %v, want %v", got, out)
+	}
+}
+
+func TestRemoveDuplicate(t *testing.T) {
+	in := []int8{1, 2, 2, 3, 3, 3, 4}
+	out := []int8{1, 2, 3, 4}
+	got := sliceutils.RemoveDuplicate(in)
+	if !reflect.DeepEqual(out, got) {
+		t.Fatalf("Map() = %v, want %v", got, out)
+	}
+}
+
+func TestReverse(t *testing.T) {
+	in := []int8{1, 2, 3, 4}
+	out := []int8{4, 3, 2, 1}
+	sliceutils.Reverse(in)
+	if !reflect.DeepEqual(out, in) {
+		t.Fatalf("Map() = %v, want %v", in, out)
+	}
+}
+
+func TestCompareOrdered(t *testing.T) {
+	type args struct {
+		a []int
+		b []int
+	}
+	tests := []struct {
+		name string
+		args args
+		want bool
+	}{
+		{
+			name: "equal",
+			args: args{
+				a: []int{1, 2, 3, 4},
+				b: []int{1, 2, 3, 4},
+			},
+			want: true,
+		},
+		{
+			name: "not equal, same len",
+			args: args{
+				a: []int{1, 2, 3, 4},
+				b: []int{0, 1, 2, 3},
+			},
+			want: false,
+		},
+		{
+			name: "not equal, diff len",
+			args: args{
+				a: []int{1, 2, 3, 4},
+				b: []int{0, 1, 2},
+			},
+			want: false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := sliceutils.CompareOrdered(tt.args.a, tt.args.b); got != tt.want {
+				t.Errorf("CompareOrdered() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestCompareUnordered(t *testing.T) {
+	type args struct {
+		a []int
+		b []int
+	}
+	tests := []struct {
+		name string
+		args args
+		want bool
+	}{
+		{
+			name: "equal ordered",
+			args: args{
+				a: []int{1, 2, 3, 4},
+				b: []int{1, 2, 3, 4},
+			},
+			want: true,
+		},
+		{
+			name: "equal unordered",
+			args: args{
+				a: []int{1, 2, 3, 4},
+				b: []int{2, 4, 3, 1},
+			},
+			want: true,
+		},
+		{
+			name: "not equal, same len",
+			args: args{
+				a: []int{1, 2, 3, 4},
+				b: []int{0, 2, 3, 4},
+			},
+			want: false,
+		},
+		{
+			name: "not equal, diff len",
+			args: args{
+				a: []int{1, 2, 3, 4},
+				b: []int{0, 1, 2},
+			},
+			want: false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := sliceutils.CompareUnordered(tt.args.a, tt.args.b); got != tt.want {
+				t.Errorf("CompareUnordered() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestContains(t *testing.T) {
+	type args struct {
+		a []int
+		b int
+	}
+	tests := []struct {
+		name string
+		args args
+		want bool
+	}{
+		{
+			name: "contains",
+			args: args{
+				a: []int{1, 2, 3, 4},
+				b: 3,
+			},
+			want: true,
+		},
+		{
+			name: "doesnt contain",
+			args: args{
+				a: []int{1, 2, 3, 4},
+				b: 0,
+			},
+			want: false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := sliceutils.Contains(tt.args.a, tt.args.b); got != tt.want {
+				t.Errorf("Contains() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestContainsFunc(t *testing.T) {
+	type args struct {
+		a []int
+		f func(t int) bool
+	}
+	tests := []struct {
+		name string
+		args args
+		want bool
+	}{
+		{
+			name: "contains",
+			args: args{
+				a: []int{1, 2, 3, 4},
+				f: func(t int) bool { return t == 2 },
+			},
+			want: true,
+		},
+		{
+			name: "doesnt contain",
+			args: args{
+				a: []int{1, 2, 3, 4},
+				f: func(t int) bool { return t == 9 },
+			},
+			want: false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := sliceutils.ContainsFunc(tt.args.a, tt.args.f); got != tt.want {
+				t.Errorf("ContainsFunc() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestCompact(t *testing.T) {
+	type args struct {
+		a         []int
+		compactor func(acc int, next int) int
+	}
+	tests := []struct {
+		name string
+		args args
+		want int
+	}{
+		{
+			name: "sum",
+			args: args{
+				a:         []int{1, 2, 3, 4},
+				compactor: func(acc, next int) int { return acc + next },
+			},
+			want: 1 + 2 + 3 + 4,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := sliceutils.Compact(tt.args.a, tt.args.compactor); !reflect.DeepEqual(
+				got,
+				tt.want,
+			) {
+				t.Errorf("Compact() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}