1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
|
package main
import (
"errors"
"fmt"
"io"
"xdelta"
)
const (
blocksize = 1<<16
winsize = 1<<22
xdelta3 = "/Users/jmacd/src/xdelta-devel/xdelta3/xdelta3"
seed = 1422253499919909358
)
func smokeTest(r *xdelta.Runner, p *xdelta.Program) {
t, g := xdelta.NewTestGroup(r)
target := "Hello world!"
source := "Hello world, nice to meet you!"
enc, err := t.Exec("encode", p, true, []string{"-evv"})
if err != nil {
g.Panic(err)
}
encodeout := t.Drain(enc.Stdout, "encode.stdout")
t.Empty(enc.Stderr, "encode")
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)
}
dec, err := t.Exec("decode", p, true, []string{"-dvv"})
if err != nil {
g.Panic(err)
}
decodeout := t.Drain(dec.Stdout, "decode.stdout")
t.Empty(dec.Stderr, "decode")
if err := xdelta.TestWrite("decode.stdin", dec.Stdin, <-encodeout); err != nil {
g.Panic(err)
}
if err := xdelta.TestWrite("decode.srcin", dec.Srcin, []byte(source)); err != nil {
g.Panic(err)
}
decoded := string(<-decodeout)
if decoded != target {
g.Panic(errors.New("It's not working!!!"))
}
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)}
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)}
dec, err := t.Exec("decode", p, true, dargs)
if err != nil {
g.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)
// The decoder output ("read", above) is compared with the
// test-provided output ("write", below). The following
// 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)
}
func main() {
r, err := xdelta.NewRunner()
if err != nil {
panic(err)
}
defer r.Cleanup()
prog := &xdelta.Program{xdelta3}
smokeTest(r, prog)
fmt.Println("Smoke-test pass")
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)
}
|
