1 files changed, 48 insertions, 71 deletions

diff --git a/xdelta3/go/src/xdelta/tgroup.go b/xdelta3/go/src/xdelta/tgroup.go
index f94c03e..7f6c875 100644
--- a/xdelta3/go/src/xdelta/tgroup.go
+++ b/xdelta3/go/src/xdelta/tgroup.go
@@ -3,114 +3,91 @@ package xdelta
 import (
         "fmt"
         "sync"
-        "time"
 )
 
 type TestGroup struct {
         *Runner
         sync.Mutex
-        running []Goroutine
+        sync.WaitGroup
+        running []*Goroutine
         errors []error
-        waitChan <-chan bool
+        nonerrors []error  // For tolerated / expected conditions
 }
 
 type Goroutine struct {
+        *TestGroup
         name string
-        errChan chan error
+        done bool
 }
 
-func NewTestGroup(r *Runner) (*TestGroup, Goroutine) {
-        g := Goroutine{"main", make(chan error, 1)}
-        wc := make(chan bool)
-        tg := &TestGroup{Runner: r, running: []Goroutine{g}, waitChan: wc}
-        go waitAll(tg, wc)
-        return tg, g
+func NewTestGroup(r *Runner) (*TestGroup, *Goroutine) {
+        tg := &TestGroup{Runner: r}
+        tg.WaitGroup.Add(1)
+        g0 := &Goroutine{tg, "main", false}
+        tg.running = append(tg.running, g0)
+        return tg, g0
 }
 
 func (g *Goroutine) String() string {
         return fmt.Sprint("[", g.name, "]")
 }
 
-func (g *Goroutine) OK() {
-        fmt.Println("OK", g)
-        if g.errChan != nil {
-                g.errChan <- nil
-                _ = <- g.errChan
-                g.errChan = nil
+func (g *Goroutine) finish(err error) {
+        wait := false
+        tg := g.TestGroup
+        tg.Lock()
+        if g.done {
+                if err != nil {
+                        tg.nonerrors = append(tg.nonerrors, err)
+                }
+        } else {
+                wait = true
+                g.done = true
+                if err != nil {
+                        tg.errors = append(tg.errors, err)
+                }
+        }
+        tg.Unlock()
+        if wait {
+                tg.WaitGroup.Done()
         }
 }
 
+func (g *Goroutine) OK() {
+        g.finish(nil)
+}
+
 func (g *Goroutine) Panic(err error) {
-        fmt.Println("PANIC", g, err)
-        if g.errChan != nil {
-                g.errChan <- err
-                _ = <- g.errChan
-        }
+        g.finish(err)
         select {}
 }
 
-func (t *TestGroup) Go(name string, f func(Goroutine)) Goroutine {
-        g := Goroutine{name, make(chan error, 1)}
+func (t *TestGroup) Go(name string, f func(*Goroutine)) *Goroutine {
+        g := &Goroutine{t, name, false}
         t.Lock()
+        t.WaitGroup.Add(1)
         t.running = append(t.running, g)
         t.Unlock()
         go f(g)
         return g
 }
 
-func (t *TestGroup) Wait(self Goroutine, procs... *Run) {
+func (t *TestGroup) Wait(self *Goroutine, procs... *Run) {
         self.OK()
-        t.Lock()
-        wc := t.waitChan
-        t.waitChan = nil
-        t.Unlock()
-        _ = <- wc
-        t.Lock()
-        errs := t.errors
-        t.Unlock()
+        t.WaitGroup.Wait()
         for _, p := range procs {
                 if err := p.Wait(); err != nil {
-                        errs = append(errs, err)
+                        t.errors = append(t.errors, err)
                 }
         }
-        if len(errs) != 0 {
-                for _, err := range errs {
-                        fmt.Println(err)
-                }
-                panic(fmt.Sprint(len(errs), " errors"))
+        for _, err := range t.errors {
+                fmt.Println(":ERROR:", err)
         }
-}
-
-func waitAll(t *TestGroup, wc chan bool) {
-        for {
-                t.Lock()
-                if len(t.running) == 0 {
-                        t.Unlock()
-                        break
-                }
-                // fmt.Println("----------------------------------------------------------------------")
-                // for _, r := range t.running {
-                //      fmt.Println("Waiting for", r)
-                // }
-                runner := t.running[0]
-                t.running = t.running[1:]
-                t.Unlock()
-
-                timeout := time.After(time.Second)
-
-                select {
-                case err := <- runner.errChan:
-                        runner.errChan <- err
-                        if err != nil {
-                                t.Lock()
-                                t.errors = append(t.errors, err)
-                                t.Unlock()
-                        }
-                case <- timeout:
-                        t.Lock()
-                        t.running = append(t.running, runner)
-                        t.Unlock()
-                }
+        for _, err := range t.nonerrors {
+                fmt.Println("(ERROR)", err)
+        }
+        if len(t.errors) != 0 {
+                panic(fmt.Sprintf("Test failed with", len(t.errors), "errors"))
         }
-        wc <- true
 }
+