summaryrefslogtreecommitdiff
path: root/t/t9011-svn-da.sh
blob: b38d16f9dbd6e6f575e12f81e7d6546f07e53f1f (plain)
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
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
#!/bin/sh

test_description='test parsing of svndiff0 files

Using the "test-svn-fe -d" helper, check that svn-fe correctly
interprets deltas using various facilities (some from the spec,
some only learned from practice).
'
. ./test-lib.sh

>empty
printf foo >preimage

test_expect_success 'reject empty delta' '
	test_must_fail test-svn-fe -d preimage empty 0
'

test_expect_success 'delta can empty file' '
	printf "SVNQ" | q_to_nul >clear.delta &&
	test-svn-fe -d preimage clear.delta 4 >actual &&
	test_cmp empty actual
'

test_expect_success 'reject svndiff2' '
	printf "SVN\002" >bad.filetype &&
	test_must_fail test-svn-fe -d preimage bad.filetype 4
'

test_expect_success 'one-window empty delta' '
	printf "SVNQ%s" "QQQQQ" | q_to_nul >clear.onewindow &&
	test-svn-fe -d preimage clear.onewindow 9 >actual &&
	test_cmp empty actual
'

test_expect_success 'reject incomplete window header' '
	printf "SVNQ%s" "QQQQQ" | q_to_nul >clear.onewindow &&
	printf "SVNQ%s" "QQ" | q_to_nul >clear.partialwindow &&
	test_must_fail test-svn-fe -d preimage clear.onewindow 6 &&
	test_must_fail test-svn-fe -d preimage clear.partialwindow 6
'

test_expect_success 'reject declared delta longer than actual delta' '
	printf "SVNQ%s" "QQQQQ" | q_to_nul >clear.onewindow &&
	printf "SVNQ%s" "QQ" | q_to_nul >clear.partialwindow &&
	test_must_fail test-svn-fe -d preimage clear.onewindow 14 &&
	test_must_fail test-svn-fe -d preimage clear.partialwindow 9
'

test_expect_success 'two-window empty delta' '
	printf "SVNQ%s%s" "QQQQQ" "QQQQQ" | q_to_nul >clear.twowindow &&
	test-svn-fe -d preimage clear.twowindow 14 >actual &&
	test_must_fail test-svn-fe -d preimage clear.twowindow 13 &&
	test_cmp empty actual
'

test_expect_success 'noisy zeroes' '
	printf "SVNQ%s" \
		"RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRQQQQQ" |
		tr R "\200" |
		q_to_nul >clear.noisy &&
	len=$(wc -c <clear.noisy) &&
	test-svn-fe -d preimage clear.noisy $len &&
	test_cmp empty actual
'

test_expect_success 'reject variable-length int in magic' '
	printf "SVNRQ" | tr R "\200" | q_to_nul >clear.badmagic &&
	test_must_fail test-svn-fe -d preimage clear.badmagic 5
'

test_expect_success 'reject truncated integer' '
	printf "SVNQ%s%s" "QQQQQ" "QQQQRRQ" |
		tr R "\200" |
		q_to_nul >clear.fullint &&
	printf "SVNQ%s%s" "QQQQQ" "QQQQRR" |
		tr RT "\201" |
		q_to_nul >clear.partialint &&
	test_must_fail test-svn-fe -d preimage clear.fullint 15 &&
	test-svn-fe -d preimage clear.fullint 16 &&
	test_must_fail test-svn-fe -d preimage clear.partialint 15
'

test_expect_success 'nonempty (but unused) preimage view' '
	printf "SVNQ%b" "Q\003QQQ" | q_to_nul >clear.readpreimage &&
	test-svn-fe -d preimage clear.readpreimage 9 >actual &&
	test_cmp empty actual
'

test_expect_success 'preimage view: right endpoint cannot backtrack' '
	printf "SVNQ%b%b" "Q\003QQQ" "Q\002QQQ" |
		q_to_nul >clear.backtrack &&
	test_must_fail test-svn-fe -d preimage clear.backtrack 14
'

test_expect_success 'preimage view: left endpoint can advance' '
	printf "SVNQ%b%b" "Q\003QQQ" "\001\002QQQ" |
		q_to_nul >clear.preshrink &&
	printf "SVNQ%b%b" "Q\003QQQ" "\001\001QQQ" |
		q_to_nul >clear.shrinkbacktrack &&
	test-svn-fe -d preimage clear.preshrink 14 >actual &&
	test_must_fail test-svn-fe -d preimage clear.shrinkbacktrack 14 &&
	test_cmp empty actual
'

test_expect_success 'preimage view: offsets compared by value' '
	printf "SVNQ%b%b" "\001\001QQQ" "\0200Q\003QQQ" |
		q_to_nul >clear.noisybacktrack &&
	printf "SVNQ%b%b" "\001\001QQQ" "\0200\001\002QQQ" |
		q_to_nul >clear.noisyadvance &&
	test_must_fail test-svn-fe -d preimage clear.noisybacktrack 15 &&
	test-svn-fe -d preimage clear.noisyadvance 15 &&
	test_cmp empty actual
'

test_expect_success 'preimage view: reject truncated preimage' '
	printf "SVNQ%b" "\010QQQQ" | q_to_nul >clear.lateemptyread &&
	printf "SVNQ%b" "\010\001QQQ" | q_to_nul >clear.latenonemptyread &&
	printf "SVNQ%b" "\001\010QQQ" | q_to_nul >clear.longread &&
	test_must_fail test-svn-fe -d preimage clear.lateemptyread 9 &&
	test_must_fail test-svn-fe -d preimage clear.latenonemptyread 9 &&
	test_must_fail test-svn-fe -d preimage clear.longread 9
