The Shed
Diff
Login
HomeTimelineFilesBranchesTagsTicketsWiki
Annotate Patch Side-by-side Diff

Differences From Artifact [717a9810a3]:

To Artifact [73a8f932ed]:

︙
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

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)
	}
}

func TestEmptyCycle(t *testing.T) {
	var input []byte = []byte{}

var testData = [][]byte{
	[]byte{},
	[]byte{0, 1, 2, 3},
	if err := cycle(input); err != nil {
		t.Error(err)
	}
}

	[]byte{0, 1, 2, 3, 4, 5, 6, 7},
func TestPartialCycle(t *testing.T) {
	var input []byte = []byte{0, 1, 2, 3}

	[]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},
	if err := cycle(input); err != nil {
		t.Error(err)
	}
}
}


func TestBlockCycle(t *testing.T) {
func TestCycle(t *testing.T) {
	var input []byte = []byte{0, 1, 2, 3, 4, 5, 6, 7}

	if err := cycle(input); err != nil {
		t.Error(err)
	}
}

	for i := 0; i < len(testData); i++ {
		if err := cycle(testData[i], len(testData[i])); 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}

func TestStepCycle(t *testing.T) {
	for i := 0; i < len(testData); i++ {
		for j := 1; j < len(testData); j++ {
	if err := cycle(input); err != nil {
		t.Error(err)
	}
}

			if err := cycle(testData[i], j); err != nil {
				t.Error("Error for testData[", i, "], step[", j, "] ", 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)
	}

}

func cycle(input []byte) error {
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(input)
	if err != nil {
		return err
			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

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\noutput: %#x\n",
			delta, input, decompressed)
		return fmt.Errorf("Unexpected decompressed output %v\ninput:  %#x\ntrace:  %#x\noutput: %#x\n",
			delta, input, trace, decompressed)
	}

	// All is good :)
	return nil
}
Powered by Fossil · RSS