maps_test.go

package utils

import (
	"reflect"
	"strings"
	"testing"
)

func TestToMap(t *testing.T) {
	type args[T any, K comparable] struct {
		list []T
		fn   func(T) K
	}
	type testCase[T any, K comparable] struct {
		name string
		args args[T, K]
		want map[K][]T
	}

	tests := []testCase[string, int]{
		{
			name: "empty",
			args: args[string, int]{
				list: []string{},
				fn:   func(s string) int { return len(s) },
			},
			want: map[int][]string{},
		},
		{
			name: "one element",
			args: args[string, int]{
				list: []string{"xd"},
				fn:   func(s string) int { return len(s) },
			},
			want: map[int][]string{2: {"xd"}},
		},
		{
			name: "group by string length",
			args: args[string, int]{
				list: []string{"xd", "xdd", "xddd", "aa"},
				fn:   func(s string) int { return len(s) },
			},
			want: map[int][]string{
				2: {"xd", "aa"},
				3: {"xdd"},
				4: {"xddd"},
			},
		},
		{
			name: "duplicate elements",
			args: args[string, int]{
				list: []string{"xd", "xdd", "xddd", "aa", "xd", "xd"},
				fn:   func(s string) int { return len(s) },
			},
			want: map[int][]string{
				2: {"xd", "aa", "xd", "xd"},
				3: {"xdd"},
				4: {"xddd"},
			},
		},
		{
			name: "group by first letter (rune key)",
			args: args[string, int]{
				list: []string{"apple", "ant", "banana", "boat", "cat"},
				fn: func(s string) int {
					if len(s) == 0 {
						return 0
					}
					return int(rune(s[0]))
				},
			},
			want: map[int][]string{
				int('a'): {"apple", "ant"},
				int('b'): {"banana", "boat"},
				int('c'): {"cat"},
			},
		},
		{
			name: "strings with empty element",
			args: args[string, int]{
				list: []string{"", "a", "bb"},
				fn:   func(s string) int { return len(s) },
			},
			want: map[int][]string{
				0: {""},
				1: {"a"},
				2: {"bb"},
			},
		},
	}

	// additional type test: integers grouped by modulo
	intTests := []testCase[int, int]{
		{
			name: "ints grouped by modulo",
			args: args[int, int]{
				list: []int{1, 2, 3, 4, 5, 6},
				fn:   func(i int) int { return i % 2 },
			},
			want: map[int][]int{
				1: {1, 3, 5},
				0: {2, 4, 6},
			},
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := ToMap(tt.args.list, tt.args.fn); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("ToMap() = %v, want %v", got, tt.want)
			}
		})
	}

	for _, tt := range intTests {
		t.Run(tt.name, func(t *testing.T) {
			if got := ToMap(tt.args.list, tt.args.fn); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("ToMap() ints = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestMapValues(t *testing.T) {
	type args[T any, R any, K comparable] struct {
		m  map[K]T
		fn func(T) R
	}
	type testCase[T any, R any, K comparable] struct {
		name string
		args args[T, R, K]
		want map[K]R
	}

	tests := []testCase[string, int, string]{
		{
			name: "empty",
			args: args[string, int, string]{
				m:  map[string]string{},
				fn: func(s string) int { return len(s) },
			},
			want: map[string]int{},
		},
		{
			name: "single element",
			args: args[string, int, string]{
				m:  map[string]string{"xd": "xd"},
				fn: func(s string) int { return len(s) },
			},
			want: map[string]int{"xd": 2},
		},
		{
			name: "multiple values length",
			args: args[string, int, string]{
				m: map[string]string{
					"a":   "apple",
					"bb":  "boat",
					"ccc": "cat",
				},
				fn: func(s string) int { return len(s) },
			},
			want: map[string]int{
				"a":   5,
				"bb":  4,
				"ccc": 3,
			},
		},
	}

	stringStringCases := []testCase[string, string, string]{
		{
			name: "uppercase transform",
			args: args[string, string, string]{
				m: map[string]string{
					"one": "a",
					"two": "b",
				},
				fn: func(s string) string { return strings.ToUpper(s) },
			},
			want: map[string]string{
				"one": "A",
				"two": "B",
			},
		},
	}

	// Integer map variant
	intTests := []testCase[int, int, string]{
		{
			name: "squared integers",
			args: args[int, int, string]{
				m: map[string]int{
					"a": 1,
					"b": 2,
					"c": 3,
				},
				fn: func(i int) int { return i * i },
			},
			want: map[string]int{
				"a": 1,
				"b": 4,
				"c": 9,
			},
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := MapValues(tt.args.m, tt.args.fn); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("MapValues() = %v, want %v", got, tt.want)
			}
		})
	}

	for _, tt := range stringStringCases {
		t.Run(tt.name, func(t *testing.T) {
			if got := MapValues(tt.args.m, tt.args.fn); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("MapValues() = %v, want %v", got, tt.want)
			}
		})
	}

	for _, tt := range intTests {
		t.Run(tt.name, func(t *testing.T) {
			if got := MapValues(tt.args.m, tt.args.fn); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("MapValues() int test = %v, want %v", got, tt.want)
			}
		})
	}
}