Fixes regtest.go running against xdelta3 head

4 files changed, 65 insertions, 97 deletions

diff --git a/xdelta3/go/src/regtest.go b/xdelta3/go/src/regtest.go
index 194761a..adb4ae4 100644
--- a/xdelta3/go/src/regtest.go
+++ b/xdelta3/go/src/regtest.go
@@ -53,7 +53,6 @@ func smokeTest(r *xdelta.Runner, p *xdelta.Program) {
                 g.Panic(errors.New("It's not working!!!"))
         }
         t.Wait(g, enc, dec)
-        fmt.Println("Smoketest pass")
 }
 
 func offsetTest(r *xdelta.Runner, p *xdelta.Program, bufsize, offset, length int64) {
@@ -64,13 +63,13 @@ func offsetTest(r *xdelta.Runner, p *xdelta.Program, bufsize, offset, length int
         // (c) open on a fifo blocks until a reader opens
         // (d) sub-process Wait can invalidate busy file descriptors
         t, g := xdelta.NewTestGroup(r)
-        eargs := []string{"-e", "-0", fmt.Sprint("-B", bufsize), "-vvvvvvv", fmt.Sprint("-W", winsize)}
+        eargs := []string{"-e", "-0", fmt.Sprint("-B", bufsize), "-vv", fmt.Sprint("-W", winsize)}
         enc, err := t.Exec("encode", p, true, eargs)
         if err != nil {
                 g.Panic(err)
         }
         
-        dargs := []string{"-d", fmt.Sprint("-B", bufsize), "-vvvvvvv", fmt.Sprint("-W", winsize)}
+        dargs := []string{"-d", fmt.Sprint("-B", bufsize), "-vv", fmt.Sprint("-W", winsize)}
         dec, err := t.Exec("decode", p, true, dargs)
         if err != nil {
                 g.Panic(err)
@@ -101,8 +100,11 @@ func main() {
 
         prog := &xdelta.Program{xdelta3}
 
-        //smokeTest(r, prog)
+        smokeTest(r, prog)
+        fmt.Println("Smoke-test pass")
+
         offsetTest(r, prog, 4 << 20, 3 << 20, 5 << 20)
+        fmt.Println("Offset-test pass")
 
         //offsetTest(r, xdelta.NewTestGroup(), prog, 1 << 31, 1 << 32, 1 << 33)
 }
diff --git a/xdelta3/go/src/xdelta/rstream.go b/xdelta3/go/src/xdelta/rstream.go
index 7d205c6..9481f22 100644
--- a/xdelta3/go/src/xdelta/rstream.go
+++ b/xdelta3/go/src/xdelta/rstream.go
@@ -13,15 +13,15 @@ const (
 
 func (t *TestGroup) WriteRstreams(desc string, seed, offset, len int64,
         src, tgt io.WriteCloser) {
-        t.Go("src-write:"+desc, func (g Goroutine) {
+        t.Go("src-write:"+desc, func (g *Goroutine) {
                 writeOne(g, seed, 0, len, src, false)
         })
-        t.Go("tgt-write:"+desc, func (g Goroutine) {
+        t.Go("tgt-write:"+desc, func (g *Goroutine) {
                 writeOne(g, seed, offset, len, tgt, true)
         })
 }
 
-func writeOne(g Goroutine, seed, offset, len int64, stream io.WriteCloser, readall bool) {
+func writeOne(g *Goroutine, seed, offset, len int64, stream io.WriteCloser, readall bool) {
         if !readall {
                 // Allow the source-read to fail or block until the process terminates.
                 // This behavior is reserved for the decoder, which is not required to
@@ -40,27 +40,23 @@ func writeOne(g Goroutine, seed, offset, len int64, stream io.WriteCloser, reada
                 len - offset, stream); err != nil {
                 g.Panic(err)
         }
-        fmt.Println(g, "closing", len)
         if err := stream.Close(); err != nil {
                 g.Panic(err)
         }
         g.OK()
 }
 
-func writeRand(g Goroutine, r *rand.Rand, len int64, s io.Writer) error {
+func writeRand(g *Goroutine, r *rand.Rand, len int64, s io.Writer) error {
         blk := make([]byte, blocksize)
-        fmt.Println(g, "rstream", len)
         for len > 0 {
                 fillRand(r, blk)
                 c := blocksize
                 if len < blocksize {
                         c = int(len)
                 }
-                fmt.Println(g, "writing...", c, s)
                 if _, err := s.Write(blk[0:c]); err != nil {
                         return err
                 }
-                fmt.Println(g, "...written", c)
                 len -= int64(c)
         }
         return nil
diff --git a/xdelta3/go/src/xdelta/test.go b/xdelta3/go/src/xdelta/test.go
index 427e4c7..00f3dd7 100644
--- a/xdelta3/go/src/xdelta/test.go
+++ b/xdelta3/go/src/xdelta/test.go
@@ -35,9 +35,8 @@ type Run struct {
 
 func (t *TestGroup) Drain(f io.ReadCloser, desc string) <-chan []byte {
         c := make(chan []byte)
-        t.Go(desc, func(g Goroutine) {
+        t.Go(desc, func(g *Goroutine) {
                 if b, err := ioutil.ReadAll(f); err != nil {
-                        fmt.Println("Drain", err)
                         g.Panic(err)
                 } else {
                         c <- b
@@ -47,8 +46,8 @@ func (t *TestGroup) Drain(f io.ReadCloser, desc string) <-chan []byte {
         return c
 }
 
-func (t *TestGroup) Empty(f io.ReadCloser, desc string) Goroutine {
-        return t.Go("empty:"+desc, func (g Goroutine) {
+func (t *TestGroup) Empty(f io.ReadCloser, desc string) *Goroutine {
+        return t.Go("empty:"+desc, func (g *Goroutine) {
                 s := bufio.NewScanner(f)
                 for s.Scan() {
                         os.Stderr.Write([]byte(fmt.Sprint(desc, ": ", s.Text(), "\n")))
@@ -64,18 +63,16 @@ func (t *TestGroup) Empty(f io.ReadCloser, desc string) Goroutine {
 
 func TestWrite(what string, f io.WriteCloser, b []byte) error {
         if _, err := f.Write(b); err != nil {
-                fmt.Println("Write", err)
                 return errors.New(fmt.Sprint(what, ":", err))
         }
         if err := f.Close(); err != nil {
-                fmt.Println("Close", err)
                 return errors.New(fmt.Sprint(what, ":", err))
         }
         return nil
 }
 
-func (t *TestGroup) CopyStreams(r io.ReadCloser, w io.WriteCloser) Goroutine {
-        return t.Go("copy", func(g Goroutine) {
+func (t *TestGroup) CopyStreams(r io.ReadCloser, w io.WriteCloser) *Goroutine {
+        return t.Go("copy", func(g *Goroutine) {
                 _, err := io.Copy(w, r)
                 if err != nil {
                         g.Panic(err)
@@ -92,8 +89,8 @@ func (t *TestGroup) CopyStreams(r io.ReadCloser, w io.WriteCloser) Goroutine {
         })
 }
 
-func (t *TestGroup) CompareStreams(r1 io.ReadCloser, r2 io.ReadCloser, length int64) Goroutine {
-        return t.Go("compare", func(g Goroutine) {
+func (t *TestGroup) CompareStreams(r1 io.ReadCloser, r2 io.ReadCloser, length int64) *Goroutine {
+        return t.Go("compare", func(g *Goroutine) {
                 b1 := make([]byte, blocksize)
                 b2 := make([]byte, blocksize)
                 var idx int64
@@ -103,11 +100,9 @@ func (t *TestGroup) CompareStreams(r1 io.ReadCloser, r2 io.ReadCloser, length in
                                 c = int(length)
                         }
                         if _, err := io.ReadFull(r1, b1[0:c]); err != nil {
-                                fmt.Println("ReadFull1", err)
                                 g.Panic(err)
                         }
                         if _, err := io.ReadFull(r2, b2[0:c]); err != nil {
-                                fmt.Println("ReadFull2", err)
                                 g.Panic(err)
                         }
                         if bytes.Compare(b1[0:c], b2[0:c]) != 0 {
@@ -166,9 +161,7 @@ func (r *Run) Wait() error {
 }
 
 func writeFifo(srcfile string, read io.Reader) error {
-        fmt.Println("About to open", srcfile)
         fifo, err := os.OpenFile(srcfile, os.O_WRONLY, 0600)
-        fmt.Println("Opened!!!", srcfile)
         if err != nil {
                 fifo.Close()
                 return err
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
 }
+