Wie können wir generische Go-Funktionen mit unterschiedlichen Typargumenten effizient tabellarisch testen?

Generische Table Go-Funktionen testen

In Go 1.18 können Programmierer die neue generische Funktion nutzen. Bei der Erkundung dieser neuen Funktion können Entwickler bei der Durchführung von Tabellentests auf Herausforderungen stoßen. Eine solche Herausforderung wird in dieser Diskussion untersucht, insbesondere im Zusammenhang mit dem Testen generischer Funktionen mit Tabellendaten.

Das Problem tritt auf, wenn versucht wird, generische Funktionen mit verschiedenen Arten von Argumenten während des Tabellentests zu instanziieren. Um dies zu beheben, greifen Entwickler häufig auf die Neudeklaration der Testlogik für jede Funktion zurück, wie im folgenden Codeausschnitt veranschaulicht:

package main

import (
    "testing"

    "github.com/stretchr/testify/assert"
)

type Item interface {
    int | string
}

type store[T Item] map[int64]T

// add adds an Item to the map if the id of the Item isn't present already
func (s store[T]) add(key int64, val T) {
    _, exists := s[key]
    if exists {
        return
    }
    s[key] = val
}

func TestStore(t *testing.T) {
    t.Run("ints", testInt)
    t.Run("strings", testString)
}

type testCase[T Item] struct {
    name     string
    start    store[T]
    key      int64
    val      T
    expected store[T]
}

func testString(t *testing.T) {
    t.Parallel()
    tests := []testCase[string]{
        {
            name:  "empty map",
            start: store[string]{},
            key:   123,
            val:   "test",
            expected: store[string]{
                123: "test",
            },
        },
        {
            name: "existing key",
            start: store[string]{
                123: "test",
            },
            key: 123,
            val: "newVal",
            expected: store[string]{
                123: "test",
            },
        },
    }
    for _, tc := range tests {
        t.Run(tc.name, runTestCase(tc))
    }
}

func testInt(t *testing.T) {
    t.Parallel()
    tests := []testCase[int]{
        {
            name:  "empty map",
            start: store[int]{},
            key:   123,
            val:   456,
            expected: store[int]{
                123: 456,
            },
        },
        {
            name: "existing key",
            start: store[int]{
                123: 456,
            },
            key: 123,
            val: 999,
            expected: store[int]{
                123: 456,
            },
        },
    }
    for _, tc := range tests {
        t.Run(tc.name, runTestCase(tc))
    }
}

func runTestCase[T Item](tc testCase[T]) func(t *testing.T) {
    return func(t *testing.T) {
        tc.start.add(tc.key, tc.val)
        assert.Equal(t, tc.start, tc.expected)
    }
}

Dieser Ansatz erfordert jedoch eine redundante Testlogik für jede Funktion. Die Essenz generischer Typen liegt in ihrer Fähigkeit, mit beliebigen Typen zu arbeiten, und Einschränkungen stellen sicher, dass solche Typen dieselben Operationen unterstützen.

Anstatt verschiedene Typen exzessiv zu testen, ist es klüger, sich auf das Testen nur dieser Typen zu konzentrieren die bei der Verwendung von Operatoren unterschiedliche Verhaltensweisen aufweisen. Beispielsweise hat der Operator „ “ unterschiedliche Bedeutungen für Zahlen (Summierung) und Zeichenfolgen (Verkettung), oder der Operator „<“ und „>“ Operatoren haben unterschiedliche Interpretationen für Zahlen (größer/kleiner) und Zeichenfolgen (lexikografische Reihenfolge).

Um dieses Problem weiter zu veranschaulichen, sollten Entwickler auf eine ähnliche Diskussion verweisen, in der der Benutzer versucht hat, Tabellentests mit generischen Funktionen durchzuführen.

Das obige ist der detaillierte Inhalt vonWie können wir generische Go-Funktionen mit unterschiedlichen Typargumenten effizient tabellarisch testen?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!