다양한 유형 인수를 사용하여 어떻게 효율적으로 일반 함수 테이블 테스트를 수행할 수 있습니까?

Table Go 일반 함수 테스트

Go 1.18에서 프로그래머는 새로운 제네릭 기능을 활용할 수 있습니다. 이 새로운 기능을 탐색하는 동안 개발자는 테이블 테스트를 수행하는 데 어려움을 겪을 수 있습니다. 이 토론에서는 특히 테이블 데이터로 일반 함수를 테스트하는 맥락에서 이러한 과제 중 하나를 살펴봅니다.

이 문제는 테이블 테스트 중에 다양한 유형의 인수를 사용하여 일반 함수를 인스턴스화하려고 할 때 발생합니다. 이 문제를 해결하기 위해 개발자는 다음 코드 조각의 예시처럼 각 기능에 대한 테스트 논리를 다시 선언하는 경우가 많습니다.

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 중국어 웹사이트의 기타 관련 기사를 참조하세요!