Écriture de tests unitaires pour les fonctions génériques dans Golang

éditeur php Banana vous propose un article sur l'écriture de tests unitaires pour les fonctions génériques dans Golang. Golang est un langage de programmation fortement typé, cependant, sa prise en charge des génériques est relativement faible. Par conséquent, l’écriture de tests unitaires pour des fonctions génériques peut présenter certains défis. Cet article vous expliquera comment écrire efficacement des tests unitaires pour les fonctions génériques dans Golang afin de garantir la qualité et la fiabilité de votre code. Que vous soyez débutant ou développeur expérimenté, cet article vous fournira des conseils pratiques et des méthodes pour vous aider à gérer facilement les tests unitaires de fonctions génériques. Nous allons jeter un coup d'oeil!

Contenu de la question

J'ai cette fonction générique simple qui récupère une clé de 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
}

J'essaie d'écrire un test unitaire piloté par table comme ceci :

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},
    },
}

Cependant, le code suivant échoue

func (us *unitutilsuite) testunitgetmapkeys() {
    for i := range testunitgetmapkeys {
        us.t().run(testunitgetmapkeys[i].name, func(t *testing.t) {
            gotkeys := getmapkeys(testunitgetmapkeys[i].inputmap)
        })
    }
}

et

type interface{} of testunitgetmapkeys[i].inputmap does not match map[t]u (cannot infer t and u)

Ceci a été corrigé avec une conversion explicite

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

Existe-t-il un moyen d'automatiser ces tests sans avoir à effectuer des conversions explicites pour chaque variable de test d'entrée ?

Solution de contournement

Veuillez noter qu'à moins que votre fonction générique n'exécute une logique spécifique à un type en plus de la logique générique, vous ne gagnerez rien en testant la fonction avec différents types. La logique générale de la fonction est la même pour tous les types du jeu de types du paramètre type, elle peut donc être entièrement exécutée en utilisant un seul type.

Mais si vous souhaitez exécuter des tests sur différents types, vous pouvez simplement faire :

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)
            }
        })
    }
}

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!