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
111
112
113
114
115
116
117
118
119
120
121
122
123
124
|
func(i, j int) bool { return result[i] == input[j] }})
if len(delta.Added) > 0 || len(delta.Removed) > 0 {
t.Error("Unexpected decompressed output", delta)
}
}
func TestEmptyCycle(t *testing.T) {
var input []byte = []byte{}
if err := cycle(input); err != nil {
t.Error(err)
}
}
func TestPartialCycle(t *testing.T) {
var input []byte = []byte{0, 1, 2, 3}
if err := cycle(input); err != nil {
t.Error(err)
}
}
BlockCycle(t *testing.T) {
var input []byte = []byte{0, 1, 2, 3, 4, 5, 6, 7}
if err := cycle(input); err != nil {
t.Error(err)
}
}
func TestBlockPartialCycle(t *testing.T) {
var input []byte = []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}
if err := cycle(input); err != nil {
t.Error(err)
}
}
func TestDualBlockCycle(t *testing.T) {
var input []byte = []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}
if err := cycle(input); err != nil {
t.Error(err)
}
}
var (
buf bytes.Buffer
err error
)
// Create a compressor and write the given data
compressor := Compressor(&buf)
err = compressor(input)
if err != nil {
return err
}
// Flush the compressor
err = compressor(nil)
if err != nil {
return err
}
|
|
|
|
<
<
<
<
|
<
|
|
<
<
|
|
<
|
<
|
|
|
|
|
|
<
<
>
>
>
|
|
|
|
|
<
<
|
<
<
|
<
<
|
>
>
>
>
>
>
>
>
>
>
>
>
>
|
|
|
>
>
>
>
>
|
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
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
|
func(i, j int) bool { return result[i] == input[j] }})
if len(delta.Added) > 0 || len(delta.Removed) > 0 {
t.Error("Unexpected decompressed output", delta)
}
}
var testData = [][]byte{
[]byte{},
[]byte{0, 1, 2, 3},
[]byte{0, 1, 2, 3, 4, 5, 6, 7},
[]byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11},
[]byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15},
}
func TestCycle(t *testing.T) {
for i := 0; i < len(testData); i++ {
if err := cycle(testData[i], len(testData[i])); err != nil {
t.Error(err)
}
}
}
func TestStepCycle(t *testing.T) {
for i := 0; i < len(testData); i++ {
for j := 1; j < len(testData); j++ {
if err := cycle(testData[i], j); err != nil {
t.Error("Error for testData[", i, "], step[", j, "] ", err)
}
}
}
}
func cycle(input []byte, step int) error {
var (
buf bytes.Buffer
err error
)
if step > len(input) {
return nil
}
// Create a compressor and write the given data
compressor := Compressor(&buf)
var data []byte = input
var trace []byte = make([]byte, 0)
for len(data) > 0 {
if step <= len(data) {
trace = append(trace, data[:step]...)
err = compressor(data[:step])
if err != nil {
return err
}
data = data[step:]
} else {
step = len(data)
}
}
// Flush the compressor
err = compressor(nil)
if err != nil {
return err
}
|
132
133
134
135
136
137
138
139
140
141
142
143
144
145
|
// Diff the result against the initial input
delta := diff.Diff(diff.D{len(input), len(decompressed),
func(i, j int) bool { return input[i] == decompressed[j] }})
// Return a well-formated error if any differences are found
if len(delta.Added) > 0 || len(delta.Removed) > 0 {
return fmt.Errorf("Unexpected decompressed output %v\ninput: %#x\noutput: %#x\n",
delta, input, decompressed)
}
// All is good :)
return nil
}
|
|
|
|
136
137
138
139
140
141
142
143
144
145
146
147
148
149
|
// Diff the result against the initial input
delta := diff.Diff(diff.D{len(input), len(decompressed),
func(i, j int) bool { return input[i] == decompressed[j] }})
// Return a well-formated error if any differences are found
if len(delta.Added) > 0 || len(delta.Removed) > 0 {
return fmt.Errorf("Unexpected decompressed output %v\ninput: %#x\ntrace: %#x\noutput: %#x\n",
delta, input, trace, decompressed)
}
// All is good :)
return nil
}
|