Dining philosophers problem in Go fails unit test - multithreading

Question

I'm taking a Go course, that has an assignment as follows:
Implement the dining philosopher's problem with the following
constraints/modifications.
There should be 5 philosophers sharing chopsticks, with one chopstick between each adjacent pair of philosophers.
Each philosopher should eat only 3 times (not in an infinite loop as we did in lecture).
The philosophers pick up the chopsticks in any order, not lowest-numbered first (which we did in lecture).
In order to eat, a philosopher must get permission from a host which executes in its own goroutine.
The host allows no more than 2 philosophers to eat concurrently.
Each philosopher is numbered, 1 through 5.
When a philosopher starts eating (after it has obtained necessary
locks) it prints "starting to eat " on a line by itself, where
is the number of the philosopher.
When a philosopher finishes eating (before it has released its locks)
it prints "finishing eating " on a line by itself, where
is the number of the philosopher.
My implementation:
package main
import (
"fmt"
"io"
"math/rand"
"os"
"sync"
"time"
)
const (
NumPhilosophers = 5
NumEatMaxTimes = 3
NumMaxAllowedToEat = 2
)
type chopstick struct{ sync.Mutex }
type philosopher struct {
num int
cs []*chopstick
}
func setTable() []*philosopher {
cs := make([]*chopstick, NumPhilosophers)
for i := 0; i < NumPhilosophers; i++ {
cs[i] = new(chopstick)
}
ph := make([]*philosopher, NumPhilosophers)
for i := 0; i < NumPhilosophers; i++ {
ph[i] = &philosopher{i + 1, []*chopstick{cs[i], cs[(i+1)%NumPhilosophers]}}
}
return ph
}
func (ph philosopher) eat(sem chan int, wg *sync.WaitGroup, w io.Writer) {
for i := 0; i < NumEatMaxTimes; i++ {
/* Ask host for permission to eat */
sem <- 1
/*
Pick any of the left or right chopsticks.
Notice how the methods on the Mutex can be called directly on a chopstick due to embedding.
*/
firstCS := rand.Intn(2)
secondCS := (firstCS + 1) % 2
ph.cs[firstCS].Lock()
ph.cs[secondCS].Lock()
fmt.Fprintf(w, "Starting to eat %d\n", ph.num)
x := rand.Intn(NumEatMaxTimes)
time.Sleep(time.Duration(x) * time.Second)
fmt.Fprintf(w, "Finishing eating %d\n", ph.num)
ph.cs[secondCS].Unlock()
ph.cs[firstCS].Unlock()
<-sem
}
wg.Done()
}
func main() {
run(os.Stdout)
}
func run(w io.Writer) {
var sem = make(chan int, NumMaxAllowedToEat)
rand.Seed(time.Now().UnixNano())
var wg sync.WaitGroup
allPh := setTable()
wg.Add(len(allPh))
for _, ph := range allPh {
go ph.eat(sem, &wg, w)
}
wg.Wait()
}
Unit test:
func TestRun(t *testing.T) {
var out bytes.Buffer
run(&out)
lines := strings.Split(strings.ReplaceAll(out.String(), "\r\n", "\n"), "\n")
eating := make(map[int]bool)
timesEaten := make(map[int]int)
for _, line := range lines {
if line == "" {
continue
}
fmt.Println(line)
tokens := strings.Fields(line)
i, err := strconv.Atoi(tokens[len(tokens)-1])
if err != nil {
t.Errorf("Bad line: %s", line)
}
s := strings.ToLower(tokens[0])
if s == "starting" {
if len(eating) > (NumMaxAllowedToEat - 1) {
t.Errorf("%v are eating at the same time", eating)
}
_, ok := eating[i]
if ok {
t.Errorf("%d started before finishing", i)
}
eating[i] = true
} else if s == "finishing" {
_, ok := eating[i]
if !ok {
t.Errorf("%d finished without starting", i)
}
delete(eating, i)
timesEaten[i] = timesEaten[i] + 1
}
}
for k, v := range timesEaten {
if v > NumEatMaxTimes {
t.Errorf("%d ate %d times", k, v)
}
}
if len(timesEaten) != NumPhilosophers {
t.Error("One or more didn't get to eat")
}
}
The problem is, the test randomly fails. Below is one execution (line numbers added):
1. Starting to eat 5
2. Starting to eat 2
3. Finishing eating 2
4. Finishing eating 5
5. Starting to eat 3
6. Starting to eat 1
7. Finishing eating 1
8. Finishing eating 3
9. Starting to eat 2
10. Starting to eat 4
11. Finishing eating 4
12. Starting to eat 5
13. Finishing eating 2
14. Finishing eating 5
15. Starting to eat 3
16. Finishing eating 3
17. Starting to eat 1
18. Finishing eating 4
19. Finishing eating 1
20. Starting to eat 5
21. Finishing eating 5
22. Starting to eat 3
23. Finishing eating 3
24. Starting to eat 4
25. Starting to eat 2
26. Finishing eating 2
27. Starting to eat 1
28. Finishing eating 4
29. Finishing eating 1
--- FAIL: TestRun (12.01s)
main_test.go:43: 4 finished without starting
Philosopher 4 has started on lines 10, and 24 and finished on lines 11, 18, and 28. Line 28 is unmatched, so the test correctly complains. However, I'm having a hard time finding the bug. Can you help?

Answer 1

Answering my own question, it turned out that byes.Buffer is not thread-safe. I ended up using go-fakeio library for the test as shown below.
s, err := fakeio.Stderr().Stdout().Do(run)
if err != nil {
t.Errorf("%v", err)
}
The rest of the test remains the same. main.run function no longer needs an io.Writer since the fakeio library replaces stderr and stdout.