2 files changed, 29 insertions, 25 deletions

diff --git a/xdelta3/go/src/regtest.go b/xdelta3/go/src/regtest.go
index f5c5480..24229f9 100644
--- a/xdelta3/go/src/regtest.go
+++ b/xdelta3/go/src/regtest.go
@@ -5,15 +5,16 @@ import (
         "io"
         "path"
         "os"
+        "sort"
         "time"
 
         "xdelta"
 )
 
 const (
-        xdataset = "/Users/jmacd/src/testdata"
-        xcompare = "/Users/jmacd/src/xdelta3-3.0.10/xdelta3"
-        xdelta3 = "/Users/jmacd/src/xdelta-devel/xdelta3/xdelta3"
+        xdataset = "/volume/home/jmacd/src/testdata"
+        xcompare = "/volume/home/jmacd/src/xdelta3-3.0.10/xdelta3"
+        xdelta3 = "/volume/home/jmacd/src/xdelta-devel/xdelta3/xdelta3"
         seed = 1422253499919909358
 )
 
@@ -34,10 +35,12 @@ func (c Config) smokeTest(t *xdelta.TestGroup, p xdelta.Program) {
 
         enc, err := t.Exec("encode", p, true, []string{"-e"})
         if err != nil {
+                fmt.Println(err)
                 t.Panic(err)
         }
         dec, err := t.Exec("decode", p, true, []string{"-d"})
         if err != nil {
+                fmt.Println(err)
                 t.Panic(err)
         }
 
@@ -86,8 +89,8 @@ func (to *TestOutput) Add(a TestOutput) {
 }
 
 func (to *TestOutput) String() string {
-        return fmt.Sprintf("SIZE: %v\tTIME: %v",
-                to.encoded, to.encDuration)
+        return fmt.Sprintf("SIZE: %v\tT: %v\tTSYS: %v\tDT: %v\tDTSYS: %v",
+                to.encoded, to.encDuration, to.encSysDuration, to.decDuration, to.encSysDuration)
 }
 
 // P is the test program, Q is the reference version.
@@ -110,17 +113,19 @@ func (cfg Config) datasetTest(t *xdelta.TestGroup, p, q xdelta.Program) {
                 total += d.Size()
         }
         meansize := total / int64(len(dents))
+        largest  := uint(20)
+        for ; largest <= 31 && 1<<largest < meansize; largest++ {}
+
+        sort.Strings(paths)
+
         testSum := map[uint]*TestOutput{}
         compSum := map[uint]*TestOutput{}
+
         for _, in1 := range paths {
                 for _, in2 := range paths {
                         if in1 == in2 { continue }
 
-                        largest := uint(20)
-                        for ; largest <= 31 && 1<<largest < meansize; largest++ {}
-
-                        // 1/4, 1/2, and 1/1 of the power-of-2 rounded-up mean size
-                        // TODO NOTE
+                        // 1/4, 1/2, and 1 of the power-of-2 rounded-up mean size
                         for b := largest - 2; b <= largest; b++ {
                                 if _, has := testSum[b]; !has {
                                         testSum[b] = &TestOutput{}
@@ -166,16 +171,16 @@ 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,
-                "-I0", pt.target}
+                "-I0", "-S", "none", pt.target}
         enc, err := t.Exec("encode", pt.program, false, eargs)
         if err != nil {
                 t.Panic(err)
         }
 
-        // TODO HACK "* 2" for known / fixed bug in decoder. Helps compare
-        // encoder perf in reasonable time, makes invalid decoder results.
-        dargs := []string{"-dc", fmt.Sprint("-B", cfg.srcbuf_size * 2), //"-q",
-                fmt.Sprint("-W", cfg.window_size), "-s", pt.source}
+        dargs := []string{"-dc", fmt.Sprint("-B", cfg.srcbuf_size), //"-q",
+                fmt.Sprint("-W", cfg.window_size), "-s", pt.source,
+                "-S", "none"}
+
         dec, err := t.Exec("decode", pt.program, false, dargs)
         if err != nil {
                 t.Panic(err)
diff --git a/xdelta3/go/src/xdelta/run.go b/xdelta3/go/src/xdelta/run.go
index 3b07178..6523a1c 100644
--- a/xdelta3/go/src/xdelta/run.go
+++ b/xdelta3/go/src/xdelta/run.go
@@ -52,17 +52,16 @@ func (r *Runner) Cleanup() {
 
 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
-                }
+        c := make(chan interface{})
+        go func() {
+                defer func() {
+                        c <- recover()
+                }()
+                fmt.Println("Testing", name, "...")
+                f(t)
+                c <- nil
         }()
-        fmt.Println("Testing", name, "...")
-        f(t)
+        rec := <- c
         if t.errors == nil && rec == nil {
                 fmt.Println("Success:", name)
         } else {