Golang-Test-Testmethode

Go-Sprache ist eine schnelle, sichere und einfache Programmiersprache, unterstützt auch Tests und ist sehr benutzerfreundlich. Beim Entwickeln und Testen in Golang kann die Qualität und Genauigkeit des Codes verbessert werden, wodurch Entwicklern die Iteration während der Projektentwicklung erleichtert wird.

In diesem Artikel werden die Testmethoden in Golang vorgestellt, einschließlich Unit-Tests, Benchmark-Tests, Leistungstests und Grenztests. Wir werden gängige Testfälle und Testtechniken teilen, um den Lesern zu helfen, Golang-Testmethoden und -fähigkeiten besser zu verstehen und die Entwicklungseffizienz und -qualität zu verbessern.

1. Unit-Test

1. Grundgerüst des Testfalls

Das Grundgerüst des Testfalls ist:

func TestFunctionName(t *testing.T) {
    // testing function
}

#🎜 🎜# TestFunctionName ist der Name der Testmethode, der mit Test beginnen muss, und der folgende FunctionName kann beliebig benannt werden. testing.T ist ein Testkontext, der zum Planen von Testzugriffsmethoden und zum Aufzeichnen des Teststatus verwendet wird. Es kann verwendet werden, um Ausfälle und Fehler während des Tests zu melden und Testergebnisse an die Konsole auszugeben.

Beispielcode:

package main

import "testing"

func Sum(x int, y int) int {
    return x + y
}

func TestSum(t *testing.T) {
    got := Sum(1, 2)
    want := 3

    if got != want {
        t.Errorf("Sum(1,2) = %d; want %d", got, want)
    }
}

Wenn das Ausgabeergebnis nicht mit der Erwartung übereinstimmt, wird bei laufendem Programm eine Fehlermeldung ausgegeben, zum Beispiel: #🎜🎜 #

--- FAIL: TestSum (0.00s)
    main_test.go:11: Sum(1,2) = 4; want 3
FAIL
exit status 1
FAIL        command-line-arguments  0.005s

2 , Testfallbenennung und -organisation

Den Testmethodennamen von Golang muss „Test“ vorangestellt werden, damit das Testframework sie automatisch identifizieren und ausführen kann, wenn der Befehl „go test“ ausgeführt wird. Um gleichzeitig Konflikte mit anderen Testmethoden mit demselben Namen zu vermeiden, sollte die Benennung von Testmethoden die Eindeutigkeit gewährleisten.

Um die Testfälle besser zu organisieren, können Sie vor den Testfällen einige identifizierbare Bezeichner hinzufügen, wie zum Beispiel:

TestXxx, BenchmarkXxx, BeispielXxx Durchsuchen Führen Sie die entsprechende Funktion aus, wenn Sie das Beispiel auf dem Server ausführen. Verwenden Sie

TestXxxShort. Nur diese Testmethode wird im Befehl go test ausgeführt. Zum Beispiel: TestParseShort()
TestXxxParallel kann parallel ausgeführt werden und t.Parallel() kann verwendet werden, um die Effizienz beim Testen zu verbessern. Zum Beispiel: TestFooParallel()
• 3. Ziele und Implementierung von Testfällen

Durch Unit-Tests kann die Qualität und Genauigkeit von Golang-Code überprüft werden, einschließlich :

Ob die Funktion das erwartete Ergebnis zurückgibt

Ob sie der Laufzeitverarbeitungslogik entspricht
Ob sie mit unerwarteten Situationen umgehen kann #🎜 🎜#
Beispielcode:

• // Add 两个整数x和y
  func Add(x, y int) int {
      return x + y
  }

Entsprechender Testcode:

func TestAdd(t *testing.T) {
    cases := []struct {
        in1, in2, want int
    }{
        {1, 2, 3},
        {0, 0, 0},
        {-1, 1, 0},
    }
    for _, c := range cases {
        got := Add(c.in1, c.in2)
        if got != c.want {
            t.Errorf("Add(%d, %d) == %d, want %d", c.in1, c.in2, got, c.want)
        }
    }
}

Das Testframework von Go ermöglicht es uns, Testfälle mit Kontrollstrukturen zu erstellen , wie Schleifen, Verzweigungen und Ausnahmefehlerbehandlung. Beim Testen von Code überprüfen Sie, ob sich der Code wie vorgesehen verhält, indem Sie Eingabeparameter an eine Funktion übergeben und den Ausgabewert der Funktion mit dem erwarteten Wert vergleichen.

2. Benchmark-Test

Der Golang-Benchmark-Test wird verwendet, um die Leistungsunterschiede von Codes in verschiedenen Situationen zu vergleichen. Benchmarks führen Code mehrmals aus und vergleichen die Laufzeiten. Bei einem Geschwindigkeitsunterschied können Sie ermitteln, welche Implementierung schneller ist.

