8 files changed, 60 insertions, 28 deletions

diff --git a/.gitignore b/.gitignore
index 5761abc..366b29f 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1 +1,20 @@
 *.o
+*~
+
+Makefile.in
+aclocal.m4
+autom4te.cache
+build
+compile
+config.guess
+config.h.in
+config.sub
+configure
+depcomp
+ltmain.sh
+libtool.m4
+ltoptions.m4
+ltsugar.m4
+ltversion.m4
+lt~obsolete.m4
+missing
diff --git a/xdelta3/Makefile.am b/xdelta3/Makefile.am
index f589599..ffc35a4 100644
--- a/xdelta3/Makefile.am
+++ b/xdelta3/Makefile.am
@@ -1,4 +1,5 @@
 ACLOCAL_AMFLAGS = -I m4
+AUTOMAKE_OPTIONS = subdir-objects
 
 bin_PROGRAMS = xdelta3
 noinst_PROGRAMS = xdelta3regtest xdelta3decode xdelta3checksum
diff --git a/xdelta3/go/src/regtest.go b/xdelta3/go/src/regtest.go
index d31e905..52547e1 100644
--- a/xdelta3/go/src/regtest.go
+++ b/xdelta3/go/src/regtest.go
@@ -1,16 +1,20 @@
 package main
 
 import (
+        "bufio"
         "bytes"
         "fmt"
         "io"
         "io/ioutil"
+        "os"
+
         "xdelta"
 )
 
 const (
-        blocksize = 1<<20
-        prog = "/Users/jmacd/src/xdelta/xdelta3/xdelta3"
+        blocksize = 1<<16
+        winsize = 1<<26
+        prog = "/Users/jmacd/src/xdelta/xdelta3/build/m64/64size-64off/xdelta3"
         seed = 1422253499919909358
 )
 
@@ -26,10 +30,14 @@ func drain(f io.ReadCloser) <-chan []byte {
         return c
 }
 
