Writing unit tests for generics function in golang

I have this trivial generic function that retrieves the keys from a map

// getMapKeys returns the keys of a map
func getMapKeys[T comparable, U any](m map[T]U) []T {
	keys := make([]T, len(m))
	i := 0
	for k := range m {
		keys[i] = k
		i++
	}
	return keys
}

I am attempting to write table driven unit tests for it as in:

var testUnitGetMapKeys = []struct {
	name     string
	inputMap interface{}
	expected interface{}
}{
	{
		name:     "string keys",
		inputMap: map[string]int{"foo": 1, "bar": 2, "baz": 3},
		expected: []string{"foo", "bar", "baz"},
	},
	{
		name:     "int keys",
		inputMap: map[int]string{1: "foo", 2: "bar", 3: "baz"},
		expected: []int{1, 2, 3},
	},
	{
		name:     "float64 keys",
		inputMap: map[float64]bool{1.0: true, 2.5: false, 3.1415: true},
		expected: []float64{1.0, 2.5, 3.1415},
	},
}

However, the following code fails

func (us *UnitUtilSuite) TestUnitGetMapKeys() {
	for i := range testUnitGetMapKeys {
		us.T().Run(testUnitGetMapKeys[i].name, func(t *testing.T) {
			gotKeys := getMapKeys(testUnitGetMapKeys[i].inputMap)
		})
	}
}

with

> type interface{} of testUnitGetMapKeys[i].inputMap does not match map[T]U (cannot infer T and U)

This is fixed by explicit casting

gotKeys := getMapKeys(testUnitGetMapKeys[i].inputMap.(map[string]string))

Is there a way to automate these tests rather than having to perform explicit casting for each input test variable?

Note that, unless your generic function is performing some type-specific logic in addition to the generic logic, you gain nothing by testing that function against different types. The function's generic logic is identical for all types in the type parameter's type set and can therefore be fully exercised with a single type.

But if you want to run the tests against different types anyway, you can simply do the following:

var testUnitGetMapKeys = []struct {
    name string
    got  any
    want any
}{
    {
        name: "string keys",
        got:  getMapKeys(map[string]int{"foo": 1, "bar": 2, "baz": 3}),
        want: []string{"foo", "bar", "baz"},
    },
    {
        name: "int keys",
        got:  getMapKeys(map[int]string{1: "foo", 2: "bar", 3: "baz"}),
        want: []int{1, 2, 3},
    },
    {
        name: "float64 keys",
        got:  getMapKeys(map[float64]bool{1.0: true, 2.5: false, 3.1415: true}),
        want: []float64{1.0, 2.5, 3.1415},
    },
}

// ...

func (us *UnitUtilSuite) TestUnitGetMapKeys() {
    for _, tt := range testUnitGetMapKeys {
        us.T().Run(tt.name, func(t *testing.T) {
            if !reflect.DeepEqual(tt.got, tt.want) {
                t.Errorf("got=%v; want=%v", tt.got, tt.want)
            }
        })
    }
}