Run offset tests up to the 31bit source window (see

5 files changed, 100 insertions, 68 deletions

diff --git a/xdelta3/go/src/regtest.go b/xdelta3/go/src/regtest.go
index adb4ae4..d762235 100644
--- a/xdelta3/go/src/regtest.go
+++ b/xdelta3/go/src/regtest.go
@@ -15,8 +15,8 @@ const (
         seed = 1422253499919909358
 )
 
-func smokeTest(r *xdelta.Runner, p *xdelta.Program) {
-        t, g := xdelta.NewTestGroup(r)
+func smokeTest(t *xdelta.TestGroup, p *xdelta.Program) {
+        g := t.Main()
         target := "Hello world!"
         source := "Hello world, nice to meet you!"
 
@@ -55,32 +55,29 @@ func smokeTest(r *xdelta.Runner, p *xdelta.Program) {
         t.Wait(g, enc, dec)
 }
 
-func offsetTest(r *xdelta.Runner, p *xdelta.Program, bufsize, offset, length int64) {
-        // Note there is a strong potential to deadlock or fail due to
-        // a broken test in this test for several reasons:
-        // (a) decoder is not required to read the entire source file
-        // (b) decoder defers open to source file until first window received
-        // (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), "-vv", fmt.Sprint("-W", winsize)}
+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)}
         enc, err := t.Exec("encode", p, true, eargs)
         if err != nil {
                 g.Panic(err)
         }
         
-        dargs := []string{"-d", fmt.Sprint("-B", bufsize), "-vv", fmt.Sprint("-W", winsize)}
+        dargs := []string{"-d", fmt.Sprint("-B", bufsize), "-q", fmt.Sprint("-W", winsize)}
         dec, err := t.Exec("decode", p, true, dargs)
         if err != nil {
                 g.Panic(err)
         }
 
+        // The pipe used to read the decoder output and compare
+        // against the target.
         read, write := io.Pipe()
 
         t.Empty(enc.Stderr, "encode")
         t.Empty(dec.Stderr, "decode")
 
-        t.CopyStreams(enc.Stdout, dec.Stdin)
+        var encoded_size int64
+        t.CopyStreams(enc.Stdout, dec.Stdin, &encoded_size)
         t.CompareStreams(dec.Stdout, read, length)
 
         // The decoder output ("read", above) is compared with the
@@ -89,6 +86,12 @@ func offsetTest(r *xdelta.Runner, p *xdelta.Program, bufsize, offset, length int
         t.WriteRstreams("encode", seed, offset, length, enc.Srcin, enc.Stdin)
         t.WriteRstreams("decode", seed, offset, length, dec.Srcin, write)
         t.Wait(g, enc, dec)
+
+        expect := bufsize - 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)
+        }
 }
 
 func main() {
@@ -100,11 +103,10 @@ func main() {
 
         prog := &xdelta.Program{xdelta3}
 
-        smokeTest(r, prog)
-        fmt.Println("Smoke-test pass")
+        r.RunTest("smoketest", func(tg *xdelta.TestGroup) { smokeTest(tg, prog) })
 
-        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)
+        for i := uint(20); i <= 30; i += 1 {
+                r.RunTest(fmt.Sprint("offset", i), func(t *xdelta.TestGroup) {
+                        offsetTest(t, prog, 1 << i, 2 << i, 3 << i) })
+        }
 }
diff --git a/xdelta3/go/src/xdelta/rstream.go b/xdelta3/go/src/xdelta/rstream.go
index 9481f22..99c3d17 100644
--- a/xdelta3/go/src/xdelta/rstream.go
+++ b/xdelta3/go/src/xdelta/rstream.go
@@ -3,7 +3,6 @@ package xdelta
 
 import (
         "io"
-        "fmt"
         "math/rand"
 )
 
