3 files changed, 370 insertions, 0 deletions

diff --git a/xdelta3/go/src/regtest.go b/xdelta3/go/src/regtest.go
new file mode 100644
index 0000000..6497166
--- /dev/null
+++ b/xdelta3/go/src/regtest.go
@@ -0,0 +1,105 @@
+package main
+
+import (
+        "errors"
+        "fmt"
+        "io"
+
+        "xdelta"
+)
+
+const (
+        blocksize = 1<<16
+        winsize = 1<<26
+        xdelta3 = "/volume/home/jmacd/src/xdelta-64bithash/xdelta3/build/x86_64-pc-linux-gnu-m64/usize64/xoff64/xdelta3"
+        seed = 1422253499919909358
+)
+
+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{"-evv"})
+        if err != nil {
+                t.Panic(err)
+        }
+        encodeout := t.Drain(run.Stdout, "encode.stdout")
+        t.Empty(run.Stderr, "encode")
+
+        t.Write("encode.stdin", run.Stdin, []byte(target))
+        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{"-dvv"})
+        if err != nil {
+                t.Panic(err)
+        }
+
+        decodeout := t.Drain(run.Stdout, "decode.stdout")
+        t.Empty(run.Stderr, "decode")
+
+        t.Write("decode.stdin", run.Stdin, <-encodeout)
+        t.Write("decode.srcin", run.Srcin, []byte(source))
+        decoded := string(<-decodeout)
+        if err := run.Cmd.Wait(); err != nil {
+                t.Panic(err)
+        }
+        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) {
+        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 {
+                t.Panic(err)
+        }
+        dargs := []string{"-d", fmt.Sprint("-B", bufsize), "-vv", fmt.Sprint("-W", winsize)}
+        dec, err := r.Exec(p, true, dargs)
+        if err != nil {
+                t.Panic(err)
+        }
+
+        read, write := io.Pipe()
+
+        t.Empty(enc.Stderr, "encode")
+        t.Empty(dec.Stderr, "decode")
+
+        t.CopyStreams(enc.Stdout, dec.Stdin)
+        t.CompareStreams(dec.Stdout, read, length)
+
+        // 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)
+        xdelta.WriteRstreams(t, seed, offset, length, dec.Srcin, write)
+
+        if err := enc.Cmd.Wait(); err != nil {
+                t.Panic(err)
+        }
+        if err := dec.Cmd.Wait(); err != nil {
+                t.Panic(err)
+        }
+        t.Done()
+}
+
+func main() {
+        r, err := xdelta.NewRunner()
+        if err != nil {
+                panic(err)
+        }
+        defer r.Cleanup()
+
+        prog := &xdelta.Program{xdelta3}
+
+        smokeTest(r, xdelta.NewTestGroup(), prog)
+
+        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
new file mode 100644
index 0000000..3e7265f
--- /dev/null
+++ b/xdelta3/go/src/xdelta/rstream.go
@@ -0,0 +1,60 @@
+package xdelta
+
+
+import (
+        "io"
+        "math/rand"
+)
+
+const (
+        blocksize = 16380
+)
+
+func WriteRstreams(t *TestGroup, seed, offset, len int64,
+        first, second io.WriteCloser) {
+        go writeOne(t, seed, 0, len, first)
+        go writeOne(t, seed, offset, len, second)
+}
+
+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 {
+                        return err
+                }
+        }
+        if err := writeRand(rand.New(rand.NewSource(seed)),
+                len - offset, stream); err != nil {
+                return err
+        }
+        t.WaitGroup.Done()
+        return stream.Close()
+}
+
+func writeRand(r *rand.Rand, len int64, s io.Writer) error {
+        blk := make([]byte, blocksize)
+        for len > 0 {
+                fillRand(r, blk)
+                c := blocksize
+                if len < blocksize {
+                        c = int(len)
+                }
+                if _, err := s.Write(blk[0:c]); err != nil {
+                        return err
+                }
+                len -= int64(c)
+        }
+        return nil
+}
+
+func fillRand(r *rand.Rand, blk []byte) {
+        for p := 0; p < blocksize; {
+                v := r.Int63()
+                for i := 7; i != 0; i-- {
+                        blk[p] = byte(v)
+                        p++
+                        v >>= 8
+                }
+        }
+}
diff --git a/xdelta3/go/src/xdelta/test.go b/xdelta3/go/src/xdelta/test.go
new file mode 100644
index 0000000..9eb47f6
--- /dev/null
+++ b/xdelta3/go/src/xdelta/test.go
@@ -0,0 +1,205 @@
+package xdelta
+
+import (
+        "bufio"
+        "bytes"
+        "errors"
+        "fmt"
+        "io"
+        "io/ioutil"
+        "os"
+        "os/exec"
+        "path"
+        "sync/atomic"
+        "sync"
+
+        "golang.org/x/sys/unix"
+)
+
+var (
+        tmpDir = "/tmp"
+        srcSeq int64
+)
+
+type Program struct {
+        Path string
+}
+
+type Runner struct {
+        Testdir string
+}
+
+type TestGroup struct {
+        sync.WaitGroup
+}
+
+type Run struct {
+        Cmd exec.Cmd
+        Srcfile string
+        Stdin io.WriteCloser
+        Srcin io.WriteCloser
+        Stdout io.ReadCloser
+        Stderr io.ReadCloser
+}
+
+func (t *TestGroup) Panic(err error) {
+        t.Done()  // For the caller
+        t.Wait()
+        panic(err)
+}
+
+func NewTestGroup() *TestGroup {
+        return &TestGroup{}
+}
+
+func (t *TestGroup) Drain(f io.ReadCloser, desc string) <-chan []byte {
+        c := make(chan []byte)
+        go func() {
+                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.Done()
+        }()
+        return c
+}
+
+func (t *TestGroup) Empty(f io.ReadCloser, desc string) {
+        go func() {
+                t.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.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) {
+        go func() {
+                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) {
+        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)
+                }
+                t.Done()
+        }()
+}
+
+func NewRunner() (*Runner, error) {
+        if dir, err := ioutil.TempDir(tmpDir, "xrt"); err != nil {
+                return nil, err
+        } else {
+                return &Runner{dir}, nil
+        }
+}
+
+func (r *Runner) Cleanup() {
+        os.RemoveAll(r.Testdir)
+}
+
+func (r *Runner) Exec(p *Program, srcfifo bool, flags []string) (*Run, error) {
+        var err error
+        run := &Run{}
+        args := []string{p.Path}
+        if srcfifo {
+                num := atomic.AddInt64(&srcSeq, 1)
+                run.Srcfile = path.Join(r.Testdir, fmt.Sprint("source", num))
+                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()
+                run.Srcin = write
+
+                go writeFifo(run.Srcfile, read)
+                args = append(args, "-s")
+                args = append(args, run.Srcfile)
+        }
+        if run.Stdin, err = run.Cmd.StdinPipe(); err != nil {
+                return nil, err
+        }
+        if run.Stdout, err = run.Cmd.StdoutPipe(); err != nil {
+                return nil, err
+        }
+        if run.Stderr, err = run.Cmd.StderrPipe(); err != nil {
+                return nil, err
+        }
+
+        run.Cmd.Path = p.Path
+        run.Cmd.Args = append(args, flags...)
+        run.Cmd.Dir = r.Testdir
+        run.Cmd.Start()
+
+        return run, nil
+}
+
+func writeFifo(srcfile string, read io.Reader) error {
+        fifo, err := os.OpenFile(srcfile, os.O_WRONLY, 0600)
+        if err != nil {
+                return err
+        }
+        if _, err := io.Copy(fifo, read); err != nil {
+                return err
+        }
+        if err := fifo.Close(); err != nil {
+                return err
+        }
+        return nil
+}