-func empty(f io.ReadCloser) {
+func empty(f io.ReadCloser, desc string) {
         go func() {
-                if _, err := ioutil.ReadAll(f); err != nil {
-                        panic(err)
+                s := bufio.NewScanner(f)
+                for s.Scan() {
+                        os.Stderr.Write([]byte(fmt.Sprint(desc, ": ", s.Text(), "\n")))
+                }
+                if err := s.Err(); err != nil {
+                        fmt.Println("error reading input:", err)
                 }
         }()
 }
@@ -52,7 +60,7 @@ func smokeTest(r *xdelta.Runner, p *xdelta.Program) {
                 panic(err)
         }
         encodeout := drain(run.Stdout)
-        empty(run.Stderr)
+        empty(run.Stderr, "encode")
 
         write(run.Stdin, []byte(target))
         write(run.Srcin, []byte(source))
@@ -67,7 +75,7 @@ func smokeTest(r *xdelta.Runner, p *xdelta.Program) {
         }
 
         decodeout := drain(run.Stdout)
-        empty(run.Stderr)
+        empty(run.Stderr, "decode")
 
         write(run.Stdin, <-encodeout)
         write(run.Srcin, []byte(source))
@@ -121,12 +129,12 @@ func compareStreams(r1 io.ReadCloser, r2 io.ReadCloser, length int64) {
         }
 }
 
-func offsetTest(r *xdelta.Runner, p *xdelta.Program, offset, length int64) {
-        enc, err := r.Exec(p, true, []string{"-e"})
+func offsetTest(r *xdelta.Runner, p *xdelta.Program, offset, bufsize, length int64) {
+        enc, err := r.Exec(p, true, []string{"-e", "-1", "-n", fmt.Sprint("-B", bufsize), "-vv", fmt.Sprint("-W", winsize)})
         if err != nil {
                 panic(err)
         }
-        dec, err := r.Exec(p, true, []string{"-d"})
+        dec, err := r.Exec(p, true, []string{"-d", fmt.Sprint("-B", bufsize), "-vv", fmt.Sprint("-W", winsize)})
         if err != nil {
                 panic(err)
         }
@@ -136,8 +144,8 @@ func offsetTest(r *xdelta.Runner, p *xdelta.Program, offset, length int64) {
         go copyStreams(enc.Stdout, dec.Stdin)
         go compareStreams(dec.Stdout, read, length)
 
-        empty(enc.Stderr)  // Use these?
-        empty(dec.Stderr)
+        empty(enc.Stderr, "encode")
+        empty(dec.Stderr, "decode")
 
         // TODO: seems possible to use one WriteRstreams call to generate
         // the source and target for both encoder and decoder.  Why not?
@@ -163,5 +171,5 @@ func main() {
 
         smokeTest(r, prog)
 
-        offsetTest(r, prog, 0, 1024 << 20)
+        offsetTest(r, prog, 1 << 31, 1 << 32, 1 << 33)
 }
diff --git a/xdelta3/go/src/xdelta/rstream.go b/xdelta3/go/src/xdelta/rstream.go
index 1666934..1d56031 100644
--- a/xdelta3/go/src/xdelta/rstream.go
+++ b/xdelta3/go/src/xdelta/rstream.go
@@ -16,20 +16,21 @@ func WriteRstreams(seed, offset, len int64,
         go writeOne(seed, offset, len, second)
 }
 
-func writeOne(seed, offset, len int64, stream io.WriteCloser) {
+func writeOne(seed, offset, len int64, stream io.WriteCloser) error {
         if offset != 0 {
                 // Fill with other random data until the offset
-                writeRand(rand.New(rand.NewSource(^seed)),
-                        offset, stream)
+                if err := writeRand(rand.New(rand.NewSource(^seed)), offset, stream); err != nil {
+                        return err
+                }
         }
-        writeRand(rand.New(rand.NewSource(seed)),
-                len - offset, stream)
-        if err := stream.Close(); err != nil {
-                panic(err)
+        if err := writeRand(rand.New(rand.NewSource(seed)),
+                len - offset, stream); err != nil {
+                return err
         }
+        return stream.Close()
 }
 
-func writeRand(r *rand.Rand, len int64, s io.Writer) {
+func writeRand(r *rand.Rand, len int64, s io.Writer) error {
         blk := make([]byte, blocksize)
         for len > 0 {
                 fillRand(r, blk)
@@ -38,10 +39,11 @@ func writeRand(r *rand.Rand, len int64, s io.Writer) {
                         c = int(len)
                 }
                 if _, err := s.Write(blk[0:c]); err != nil {
-                        panic(err)
+                        return err
                 }
                 len -= int64(c)
         }
+        return nil
 }
 
 func fillRand(r *rand.Rand, blk []byte) {
diff --git a/xdelta3/go/src/xdelta/test.go b/xdelta3/go/src/xdelta/test.go
index 292f133..3143dfa 100644
--- a/xdelta3/go/src/xdelta/test.go
+++ b/xdelta3/go/src/xdelta/test.go
@@ -83,15 +83,16 @@ func (r *Runner) Exec(p *Program, srcfifo bool, flags []string) (*Run, error) {
         return run, nil
 }
 
-func writeFifo(srcfile string, read io.Reader) {
+func writeFifo(srcfile string, read io.Reader) error {
         fifo, err := os.OpenFile(srcfile, os.O_WRONLY, 0600)
         if err != nil {
-                panic(err)
+                return err
         }
         if _, err := io.Copy(fifo, read); err != nil {
-                panic(err)
+                return err
         }
         if err := fifo.Close(); err != nil {
-                panic(err)
+                return err
         }
+        return nil
 }
diff --git a/xdelta3/run_release.sh b/xdelta3/run_release.sh
index fc06491..2ac810a 100755
--- a/xdelta3/run_release.sh
+++ b/xdelta3/run_release.sh
@@ -52,6 +52,7 @@ function buildit {
     echo CXXFLAGS=$CXXFLAGS
     D=build/$MACH/${sizebits}size-${offsetbits}off
     mkdir -p $D
+    echo "Configuring $D ..."
     (cd $D && $SRCDIR/configure --prefix=$PWD/bin --enable-debug-symbols)
     #(cd $D && make all && make test)
 }
diff --git a/xdelta3/xdelta3-main.h b/xdelta3/xdelta3-main.h
index 157a4fb..1871f14 100644
--- a/xdelta3/xdelta3-main.h
+++ b/xdelta3/xdelta3-main.h
@@ -708,7 +708,7 @@ main_atoux (const char* arg, xoff_t *xo, xoff_t low,
   int ret;
 
   if ((ret = main_strtoxoff (arg, & x, which))) { return ret; }
-  XPR(NT "SEE -%c: value %"Q" low %"Q" high %"Q"\n", which, x, low, high);
+
   if (x < low)
     {
       XPR(NT "-%c: minimum value: %"Q"\n", which, low);
diff --git a/xdelta3/xdelta3.h b/xdelta3/xdelta3.h
index f1aa5d8..bb5f4d6 100644
--- a/xdelta3/xdelta3.h
+++ b/xdelta3/xdelta3.h
@@ -71,7 +71,7 @@
  *
  * 8-16MB is reasonable, probably don't need to go larger. */
 #ifndef XD3_HARDMAXWINSIZE
-#define XD3_HARDMAXWINSIZE (1U<<24)
+#define XD3_HARDMAXWINSIZE (1U<<26)
 #endif
 /* The IOPT_SIZE value sets the size of a buffer used to batch
  * overlapping copy instructions before they are optimized by picking