Test Golang Goroutine

Question

Ich habe herum gesucht, aber bisher nur ähnlichen Artikel geschrieben here von Ariejan de Vroom.

Ich würde gerne wissen, ob ich goroutine in Einheit testen kann, so dass es genau die gleichzeitige Anzahl von goroutines läuft läuft und kann mir sagen, ob sie korrekt goroutine in der Zahl, die ich angegeben habe.

Ich habe den folgenden Code zum Beispiel ..

import (
    "testing" 
    "github.com/stretchr/testify/assert" 
) 

func createList(job int, done chan bool) { 
    time.Sleep(500) 
    // do something 
    time.Sleep(500) 
    done <- true 
    return 
} 

func TestNewList(t *testing.T) { 
    list := NewList() 
    if assert.NotNil(t, list) { 
    const numGoRoutines = 16 
    jobs := make(chan int, numGoRoutines) 
    done := make(chan bool, 1) 

    for j := 1; j <= numGoRoutines; j++ { 
     jobs <- j 
     go createList(j, done) 
     fmt.Println("sent job", j) 
    } 
    close(jobs) 
    fmt.Println("sent all jobs") 
    <-done 
} 

Answer 1

Eine mögliche approch oder analysieren die Ausgabe von runtime.debug.PrintStack() zu verwenden, um wäre, alle goroutines zu einem bestimmten Zeitpunkt zu sehen.

Diese Optionen sind detailliert in "How to dump goroutine stacktraces?".

Answer 2

Einfach in Ihrem Beispiel können Sie die done Kanal numGoRoutines mal lesen, um zu überprüfen, dass Sie so viele Antworten bekommen?

Answer 3

Wie ich verstanden habe, sind Sie bereit, die Anzahl der gleichzeitig laufenden Routinen zu begrenzen und zu überprüfen, ob sie ordnungsgemäß funktioniert. Ich würde vorschlagen, eine Funktion zu schreiben, die eine Routine als und ein Argument nimmt und eine Scheinroutine benutzt, um sie zu testen.
Im folgenden Beispiel spawn Funktion läuft fn Routinen count mal aber nicht mehr als limit Routinen gleichzeitig. Ich habe es in die Hauptfunktion eingepackt, um es auf dem Spielplatz laufen zu lassen, aber Sie können den gleichen Ansatz für Ihre Testmethode verwenden.

package main 

import (
    "fmt" 
    "sync" 
    "time" 
) 

func spawn(fn func(), count int, limit int) { 
    limiter := make(chan bool, limit) 

    spawned := func() { 
     defer func() { <-limiter }() 
     fn() 
    } 

    for i := 0; i < count; i++ { 
     limiter <- true 
     go spawned() 
    } 
} 

func main() { 

    count := 10 
    limit := 3 

    var wg sync.WaitGroup 
    wg.Add(count) 

    concurrentCount := 0 
    failed := false 

    var mock = func() { 
     defer func() { 
      wg.Done() 
      concurrentCount-- 
     }() 

     concurrentCount++ 
     if concurrentCount > limit { 
      failed = true // test could be failed here without waiting all routines finish 
     } 

     time.Sleep(100) 
    } 

    spawn(mock, count, limit) 

    wg.Wait() 

    if failed { 
     fmt.Println("Test failed") 
    } else { 
     fmt.Println("Test passed") 
    } 
} 

Playground