'

test_expect_success 'forbid unconsumed inline data' '
	printf "SVNQ%b%s%b%s" "QQQQ\003" "bar" "QQQQ\001" "x" |
		q_to_nul >inline.clear &&
	test_must_fail test-svn-fe -d preimage inline.clear 18 >actual
'

test_expect_success 'reject truncated inline data' '
	printf "SVNQ%b%s" "QQQQ\003" "b" | q_to_nul >inline.trunc &&
	test_must_fail test-svn-fe -d preimage inline.trunc 10
'

test_expect_success 'reject truncated inline data (after instruction section)' '
	printf "SVNQ%b%b%s" "QQ\001\001\003" "\0201" "b" | q_to_nul >insn.trunc &&
	test_must_fail test-svn-fe -d preimage insn.trunc 11
'

test_expect_success 'copyfrom_data' '
	echo hi >expect &&
	printf "SVNQ%b%b%b" "QQ\003\001\003" "\0203" "hi\n" | q_to_nul >copydat &&
	test-svn-fe -d preimage copydat 13 >actual &&
	test_cmp expect actual
'

test_expect_success 'multiple copyfrom_data' '
	echo hi >expect &&
	printf "SVNQ%b%b%b%b%b" "QQ\003\002\003" "\0201\0202" "hi\n" \
		"QQQ\002Q" "\0200Q" | q_to_nul >copy.multi &&
	len=$(wc -c <copy.multi) &&
	test-svn-fe -d preimage copy.multi $len >actual &&
	test_cmp expect actual
'

test_expect_success 'incomplete multiple insn' '
	printf "SVNQ%b%b%b" "QQ\003\002\003" "\0203\0200" "hi\n" |
		q_to_nul >copy.partial &&
	len=$(wc -c <copy.partial) &&
	test_must_fail test-svn-fe -d preimage copy.partial $len
'

test_expect_success 'catch attempt to copy missing data' '
	printf "SVNQ%b%b%s%b%s" "QQ\002\002\001" "\0201\0201" "X" \
			"QQQQ\002" "YZ" |
		q_to_nul >copy.incomplete &&
	len=$(wc -c <copy.incomplete) &&
	test_must_fail test-svn-fe -d preimage copy.incomplete $len
'

test_expect_success 'copyfrom target to repeat data' '
	printf foofoo >expect &&
	printf "SVNQ%b%b%s" "QQ\006\004\003" "\0203\0100\003Q" "foo" |
		q_to_nul >copytarget.repeat &&
	len=$(wc -c <copytarget.repeat) &&
	test-svn-fe -d preimage copytarget.repeat $len >actual &&
	test_cmp expect actual
'

test_expect_success 'copyfrom target out of order' '
	printf foooof >expect &&
	printf "SVNQ%b%b%s" \
		"QQ\006\007\003" "\0203\0101\002\0101\001\0101Q" "foo" |
		q_to_nul >copytarget.reverse &&
	len=$(wc -c <copytarget.reverse) &&
	test-svn-fe -d preimage copytarget.reverse $len >actual &&
	test_cmp expect actual
'

test_expect_success 'catch copyfrom future' '
	printf "SVNQ%b%b%s" "QQ\004\004\003" "\0202\0101\002\0201" "XYZ" |
		q_to_nul >copytarget.infuture &&
	len=$(wc -c <copytarget.infuture) &&
	test_must_fail test-svn-fe -d preimage copytarget.infuture $len
'

test_expect_success 'copy to sustain' '
	printf XYXYXYXYXYXZ >expect &&
	printf "SVNQ%b%b%s" "QQ\014\004\003" "\0202\0111Q\0201" "XYZ" |
		q_to_nul >copytarget.sustain &&
	len=$(wc -c <copytarget.sustain) &&
	test-svn-fe -d preimage copytarget.sustain $len >actual &&
	test_cmp expect actual
'

test_expect_success 'catch copy that overflows' '
	printf "SVNQ%b%b%s" "QQ\003\003\001" "\0201\0177Q" X |
		q_to_nul >copytarget.overflow &&
	len=$(wc -c <copytarget.overflow) &&
	test_must_fail test-svn-fe -d preimage copytarget.overflow $len
'

test_expect_success 'copyfrom source' '
	printf foo >expect &&
	printf "SVNQ%b%b" "Q\003\003\002Q" "\003Q" | q_to_nul >copysource.all &&
	test-svn-fe -d preimage copysource.all 11 >actual &&
	test_cmp expect actual
'

test_expect_success 'copy backwards' '
	printf oof >expect &&
	printf "SVNQ%b%b" "Q\003\003\006Q" "\001\002\001\001\001Q" |
		q_to_nul >copysource.rev &&
	test-svn-fe -d preimage copysource.rev 15 >actual &&
	test_cmp expect actual
'

test_expect_success 'offsets are relative to window' '
	printf fo >expect &&
	printf "SVNQ%b%b%b%b" "Q\003\001\002Q" "\001Q" \
		"\002\001\001\002Q" "\001Q" |
		q_to_nul >copysource.two &&
	test-svn-fe -d preimage copysource.two 18 >actual &&
	test_cmp expect actual
'

test_expect_success 'example from notes/svndiff' '
	printf aaaaccccdddddddd >expect &&
	printf aaaabbbbcccc >source &&
	printf "SVNQ%b%b%s" "Q\014\020\007\001" \
		"\004Q\004\010\0201\0107\010" d |
		q_to_nul >delta.example &&
	len=$(wc -c <delta.example) &&
	test-svn-fe -d source delta.example $len >actual &&
	test_cmp expect actual
'

test_done