2 files changed, 69 insertions, 57 deletions

diff --git a/xdelta3/go/src/regtest.go b/xdelta3/go/src/regtest.go
index 1798f40..f8045c0 100644
--- a/xdelta3/go/src/regtest.go
+++ b/xdelta3/go/src/regtest.go
@@ -20,48 +20,51 @@ func smokeTest(r *xdelta.Runner, t *xdelta.TestGroup, p *xdelta.Program) {
         target := "Hello world!"
         source := "Hello world, nice to meet you!"
         
-        run, err := r.Exec(p, true, []string{"-e"})
+        run, err := r.Exec(p, true, []string{"-evv"})
         if err != nil {
                 t.Panic(err)
         }
-        encodeout := t.Drain(run.Stdout)
+        encodeout := t.Drain(run.Stdout, "encode.stdout")
         t.Empty(run.Stderr, "encode")
 
         t.Write("encode.stdin", run.Stdin, []byte(target))
-        t.Write("encode.stdout", run.Srcin, []byte(source))
+        t.Write("encode.srcin", run.Srcin, []byte(source))
 
         if err := run.Cmd.Wait(); err != nil {
                 t.Panic(err)
         }
 
-        run, err = r.Exec(p, true, []string{"-d"})
+        run, err = r.Exec(p, true, []string{"-dvv"})
         if err != nil {
                 t.Panic(err)
         }
 
-        decodeout := t.Drain(run.Stdout)
+        decodeout := t.Drain(run.Stdout, "decode.stdout")
         t.Empty(run.Stderr, "decode")
 
         t.Write("decode.stdin", run.Stdin, <-encodeout)
-        t.Write("decode.stdout", run.Srcin, []byte(source))
-
+        t.Write("decode.srcin", run.Srcin, []byte(source))
+        decoded := string(<-decodeout)
         if err := run.Cmd.Wait(); err != nil {
                 t.Panic(err)
         }
-
-        if string(<-decodeout) != target {
+        if decoded != target {
                 t.Panic(errors.New("It's not working!!!"))
         }
         t.Done()
+        fmt.Println("Smoketest pass")
 }
 
 func offsetTest(r *xdelta.Runner, t *xdelta.TestGroup, p *xdelta.Program, offset, bufsize, length int64) {
+        fmt.Println("Hi")
         t.Add(1)
         eargs := []string{"-e", "-1", "-n", fmt.Sprint("-B", bufsize), "-vv", fmt.Sprint("-W", winsize)}
         enc, err := r.Exec(p, true, eargs)
+        fmt.Println("Hi2")
         if err != nil {
                 t.Panic(err)
         }
+        fmt.Println("Hi3")
         dargs := []string{"-d", fmt.Sprint("-B", bufsize), "-vv", fmt.Sprint("-W", winsize)}
         dec, err := r.Exec(p, true, dargs)
         if err != nil {
@@ -70,12 +73,15 @@ func offsetTest(r *xdelta.Runner, t *xdelta.TestGroup, p *xdelta.Program, offset
 
         read, write := io.Pipe()
 
-        t.CopyStreams(enc.Stdout, dec.Stdin)
-        t.CompareStreams(dec.Stdout, read, length)
-
         t.Empty(enc.Stderr, "encode")
         t.Empty(dec.Stderr, "decode")
 
+        fmt.Println("Hi4")
+        t.CopyStreams(enc.Stdout, dec.Stdin)
+        fmt.Println("Hi5")
+        t.CompareStreams(dec.Stdout, read, length)
+        fmt.Println("Hi6")
+
         // TODO: seems possible to use one WriteRstreams call to generate
         // the source and target for both encoder and decoder.  Why not?
         xdelta.WriteRstreams(t, seed, offset, length, enc.Srcin, enc. Stdin)
@@ -101,7 +107,5 @@ func main() {
 
         smokeTest(r, xdelta.NewTestGroup(), prog)
 
-        offsetTest(r, xdelta.NewTestGroup(), prog, 1 << 8, 1 << 9, 1 << 10)
-
-        //offsetTest(r, prog, 1 << 31, 1 << 32, 1 << 33)
+        offsetTest(r, xdelta.NewTestGroup(), prog, 1 << 31, 1 << 32, 1 << 33)
 }
diff --git a/xdelta3/go/src/xdelta/test.go b/xdelta3/go/src/xdelta/test.go
index 50ddeae..9eb47f6 100644
--- a/xdelta3/go/src/xdelta/test.go
+++ b/xdelta3/go/src/xdelta/test.go
@@ -43,8 +43,8 @@ type Run struct {
 }
 
 func (t *TestGroup) Panic(err error) {
-        t.WaitGroup.Done()  // For the caller
-        t.WaitGroup.Wait()
+        t.Done()  // For the caller
+        t.Wait()
         panic(err)
 }
 
@@ -52,23 +52,25 @@ func NewTestGroup() *TestGroup {
         return &TestGroup{}
 }
 
-func (t *TestGroup) Drain(f io.ReadCloser) <-chan []byte {
+func (t *TestGroup) Drain(f io.ReadCloser, desc string) <-chan []byte {
         c := make(chan []byte)
         go func() {
-                t.WaitGroup.Add(1)
+                t.Add(1)
+                //fmt.Println("Draining", desc)
                 if b, err := ioutil.ReadAll(f); err != nil {
                         t.Panic(err)
                 } else {
+                        //fmt.Println("Draining", desc, "--got it")
                         c <- b
                 }
-                t.WaitGroup.Done()
+                t.Done()
         }()
         return c
 }
 
 func (t *TestGroup) Empty(f io.ReadCloser, desc string) {
         go func() {
-                t.WaitGroup.Add(1)
+                t.Add(1)
                 s := bufio.NewScanner(f)
                 for s.Scan() {
                         os.Stderr.Write([]byte(fmt.Sprint(desc, ": ", s.Text(), "\n")))
@@ -76,61 +78,67 @@ func (t *TestGroup) Empty(f io.ReadCloser, desc string) {
                 if err := s.Err(); err != nil {
                         t.Panic(err)
                 }
-                t.WaitGroup.Done()
+                t.Done()
         }()
 }
 
 func (t *TestGroup) Write(what string, f io.WriteCloser, b []byte) {
+        //fmt.Println("Write (", what, ") ", len(b), "bytes")
         if _, err := f.Write(b); err != nil {
                 t.Panic(errors.New(fmt.Sprint(what, ":", err)))
         }
+        //fmt.Println("Write (", what, ") closing")
         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)
+        go func() {
+                t.Add(1)
+                _, err := io.Copy(w, r)
+                if err != nil {
+                        t.Panic(err)
                 }
-                if _, err := io.ReadFull(r1, b1[0:c]); err != nil {
+                err = r.Close()
+                if err != nil {
                         t.Panic(err)
                 }
-                if _, err := io.ReadFull(r2, b2[0:c]); err != nil {
+                err = w.Close()
+                if 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)))
+                t.Done()
+        }()
+}
+
+func (t *TestGroup) CompareStreams(r1 io.ReadCloser, r2 io.ReadCloser, length int64) {
+        go func() {
+                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)
                 }
-                length -= int64(c)
-                idx += int64(c)
-        }
-        t.Done()
+                t.Done()
+        }()
 }
 
 func NewRunner() (*Runner, error) {