Das Grundgerüst des Benchmark-Tests ist:

func BenchmarkFunctionName(b *testing.B) {
    // Testing code
}

Unter diesen stellt BenchmarkFunctionName den Namen der Benchmark-Testmethode dar, der mit Benchmark beginnen muss, und der folgende FunctionName kann beliebig benannt werden . testing.B ist der Testkontext, der zur Steuerung des Status und der Iteration des Tests verwendet wird. Während des Benchmark-Tests können Sie damit die Anzahl der Testläufe steuern, Fehler erkennen, die beim Beenden des Tests auftreten können, und andere Probleme erkennen.

Beispielcode:

func BenchmarkAdd(b *testing.B) {
    for i := 0; i < b.N; i++ {
        Add(1, 2)
    }
}

Wenn das Programm ausgeführt wird, lautet das Ausgabeergebnis wie folgt:

BenchmarkAdd-4        2000000000             0.29 ns/op
PASS
ok      _/Users/test/main    1.028s

Unter ihnen

# 🎜🎜##🎜 🎜#"BenchmarkAdd" steht für den Namen des Benchmark-Tests

"4" steht für die Anzahl der von der Testfunktion parallel ausgeführten Goroutinen

"2000000000 " stellt die Gesamtzahl der Tests dar.B.Run führt die Anzahl der Iterationen aus, die Anzahl der Iterationen jeder Iteration des internen adaptiven Ausgleichs der Go-Sprache

• „0,29 ns/op“ bedeutet die durchschnittliche Zeit Die für jede Iteration erforderliche Zeit beträgt 0,29 Nanosekunden.
3. Leistungstest
Der Leistungstest wird verwendet, um die Leistung des Programms im Langzeitbetrieb zu testen. Zum Beispiel:

• func TestPerfAdd(t *testing.T) {
      for i := 0; i < 100000; i++ {
          Add(1, 2)
      }
  }

Unter anderem führt die Testschleife die Funktion 100.000 Mal aus, um ihre Leistungsprobleme bei längerer Ausführung zu testen. Ideal zum Testen der Leistung eines Programms bei Speicherlecks, Dateihandle-Lecks oder anderen Ressourcenlecks.

4. Grenztests

Grenztests werden verwendet, um zu testen, wie gut der Code Randbedingungen handhabt, zum Beispiel:

func TestBubbleSort(t *testing.T) {
    tests := []struct {
        name string
        in   []int
        want []int
    }{
        {"Sorted", []int{1, 2, 3, 4, 5}, []int{1, 2, 3, 4, 5}},
        {"Reverse", []int{5, 4, 3, 2, 1}, []int{1, 2, 3, 4, 5}},
        {"FewElement", []int{5, 3}, []int{3, 5}},
        {"Duplicate", []int{5, 3, 5, 2, 2}, []int{2, 2, 3, 5, 5}},
    }

    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            BubbleSort(tt.in)
            if !reflect.DeepEqual(tt.in, tt.want) {
                t.Errorf("test case %s expects %v but actual is %v",
                    tt.name, tt.want, tt.in)
            }
        })
    }
}

Grenztests können überprüfen dass das Programm verarbeitet Ob die Kantenbedingungen wie erwartet sind, zum Beispiel:

Behandeln Sie einige abnormale Eingaben (z. B. negative Zahlen, 0, maximale/kleine Werte)

# 🎜🎜#Lassen Sie das Programm im Fall der schnellsten oder langsamsten Verarbeitung sein (z. B. ist die Datengröße 0 oder maximal)

Legen Sie Ober- und Untergrenzen für verschiedene Parameter der Funktion fest und testen Sie die Reaktion der Funktion#🎜 🎜#

# 🎜🎜#Zusammenfassung

Beim Testen von Golang-Code sollten Sie die Vielfalt der Testfälle berücksichtigen, um nützliche und umfassende Tests für verschiedene Teile des Programms bereitstellen zu können. Das Golang-Testframework unterstützt Unit-Tests, Benchmark-Tests, Leistungstests und Grenztests, und wir können entsprechend den tatsächlichen Anforderungen auswählen. Darüber hinaus müssen wir einige Best Practices für Tests befolgen, z. B. die Benennung von Testmethoden standardisieren, Testaufgaben rational zuweisen, wiederholte Testlogik extrahieren und die schnelle Ausführung von Tests erleichtern. Ich glaube, dass Leser nach der Beherrschung dieser Testfähigkeiten in der Lage sein werden, bei der Entwicklung von Golang detailliertere Codetests durchzuführen und die Testeffizienz und Codequalität der Entwicklung zu verbessern.

Das obige ist der detaillierte Inhalt vonGolang-Test-Testmethode. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!