Wie kann die Ausführung von Golang-Unit-Tests beschleunigt werden?-Golang-php.cn

Wie kann die Ausführung von Golang-Unit-Tests beschleunigt werden?

王林

Freigeben： 2024-06-05 19:20:00

Original

598 Leute haben es durchsucht

Um die Ausführung von Golang-Einheitstests zu beschleunigen, können die folgenden Maßnahmen ergriffen werden: 1. Führen Sie parallele Tests durch, um mehrere Tests gleichzeitig auszuführen. 2. Verwenden Sie Testdaten wieder, um den Aufwand für die Erstellung und Initialisierung von Daten zu reduzieren Abhängigkeiten durch Mocking, um Ungenauigkeiten zu vermeiden. 4. Verwenden Sie Benching, um den Test zu finden, der die längste Ausführungszeit benötigt, und ihn zu optimieren.

如何加速 Golang 单元测试的执行速度？

Wie kann die Ausführung von Golang-Unit-Tests beschleunigt werden?

Obwohl Golangs Unit-Tests leistungsstark sind, ist seine Ausführungsgeschwindigkeit langsam, was sich auf die Entwicklungseffizienz auswirkt. In diesem Artikel werden verschiedene Methoden vorgestellt, um die Testausführung zu beschleunigen und den Entwicklungsprozess zu optimieren.

1. Paralleles Testen

Go unterstützt paralleles Testen ab 1.18, d. h. das gleichzeitige Ausführen mehrerer Tests. Dies ist besonders bei großen Projekten von Vorteil.

package main

import (
    "testing"
    "sync"
)

// TestParallel runs tests in parallel using the t.Parallel() function.
func TestParallel(t *testing.T) {
    // Create a channel to signal completion.
    done := make(chan struct{})
    defer close(done)

    // Create a wait group to track running tests.
    var wg sync.WaitGroup

    // Start multiple test goroutines.
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func(i int) {
            defer wg.Done()

            t.Run("Test"+strconv.Itoa(i), func(t *testing.T) {
                // Your test code here
                time.Sleep(100 * time.Millisecond)
            })
        }(i)
    }

    // Wait for all tests to complete before returning.
    go func() {
        wg.Wait()
        close(done)
    }()

    <-done // Block until all tests have finished.
}

Nach dem Login kopieren

2. Testdaten wiederverwenden

Das Erstellen und Wiederverwenden von Testdaten im Voraus kann die Testausführungszeit verkürzen.

package main

import (
    "testing"
    "sync"
)

var testData map[string]interface{}
var testDataLock sync.RWMutex

// TestDataSetup runs once before all tests and creates test data.
func TestDataSetup(t *testing.T) {
    testDataLock.Lock()
    defer testDataLock.Unlock()
    if testData == nil {
        // Create and initialize test data here.
    }
}

// TestExample runs a test using the shared test data.
func TestExample(t *testing.T) {
    TestDataSetup(t) // Ensure test data is available before each test.

    // Use testData in your test code.
}

Nach dem Login kopieren

3. Mocking

Simulieren Sie externe Anrufe und beseitigen Sie Engpässe durch Mocking von Abhängigkeiten.

package main

import (
    "testing"
)

type MyInterface interface {
    DoSomething()
}

type MockMyInterface struct {
    DoSomethingCalled bool
}

func (m *MockMyInterface) DoSomething() {
    m.DoSomethingCalled = true
}

// TestExample uses a mocked dependency to speed up testing.
func TestExample(t *testing.T) {
    mock := &MockMyInterface{}
    // Pass mock to your code under test.

    // Assertions using mock.DoSomethingCalled to verify behavior.
}

Nach dem Login kopieren

4. Benching

Verwenden Sie Benching, um die Tests zu finden, deren Ausführung am längsten dauert, und um sie zu optimieren.

package main

import (
    "testing"
    "time"
)

func TestSlow(t *testing.T) {
    for i := 0; i < 10000; i++ {
        // Time-consuming operation.
    }
}

func TestFast(t *testing.T) {
    for i := 0; i < 100; i++ {
        // Fast operation.
    }
}

func TestBenchmark(t *testing.T) {
    for i := 0; i < benchmarkN; i++ {
        t.Run("TestSlow", func(t *testing.T) {
            b := testing.Benchmark(TestSlow)
            log.Println(b.N, b.NsPerOp())
        })

        t.Run("TestFast", func(t *testing.T) {
            b := testing.Benchmark(TestFast)
            log.Println(b.N, b.NsPerOp())
        })
    }
}

Nach dem Login kopieren

Das obige ist der detaillierte Inhalt vonWie kann die Ausführung von Golang-Unit-Tests beschleunigt werden?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!