@@ -14,10 +13,10 @@ const (
 func (t *TestGroup) WriteRstreams(desc string, seed, offset, len int64,
         src, tgt io.WriteCloser) {
         t.Go("src-write:"+desc, func (g *Goroutine) {
-                writeOne(g, seed, 0, len, src, false)
+                writeOne(g, seed, 0, len, tgt, false)
         })
         t.Go("tgt-write:"+desc, func (g *Goroutine) {
-                writeOne(g, seed, offset, len, tgt, true)
+                writeOne(g, seed, offset, len, src, true)
         })
 }
 
@@ -30,12 +29,10 @@ func writeOne(g *Goroutine, seed, offset, len int64, stream io.WriteCloser, read
         }
         if offset != 0 {
                 // Fill with other random data until the offset
-                fmt.Println(g, "pre-offset case", offset)
                 if err := writeRand(g, rand.New(rand.NewSource(^seed)), offset, stream); err != nil {
                         g.Panic(err)
                 }
         }
-        fmt.Println(g, "offset case", len - offset)
         if err := writeRand(g, rand.New(rand.NewSource(seed)),
                 len - offset, stream); err != nil {
                 g.Panic(err)
diff --git a/xdelta3/go/src/xdelta/run.go b/xdelta3/go/src/xdelta/run.go
index f9b4185..3b07178 100644
--- a/xdelta3/go/src/xdelta/run.go
+++ b/xdelta3/go/src/xdelta/run.go
@@ -1,14 +1,34 @@
 package xdelta
 
 import (
+        "fmt"
+        "io"
         "io/ioutil"
         "os"
+        "os/exec"
 )
 
+type Program struct {
+        Path string
+}
+
+type Run struct {
+        Cmd exec.Cmd
+        Srcfile string
+        Stdin io.WriteCloser
+        Srcin io.WriteCloser
+        Stdout io.ReadCloser
+        Stderr io.ReadCloser
+}
+
 type Runner struct {
         Testdir string
 }
 
+func (r *Run) Wait() error {
+        return r.Cmd.Wait()
+}
+
 func NewRunner() (*Runner, error) {
         if dir, err := ioutil.TempDir(tmpDir, "xrt"); err != nil {
                 return nil, err
@@ -17,6 +37,35 @@ func NewRunner() (*Runner, error) {
         }
 }
 
+func (r *Runner) newTestGroup(name string) (*TestGroup) {
+        tg := &TestGroup{Runner: r}
+        tg.WaitGroup.Add(1)
+        g0 := &Goroutine{tg, name, false}
+        tg.running = append(tg.running, g0)
+        tg.main = g0
+        return tg
+}
+
 func (r *Runner) Cleanup() {
         os.RemoveAll(r.Testdir)
 }
+
+func (r *Runner) RunTest(name string, f func (t *TestGroup)) {
+        t := r.newTestGroup(name)
+        var rec interface{}
+        defer func() {
+                if r := recover(); r != nil {
+                        fmt.Println("PANIC in ", name, ": ", r)
+                        rec = r
+                } else {
+                        // Goexit
+                }
+        }()
+        fmt.Println("Testing", name, "...")
+        f(t)
+        if t.errors == nil && rec == nil {
+                fmt.Println("Success:", name)
+        } else {
+                fmt.Println("FAILED:", name, t.errors, rec)
+        }
+}
diff --git a/xdelta3/go/src/xdelta/test.go b/xdelta3/go/src/xdelta/test.go
index 00f3dd7..bab66f3 100644
--- a/xdelta3/go/src/xdelta/test.go
+++ b/xdelta3/go/src/xdelta/test.go
@@ -8,7 +8,6 @@ import (
         "io"
         "io/ioutil"
         "os"
-        "os/exec"
         "path"
         "sync/atomic"
 
@@ -20,19 +19,6 @@ var (
         srcSeq int64
 )
 
-type Program struct {
-        Path string
-}
-
-type Run struct {
-        Cmd exec.Cmd
-        Srcfile string
-        Stdin io.WriteCloser
-        Srcin io.WriteCloser
-        Stdout io.ReadCloser
-        Stderr io.ReadCloser
-}
-
 func (t *TestGroup) Drain(f io.ReadCloser, desc string) <-chan []byte {
         c := make(chan []byte)
         t.Go(desc, func(g *Goroutine) {
@@ -71,9 +57,9 @@ func TestWrite(what string, f io.WriteCloser, b []byte) error {
         return nil
 }
 
-func (t *TestGroup) CopyStreams(r io.ReadCloser, w io.WriteCloser) *Goroutine {
+func (t *TestGroup) CopyStreams(r io.ReadCloser, w io.WriteCloser, written *int64) *Goroutine {
         return t.Go("copy", func(g *Goroutine) {
-                _, err := io.Copy(w, r)
+                nwrite, err := io.Copy(w, r)
                 if err != nil {
                         g.Panic(err)
                 }
@@ -86,6 +72,7 @@ func (t *TestGroup) CopyStreams(r io.ReadCloser, w io.WriteCloser) *Goroutine {
                         g.Panic(err)
                 }
                 g.OK()
+                *written = nwrite
         })
 }
 
@@ -127,12 +114,9 @@ func (t *TestGroup) Exec(desc string, p *Program, srcfifo bool, flags []string)
                 if err = unix.Mkfifo(run.Srcfile, 0600); err != nil {
                         return nil, err
                 }
-                // Because OpenFile blocks on the Fifo until the reader
-                // arrives, a pipe to defer open
                 read, write := io.Pipe()
+                t.writeFifo(run.Srcfile, read)
                 run.Srcin = write
-
-                go writeFifo(run.Srcfile, read)
                 args = append(args, "-s")
                 args = append(args, run.Srcfile)
         }
@@ -156,19 +140,24 @@ func (t *TestGroup) Exec(desc string, p *Program, srcfifo bool, flags []string)
         return run, nil
 }
 
-func (r *Run) Wait() error {
-        return r.Cmd.Wait()
+func (t *TestGroup) Fail(v ...interface{}) {
+        panic(fmt.Sprintln(v...))
 }
 
-func writeFifo(srcfile string, read io.Reader) error {
-        fifo, err := os.OpenFile(srcfile, os.O_WRONLY, 0600)
-        if err != nil {
-                fifo.Close()
-                return err
-        }
-        if _, err := io.Copy(fifo, read); err != nil {
-                fifo.Close()
-                return err
-        }
-        return fifo.Close()
+func (t *TestGroup) writeFifo(srcfile string, read io.Reader) *Goroutine {
+        return t.Go("compare", func(g *Goroutine) {
+                fifo, err := os.OpenFile(srcfile, os.O_WRONLY, 0600)
+                if err != nil {
+                        fifo.Close()
+                        g.Panic(err)
+                }
+                if _, err := io.Copy(fifo, read); err != nil {
+                        fifo.Close()
+                        g.Panic(err)
+                }
+                if err := fifo.Close(); err != nil {
+                        g.Panic(err)
+                }
+                g.OK()
+        })
 }
diff --git a/xdelta3/go/src/xdelta/tgroup.go b/xdelta3/go/src/xdelta/tgroup.go
index 7f6c875..0a3b41b 100644
--- a/xdelta3/go/src/xdelta/tgroup.go
+++ b/xdelta3/go/src/xdelta/tgroup.go
@@ -2,11 +2,13 @@ package xdelta
 
 import (
         "fmt"
+        "runtime"
         "sync"
 )
 
 type TestGroup struct {
         *Runner
+        main *Goroutine
         sync.Mutex
         sync.WaitGroup
         running []*Goroutine
@@ -20,14 +22,6 @@ type Goroutine struct {
         done bool
 }
 
-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, "]")
 }
@@ -59,9 +53,11 @@ func (g *Goroutine) OK() {
 
 func (g *Goroutine) Panic(err error) {
         g.finish(err)
-        select {}
+        runtime.Goexit()
 }
 
+func (t *TestGroup) Main() *Goroutine { return t.main }
+
 func (t *TestGroup) Go(name string, f func(*Goroutine)) *Goroutine {
         g := &Goroutine{t, name, false}
         t.Lock()
@@ -87,7 +83,6 @@ func (t *TestGroup) Wait(self *Goroutine, procs... *Run) {
                 fmt.Println("(ERROR)", err)
         }
         if len(t.errors) != 0 {
-                panic(fmt.Sprintf("Test failed with", len(t.errors), "errors"))
+                t.Fail("Test failed with", len(t.errors), "errors")
         }
 }
-