Regtest work

3 files changed, 64 insertions, 12 deletions

diff --git a/xdelta3/go/src/regtest.go b/xdelta3/go/src/regtest.go
index 76d253c..4507b8c 100644
--- a/xdelta3/go/src/regtest.go
+++ b/xdelta3/go/src/regtest.go
@@ -78,8 +78,11 @@ func offsetTest(r *xdelta.Runner, p *xdelta.Program, bufsize, offset, length int
         t.CopyStreams(enc.Stdout, dec.Stdin)
         t.CompareStreams(dec.Stdout, read, length)
 
-        xdelta.WriteRstreams(t, "encode", seed, offset, length, enc.Srcin, enc.Stdin)
-        xdelta.WriteRstreams(t, "decode", seed, offset, length, dec.Srcin, write)
+        // The decoder output ("read", above) is compared with the
+        // test-provided output ("write", below).
+        xdelta.WriteRstreams(t, seed, offset, length,
+                t.NewDualWriter(enc.Srcin, dec.Srcin),
+                t.NewDualWriter(dec.Srcin, write))
         t.Wait(g, enc, dec)
 }
 
@@ -92,10 +95,8 @@ func main() {
 
         prog := &xdelta.Program{xdelta3}
 
-        smokeTest(r, prog)
-        for {
-                offsetTest(r, prog, 4 << 20, 3 << 20, 5 << 20)
-        }
+        //smokeTest(r, prog)
+        offsetTest(r, prog, 4 << 20, 3 << 20, 5 << 20)
 
         //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 67d23e6..eafcfeb 100644
--- a/xdelta3/go/src/xdelta/rstream.go
+++ b/xdelta3/go/src/xdelta/rstream.go
@@ -7,15 +7,15 @@ import (
 )
 
 const (
-        blocksize = 16380
+        blocksize = 1<<20
 )
 
-func WriteRstreams(t *TestGroup, desc string, seed, offset, len int64,
+func WriteRstreams(t *TestGroup, seed, offset, len int64,
         src, tgt io.WriteCloser) {
-        t.Go("src-write:"+desc, func (g Goroutine) {
+        t.Go("src-write", func (g Goroutine) {
                 writeOne(g, seed, 0, len, src, false)
         })
-        t.Go("tgt-write:"+desc, func (g Goroutine) {
+        t.Go("tgt-write", func (g Goroutine) {
                 writeOne(g, seed, offset, len, tgt, true)
         })
 }
@@ -60,9 +60,9 @@ func writeRand(r *rand.Rand, len int64, s io.Writer) error {
 }
 
 func fillRand(r *rand.Rand, blk []byte) {
-        for p := 0; p < blocksize; {
+        for p := 0; p < len(blk); {
                 v := r.Int63()
-                for i := 7; i != 0; i-- {
+                for i := 7; i != 0 && p < len(blk); i-- {
                         blk[p] = byte(v)
                         p++
                         v >>= 8
diff --git a/xdelta3/go/src/xdelta/tgroup.go b/xdelta3/go/src/xdelta/tgroup.go
index c7337c6..1852bac 100644
--- a/xdelta3/go/src/xdelta/tgroup.go
+++ b/xdelta3/go/src/xdelta/tgroup.go
@@ -2,6 +2,7 @@ package xdelta
 
 import (
         "fmt"
+        "io"
         "sync"
         "time"
 )
@@ -109,3 +110,53 @@ func waitAll(t *TestGroup, wc chan bool) {
         }
         wc <- true
 }
+
+type dualWriter struct {
+        e, d chan []byte
+}
+
+func (d *dualWriter) Write(p []byte) (int, error) {
+        if len(p) != 0 {
+                d.e <- p
+                d.d <- p
+        }
+        return len(p), nil
+}
+
+func (d *dualWriter) Close() error {
+        d.e <- nil
+        d.d <- nil
+        _ = <- d.e
+        _ = <- d.d
+        return nil
+}
+
+func newWriter(c chan []byte, a io.WriteCloser) func (Goroutine) {
+        return func (g Goroutine) {
+                for {
+                        d := <- c
+                        if d == nil {
+                                if err := a.Close(); err != nil {
+                                        g.Panic(err)
+                                }
+                                c <- nil
+                                g.OK()
+                                return
+                        }
+                        if num, err := a.Write(d); err != nil {
+                                g.Panic(err)
+                        } else if num != len(d) {
+                                g.Panic(fmt.Errorf("Invalid write: %v != %v", num, len(d)))
+                        }
+                }
+        }
+}
+
+func (t *TestGroup) NewDualWriter(a1, a2 io.WriteCloser) io.WriteCloser {
+        c1 := make(chan []byte)
+        c2 := make(chan []byte)
+        r := &dualWriter{c1, c2}
+        t.Go("writer0", newWriter(c1, a1))
+        t.Go("writer1", newWriter(c2, a2))
+        return r
+}