3 files changed, 146 insertions, 113 deletions

diff --git a/xdelta3/go/src/regtest.go b/xdelta3/go/src/regtest.go
index 52547e1..1798f40 100644
--- a/xdelta3/go/src/regtest.go
+++ b/xdelta3/go/src/regtest.go
@@ -1,12 +1,9 @@
 package main
 
 import (
-        "bufio"
-        "bytes"
+        "errors"
         "fmt"
         "io"
-        "io/ioutil"
-        "os"
 
         "xdelta"
 )
@@ -14,150 +11,83 @@ import (
 const (
         blocksize = 1<<16
         winsize = 1<<26
-        prog = "/Users/jmacd/src/xdelta/xdelta3/build/m64/64size-64off/xdelta3"
+        xdelta3 = "/volume/home/jmacd/src/xdelta-64bithash/xdelta3/build/x86_64-pc-linux-gnu-m64/usize64/xoff64/xdelta3"
         seed = 1422253499919909358
 )
 
-func drain(f io.ReadCloser) <-chan []byte {
-        c := make(chan []byte)
-        go func() {
-                if b, err := ioutil.ReadAll(f); err != nil {
-                        panic(err)
-                } else {
-                        c <- b
-                }
-        }()
-        return c
-}
-
-func empty(f io.ReadCloser, desc string) {
-        go func() {
-                s := bufio.NewScanner(f)
-                for s.Scan() {
-                        os.Stderr.Write([]byte(fmt.Sprint(desc, ": ", s.Text(), "\n")))
-                }
-                if err := s.Err(); err != nil {
-                        fmt.Println("error reading input:", err)
-                }
-        }()
-}
-
-func write(f io.WriteCloser, b []byte) {
-        if _, err := f.Write(b); err != nil {
-                panic(err)
-        }
-        if err := f.Close(); err != nil {
-                panic(err)
-        }
-}
-
-func smokeTest(r *xdelta.Runner, p *xdelta.Program) {
+func smokeTest(r *xdelta.Runner, t *xdelta.TestGroup, p *xdelta.Program) {
+        t.Add(1)
         target := "Hello world!"
         source := "Hello world, nice to meet you!"
         
         run, err := r.Exec(p, true, []string{"-e"})
         if err != nil {
-                panic(err)
+                t.Panic(err)
         }
-        encodeout := drain(run.Stdout)
-        empty(run.Stderr, "encode")
+        encodeout := t.Drain(run.Stdout)
+        t.Empty(run.Stderr, "encode")
 
-        write(run.Stdin, []byte(target))
-        write(run.Srcin, []byte(source))
+        t.Write("encode.stdin", run.Stdin, []byte(target))
+        t.Write("encode.stdout", run.Srcin, []byte(source))
 
         if err := run.Cmd.Wait(); err != nil {
-                panic(err)
+                t.Panic(err)
         }
 
         run, err = r.Exec(p, true, []string{"-d"})
         if err != nil {
-                panic(err)
+                t.Panic(err)
         }
 
-        decodeout := drain(run.Stdout)
-        empty(run.Stderr, "decode")
+        decodeout := t.Drain(run.Stdout)
+        t.Empty(run.Stderr, "decode")
 
-        write(run.Stdin, <-encodeout)
-        write(run.Srcin, []byte(source))
+        t.Write("decode.stdin", run.Stdin, <-encodeout)
+        t.Write("decode.stdout", run.Srcin, []byte(source))
 
         if err := run.Cmd.Wait(); err != nil {
-                panic(err)
+                t.Panic(err)
         }
 
         if string(<-decodeout) != target {
-                panic("It's not working!!!")
+                t.Panic(errors.New("It's not working!!!"))
         }
+        t.Done()
 }
 
-func copyStreams(r io.ReadCloser, w io.WriteCloser) {
-        _, err := io.Copy(w, r)
+func offsetTest(r *xdelta.Runner, t *xdelta.TestGroup, p *xdelta.Program, offset, bufsize, length int64) {
+        t.Add(1)
+        eargs := []string{"-e", "-1", "-n", fmt.Sprint("-B", bufsize), "-vv", fmt.Sprint("-W", winsize)}
+        enc, err := r.Exec(p, true, eargs)
         if err != nil {
-                panic(err)
+                t.Panic(err)
         }
-        err = r.Close()
+        dargs := []string{"-d", fmt.Sprint("-B", bufsize), "-vv", fmt.Sprint("-W", winsize)}
+        dec, err := r.Exec(p, true, dargs)
         if err != nil {
-                panic(err)
-        }
-        err = w.Close()
-        if err != nil {
-                panic(err)
-        }
-}
-
-func compareStreams(r1 io.ReadCloser, r2 io.ReadCloser, length int64) {
-        b1 := make([]byte, blocksize)
-        b2 := make([]byte, blocksize)
-        var idx int64
-        for length > 0 {
-                c := blocksize
-                if length < blocksize {
-                        c = int(length)
-                }
-                if _, err := io.ReadFull(r1, b1[0:c]); err != nil {
-                        panic(err)
-                }
-                if _, err := io.ReadFull(r2, b2[0:c]); err != nil {
-                        panic(err)
-                }
-                if bytes.Compare(b1[0:c], b2[0:c]) != 0 {
-                        fmt.Println("B1 is", string(b1[0:c]))
-                        fmt.Println("B2 is", string(b2[0:c]))                   
-                        panic(fmt.Sprint("Bytes do not compare at ", idx))
-                }
-                length -= int64(c)
-                idx += int64(c)
-        }
-}
-
-func offsetTest(r *xdelta.Runner, p *xdelta.Program, offset, bufsize, length int64) {
-        enc, err := r.Exec(p, true, []string{"-e", "-1", "-n", fmt.Sprint("-B", bufsize), "-vv", fmt.Sprint("-W", winsize)})
-        if err != nil {
-                panic(err)
-        }
-        dec, err := r.Exec(p, true, []string{"-d", fmt.Sprint("-B", bufsize), "-vv", fmt.Sprint("-W", winsize)})
-        if err != nil {
-                panic(err)
+                t.Panic(err)
         }
 
         read, write := io.Pipe()
 
-        go copyStreams(enc.Stdout, dec.Stdin)
-        go compareStreams(dec.Stdout, read, length)
+        t.CopyStreams(enc.Stdout, dec.Stdin)
+        t.CompareStreams(dec.Stdout, read, length)
 
-        empty(enc.Stderr, "encode")
-        empty(dec.Stderr, "decode")
+        t.Empty(enc.Stderr, "encode")
+        t.Empty(dec.Stderr, "decode")
 
         // TODO: seems possible to use one WriteRstreams call to generate
         // the source and target for both encoder and decoder.  Why not?
-        xdelta.WriteRstreams(seed, offset, length, enc.Srcin, enc.Stdin)
-        xdelta.WriteRstreams(seed, offset, length, dec.Srcin, write)
+        xdelta.WriteRstreams(t, seed, offset, length, enc.Srcin, enc. Stdin)
+        xdelta.WriteRstreams(t, seed, offset, length, dec.Srcin, write)
 
         if err := enc.Cmd.Wait(); err != nil {
-                panic(err)
+                t.Panic(err)
         }
         if err := dec.Cmd.Wait(); err != nil {
-                panic(err)
+                t.Panic(err)
         }
+        t.Done()
 }
 
 func main() {
@@ -167,9 +97,11 @@ func main() {
         }
         defer r.Cleanup()
 
-        prog := &xdelta.Program{prog}
+        prog := &xdelta.Program{xdelta3}
+
+        smokeTest(r, xdelta.NewTestGroup(), prog)
 
-        smokeTest(r, prog)
+        offsetTest(r, xdelta.NewTestGroup(), prog, 1 << 8, 1 << 9, 1 << 10)
 
-        offsetTest(r, prog, 1 << 31, 1 << 32, 1 << 33)
+        //offsetTest(r, prog, 1 << 31, 1 << 32, 1 << 33)
 }
diff --git a/xdelta3/go/src/xdelta/rstream.go b/xdelta3/go/src/xdelta/rstream.go
index 1d56031..3e7265f 100644
--- a/xdelta3/go/src/xdelta/rstream.go
+++ b/xdelta3/go/src/xdelta/rstream.go
@@ -7,16 +7,17 @@ import (
 )
 
 const (
-        blocksize = 16380  // A factor of 7
+        blocksize = 16380
 )
 
-func WriteRstreams(seed, offset, len int64,
+func WriteRstreams(t *TestGroup, seed, offset, len int64,
         first, second io.WriteCloser) {
-        go writeOne(seed, 0, len, first)
-        go writeOne(seed, offset, len, second)
+        go writeOne(t, seed, 0, len, first)
+        go writeOne(t, seed, offset, len, second)
 }
 
-func writeOne(seed, offset, len int64, stream io.WriteCloser) error {
+func writeOne(t *TestGroup, seed, offset, len int64, stream io.WriteCloser) error {
+        t.WaitGroup.Add(1)
         if offset != 0 {
                 // Fill with other random data until the offset
                 if err := writeRand(rand.New(rand.NewSource(^seed)), offset, stream); err != nil {
@@ -27,6 +28,7 @@ func writeOne(seed, offset, len int64, stream io.WriteCloser) error {
                 len - offset, stream); err != nil {
                 return err
         }
+        t.WaitGroup.Done()
         return stream.Close()
 }
 
diff --git a/xdelta3/go/src/xdelta/test.go b/xdelta3/go/src/xdelta/test.go
index 3143dfa..50ddeae 100644
--- a/xdelta3/go/src/xdelta/test.go
+++ b/xdelta3/go/src/xdelta/test.go
@@ -1,6 +1,9 @@
 package xdelta
 
 import (
+        "bufio"
+        "bytes"
+        "errors"
         "fmt"
         "io"
         "io/ioutil"
@@ -8,6 +11,7 @@ import (
         "os/exec"
         "path"
         "sync/atomic"
+        "sync"
 
         "golang.org/x/sys/unix"
 )
@@ -25,6 +29,10 @@ type Runner struct {
         Testdir string
 }
 
+type TestGroup struct {
+        sync.WaitGroup
+}
+
 type Run struct {
         Cmd exec.Cmd
         Srcfile string
@@ -34,6 +42,97 @@ type Run struct {
         Stderr io.ReadCloser
 }
 
+func (t *TestGroup) Panic(err error) {
+        t.WaitGroup.Done()  // For the caller
+        t.WaitGroup.Wait()
+        panic(err)
+}
+
+func NewTestGroup() *TestGroup {
+        return &TestGroup{}
+}
+
+func (t *TestGroup) Drain(f io.ReadCloser) <-chan []byte {
+        c := make(chan []byte)
+        go func() {
+                t.WaitGroup.Add(1)
+                if b, err := ioutil.ReadAll(f); err != nil {
+                        t.Panic(err)
+                } else {
+                        c <- b
+                }
+                t.WaitGroup.Done()
+        }()
+        return c
+}
+
+func (t *TestGroup) Empty(f io.ReadCloser, desc string) {
+        go func() {
+                t.WaitGroup.Add(1)
+                s := bufio.NewScanner(f)
+                for s.Scan() {
+                        os.Stderr.Write([]byte(fmt.Sprint(desc, ": ", s.Text(), "\n")))
+                }
+                if err := s.Err(); err != nil {
+                        t.Panic(err)
+                }
+                t.WaitGroup.Done()
+        }()
+}
+
+func (t *TestGroup) Write(what string, f io.WriteCloser, b []byte) {
+        if _, err := f.Write(b); err != nil {
+                t.Panic(errors.New(fmt.Sprint(what, ":", err)))
+        }
+        if err := f.Close(); err != nil {
+                t.Panic(errors.New(fmt.Sprint(what, ":", err)))
+        }
+}
+
+func (t *TestGroup) CopyStreams(r io.ReadCloser, w io.WriteCloser) {
+        t.Add(1)
+        _, err := io.Copy(w, r)
+        if err != nil {
+                t.Panic(err)
+        }
+        err = r.Close()
+        if err != nil {
+                t.Panic(err)
+        }
+        err = w.Close()
+        if err != nil {
+                t.Panic(err)
+        }
+        t.Done()
+}
+
+func (t *TestGroup) CompareStreams(r1 io.ReadCloser, r2 io.ReadCloser, length int64) {
+        t.Add(1)
+        b1 := make([]byte, blocksize)
+        b2 := make([]byte, blocksize)
+        var idx int64
+        for length > 0 {
+                c := blocksize
+                if length < blocksize {
+                        c = int(length)
+                }
+                if _, err := io.ReadFull(r1, b1[0:c]); err != nil {
+                        t.Panic(err)
+                }
+                if _, err := io.ReadFull(r2, b2[0:c]); err != nil {
+                        t.Panic(err)
+                }
+                if bytes.Compare(b1[0:c], b2[0:c]) != 0 {
+                        fmt.Println("B1 is", string(b1[0:c]))
+                        fmt.Println("B2 is", string(b2[0:c]))                   
+                        t.Panic(errors.New(fmt.Sprint("Bytes do not compare at ", idx)))
+                }
+                length -= int64(c)
+                idx += int64(c)
+        }
+        t.Done()
+}
+
 func NewRunner() (*Runner, error) {
         if dir, err := ioutil.TempDir(tmpDir, "xrt"); err != nil {
                 return nil, err