3 files changed, 155 insertions, 48 deletions

diff --git a/xdelta3/go/src/regtest.go b/xdelta3/go/src/regtest.go
index d762235..233e005 100644
--- a/xdelta3/go/src/regtest.go
+++ b/xdelta3/go/src/regtest.go
@@ -1,72 +1,158 @@
 package main
 
 import (
-        "errors"
         "fmt"
         "io"
+        "os"
 
         "xdelta"
 )
 
 const (
-        blocksize = 1<<16
-        winsize = 1<<22
+        xdataset = "/Users/jmacd/src/testdata"
+        xcompare = "/Users/jmacd/src/xdelta3-3.0.10/xdelta3"
         xdelta3 = "/Users/jmacd/src/xdelta-devel/xdelta3/xdelta3"
         seed = 1422253499919909358
 )
 
-func smokeTest(t *xdelta.TestGroup, p *xdelta.Program) {
-        g := t.Main()
+type Config struct {
+        srcbuf_size int64
+        window_size int64
+        blocksize   int
+}
+
+func NewC() Config {
+        // TODO make these (and above) flags
+        return Config{1<<26, 1<<22, 1<<16}
+}
+
+func (c Config) smokeTest(t *xdelta.TestGroup, p xdelta.Program) {
         target := "Hello world!"
         source := "Hello world, nice to meet you!"
 
-        enc, err := t.Exec("encode", p, true, []string{"-evv"})
+        enc, err := t.Exec("encode", p, true, []string{"-e"})
+        if err != nil {
+                t.Panic(err)
+        }
+        dec, err := t.Exec("decode", p, true, []string{"-d"})
         if err != nil {
-                g.Panic(err)
+                t.Panic(err)
         }
+
         encodeout := t.Drain(enc.Stdout, "encode.stdout")
+        decodeout := t.Drain(dec.Stdout, "decode.stdout")
+
         t.Empty(enc.Stderr, "encode")
+        t.Empty(dec.Stderr, "decode")
 
-        if err := xdelta.TestWrite("encode.stdin", enc.Stdin, []byte(target)); err != nil {
-                g.Panic(err)
-        }
-        if err := xdelta.TestWrite("encode.srcin", enc.Srcin, []byte(source)); err != nil {
-                g.Panic(err)
+        t.TestWrite("encode.stdin", enc.Stdin, []byte(target))
+        t.TestWrite("encode.srcin", enc.Srcin, []byte(source))
+
+        t.TestWrite("decode.stdin", dec.Stdin, <-encodeout)
+        t.TestWrite("decode.srcin", dec.Srcin, []byte(source))
+
+        if do := string(<-decodeout); do != target {
+                t.Panic(fmt.Errorf("It's not working! %s\n!=\n%s\n", do, target))
         }
+        t.Wait(enc, dec)
+}
+
+type PairTest struct {
+        // Input
+        Config
+        program xdelta.Program
+        source, target string
 
-        dec, err := t.Exec("decode", p, true, []string{"-dvv"})
+        // Output
+        encoded int64
+}
+
+// P is the test program, Q is the reference version.
+func (cfg Config) datasetTest(t *xdelta.TestGroup, p, q xdelta.Program) {
+        dir, err := os.Open(xdataset)
+        if err != nil {
+                t.Panic(err)
+        }
+        dents, err := dir.Readdir(-1)
         if err != nil {
-                g.Panic(err)
+                t.Panic(err)
         }
+        paths := make([]string, len(dents))
+        var total int64
+        for i, d := range dents {
+                if !d.Mode().IsRegular() {
+                        continue
+                }
+                paths[i] = fmt.Sprint(xdataset, "/", d.Name())
+                total += d.Size()
+        }
+        meansize := total / int64(len(dents))
+        for _, in1 := range paths {
+                for _, in2 := range paths {
+                        if in1 == in2 { continue }
+
+                        largest := uint(20)
+                        for ; largest <= 31 && 1<<largest < meansize; largest++ {}
+
+                        // 1/8, 1/4, 1/2, and 1/1 of the power-of-2 rounded-up mean size
+                        for b := largest /* - 3*/; b <= largest; b++ {
+                                c1 := cfg
+                                c1.srcbuf_size = 1<<b
+                                ptest := &PairTest{c1, p, in1, in2, -1}
+                                ptest.datasetPairTest(t, 1<<b);
+                                qtest := &PairTest{c1, q, in1, in2, -1}
+                                qtest.datasetPairTest(t, 1<<b)
+                        }
+                }
+        }
+}
 
-        decodeout := t.Drain(dec.Stdout, "decode.stdout")
-        t.Empty(dec.Stderr, "decode")
+func (pt *PairTest) datasetPairTest(t *xdelta.TestGroup, meanSize int64) {
+        cfg := pt.Config
+        eargs := []string{"-e", fmt.Sprint("-B", cfg.srcbuf_size), "-q",
+                fmt.Sprint("-W", cfg.window_size), "-s", pt.source, pt.target}
+        enc, err := t.Exec("encode", pt.program, false, eargs)
+        if err != nil {
+                t.Panic(err)
+        }
 
-        if err := xdelta.TestWrite("decode.stdin", dec.Stdin, <-encodeout); err != nil {
-                g.Panic(err)
+        dargs := []string{"-dc", fmt.Sprint("-B", cfg.srcbuf_size), "-q",
+                fmt.Sprint("-W", cfg.window_size), "-s", pt.source}
+        dec, err := t.Exec("decode", pt.program, false, dargs)
+        if err != nil {
+                t.Panic(err)
         }
-        if err := xdelta.TestWrite("decode.srcin", dec.Srcin, []byte(source)); err != nil {
-                g.Panic(err)
+        tgt_check, err := os.Open(pt.target)
+        if err != nil {
+                t.Panic(err)
         }
-        decoded := string(<-decodeout)
-        if decoded != target {
-                g.Panic(errors.New("It's not working!!!"))
+        tgt_info, err := tgt_check.Stat()
+        if err != nil {
+                t.Panic(err)
         }
-        t.Wait(g, enc, dec)
+        t.Empty(enc.Stderr, "encode")
+        t.Empty(dec.Stderr, "decode")
+        t.CopyStreams(enc.Stdout, dec.Stdin, &pt.encoded)
+        t.CompareStreams(dec.Stdout, tgt_check, tgt_info.Size())
+
+        t.Wait(enc, dec)
+
+        fmt.Println("PairTest", pt, "success")
 }
 
-func offsetTest(t *xdelta.TestGroup, p *xdelta.Program, offset, bufsize, length int64) {
-        g := t.Main()
-        eargs := []string{"-e", "-0", fmt.Sprint("-B", bufsize), "-q", fmt.Sprint("-W", winsize)}
+func (cfg Config) offsetTest(t *xdelta.TestGroup, p xdelta.Program, offset, length int64) {
+        eargs := []string{"-e", "-0", fmt.Sprint("-B", cfg.srcbuf_size), "-q",
+                fmt.Sprint("-W", cfg.window_size)}
         enc, err := t.Exec("encode", p, true, eargs)
         if err != nil {
-                g.Panic(err)
+                t.Panic(err)
         }
         
-        dargs := []string{"-d", fmt.Sprint("-B", bufsize), "-q", fmt.Sprint("-W", winsize)}
+        dargs := []string{"-d", fmt.Sprint("-B", cfg.srcbuf_size), "-q",
+                fmt.Sprint("-W", cfg.window_size)}
         dec, err := t.Exec("decode", p, true, dargs)
         if err != nil {
-                g.Panic(err)
+                t.Panic(err)
         }
 
         // The pipe used to read the decoder output and compare
@@ -85,9 +171,9 @@ func offsetTest(t *xdelta.TestGroup, p *xdelta.Program, offset, bufsize, length
         // generates the input and output twice.
         t.WriteRstreams("encode", seed, offset, length, enc.Srcin, enc.Stdin)
         t.WriteRstreams("decode", seed, offset, length, dec.Srcin, write)
-        t.Wait(g, enc, dec)
+        t.Wait(enc, dec)
 
-        expect := bufsize - offset
+        expect := cfg.srcbuf_size - offset
         if float64(encoded_size) < (0.95 * float64(expect)) ||
                 float64(encoded_size) > (1.05 * float64(expect)) {
                 t.Fail("encoded size should be ~=", expect, ", actual ", encoded_size)
@@ -101,12 +187,25 @@ func main() {
         }
         defer r.Cleanup()
 
-        prog := &xdelta.Program{xdelta3}
+        cfg := NewC()
 
-        r.RunTest("smoketest", func(tg *xdelta.TestGroup) { smokeTest(tg, prog) })
+        prog := xdelta.Program{xdelta3}
 
-        for i := uint(20); i <= 30; i += 1 {
+        r.RunTest("smoketest", func(t *xdelta.TestGroup) { cfg.smokeTest(t, prog) })
+
+        comp := xdelta.Program{xcompare}
+
+        r.RunTest("dataset", func(t *xdelta.TestGroup) { cfg.datasetTest(t, prog, comp) })
+
+        for i := uint(19); i <= 30; i += 1 {
+                // The arguments to offsetTest are offset, source
+                // window size, and file size. The source window size
+                // is (2 << i) and (in the 3.0x release branch) is
+                // limited to 2^31, so the the greatest value of i is
+                // 30.
+                cfg.srcbuf_size = 2 << i
                 r.RunTest(fmt.Sprint("offset", i), func(t *xdelta.TestGroup) {
-                        offsetTest(t, prog, 1 << i, 2 << i, 3 << i) })
+                        cfg.offsetTest(t, prog, 1 << i, 3 << i) })
         }
+        
 }
diff --git a/xdelta3/go/src/xdelta/test.go b/xdelta3/go/src/xdelta/test.go
index bab66f3..7210698 100644
--- a/xdelta3/go/src/xdelta/test.go
+++ b/xdelta3/go/src/xdelta/test.go
@@ -47,14 +47,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 {
-                return errors.New(fmt.Sprint(what, ":", err))
-        }
-        if err := f.Close(); err != nil {
-                return errors.New(fmt.Sprint(what, ":", err))
-        }
-        return nil
+func (t *TestGroup) TestWrite(what string, f io.WriteCloser, b []byte) *Goroutine {
+        return t.Go("write", func(g *Goroutine) {
+                if _, err := f.Write(b); err != nil {
+                        g.Panic(err)
+                }
+                if err := f.Close(); err != nil {
+                        g.Panic(err)
+                }
+                g.OK()
+        })
 }
 
 func (t *TestGroup) CopyStreams(r io.ReadCloser, w io.WriteCloser, written *int64) *Goroutine {
@@ -104,7 +106,7 @@ func (t *TestGroup) CompareStreams(r1 io.ReadCloser, r2 io.ReadCloser, length in
         })
 }
 
-func (t *TestGroup) Exec(desc string, p *Program, srcfifo bool, flags []string) (*Run, error) {
+func (t *TestGroup) Exec(desc string, p Program, srcfifo bool, flags []string) (*Run, error) {
         var err error
         run := &Run{}
         args := []string{p.Path}
@@ -133,7 +135,6 @@ func (t *TestGroup) Exec(desc string, p *Program, srcfifo bool, flags []string)
         run.Cmd.Path = p.Path
         run.Cmd.Args = append(args, flags...)
         run.Cmd.Dir = t.Runner.Testdir
-        fmt.Println("Start command", run.Cmd.Args)
         if serr := run.Cmd.Start(); serr != nil {
                 return nil, serr
         }
diff --git a/xdelta3/go/src/xdelta/tgroup.go b/xdelta3/go/src/xdelta/tgroup.go
index 0a3b41b..b1b04ec 100644
--- a/xdelta3/go/src/xdelta/tgroup.go
+++ b/xdelta3/go/src/xdelta/tgroup.go
@@ -29,6 +29,11 @@ func (g *Goroutine) String() string {
 func (g *Goroutine) finish(err error) {
         wait := false
         tg := g.TestGroup
+        sbuf := make([]byte, 4096)
+        sbuf = sbuf[0:runtime.Stack(sbuf, false)]
+        if err != nil {
+                err = fmt.Errorf("%v:%v:%v", g.name, err, string(sbuf))
+        }
         tg.Lock()
         if g.done {
                 if err != nil {
@@ -58,6 +63,8 @@ func (g *Goroutine) Panic(err error) {
 
 func (t *TestGroup) Main() *Goroutine { return t.main }
 
+func (t *TestGroup) Panic(err error) { t.Main().Panic(err) }
+
 func (t *TestGroup) Go(name string, f func(*Goroutine)) *Goroutine {
         g := &Goroutine{t, name, false}
         t.Lock()
@@ -68,8 +75,8 @@ func (t *TestGroup) Go(name string, f func(*Goroutine)) *Goroutine {
         return g
 }
 
-func (t *TestGroup) Wait(self *Goroutine, procs... *Run) {
-        self.OK()
+func (t *TestGroup) Wait(procs... *Run) {
+        t.Main().OK()
         t.WaitGroup.Wait()
         for _, p := range procs {
                 if err := p.Wait(); err != nil {