異なる型の引数を持つジェネリック関数のテーブル テストを効率的に行うにはどうすればよいでしょうか?

テーブル Go ジェネリック関数のテスト

Go 1.18 では、プログラマは新しいジェネリック機能を利用できます。この新しい機能を検討しているときに、開発者はテーブル テストを実行する際に課題に遭遇する可能性があります。この議論では、特にテーブル データを使用したジェネリック関数のテストのコンテキストで、そのような課題の 1 つを検討します。

この問題は、テーブル テスト中にさまざまな種類の引数を使用してジェネリック関数をインスタンス化しようとすると発生します。これに対処するために、開発者は、次のコード スニペットに示すように、関数ごとにテスト ロジックを再宣言することがよくあります。

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

ただし、このアプローチでは、関数ごとに冗長なテスト ロジックが必要です。ジェネリック型の本質は、任意の型を操作できる機能にあり、制約により、そのような型が同じ操作をサポートすることが保証されます。

異なる型を過度にテストする代わりに、それらの型のみをテストすることに重点を置く方が賢明です。演算子を使用するときに異なる動作を示すもの。たとえば、「 」演算子は数値 (合計) と文字列 (連結) に対して異なる意味を持ちます。また、「<」そして「>」演算子には、数値 (大きい/小さい) と文字列 (辞書順) の解釈が異なります。

この問題をさらに詳しく説明するには、開発者は、ユーザーが汎用関数を使用してテーブル テストを実行しようとした同様の説明を参照する必要があります。

以上が異なる型の引数を持つジェネリック関数のテーブル テストを効率的に行うにはどうすればよいでしょうか?の詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。