|
@@ -91,11 +91,30 @@ class TestHunk(unittest.TestCase):
|
91
|
91
|
class TestDiff(unittest.TestCase):
|
92
|
92
|
|
93
|
93
|
def _init_diff(self):
|
94
|
|
- hunk = cdiff.Hunk(['hunk header\n'], '@@ -1,2 +1,2 @@\n',
|
95
|
|
- (1, 2), (1, 2))
|
96
|
|
- hunk.append(('-', 'hella\n'))
|
97
|
|
- hunk.append(('+', 'hello\n'))
|
|
94
|
+ """Return a minimal diff contains all required samples
|
|
95
|
+ header
|
|
96
|
+ --- old
|
|
97
|
+ +++ new
|
|
98
|
+ hunk header
|
|
99
|
+ @@ -1,4 +1,4 @@
|
|
100
|
+ -hhello
|
|
101
|
+ +helloo
|
|
102
|
+ +spammm
|
|
103
|
+ world
|
|
104
|
+ -garb
|
|
105
|
+ -Again
|
|
106
|
+ +again
|
|
107
|
+ """
|
|
108
|
+
|
|
109
|
+ hunk = cdiff.Hunk(['hunk header\n'], '@@ -1,4 +1,4 @@\n',
|
|
110
|
+ (1, 4), (1, 4))
|
|
111
|
+ hunk.append(('-', 'hhello\n'))
|
|
112
|
+ hunk.append(('+', 'helloo\n'))
|
|
113
|
+ hunk.append(('+', 'spammm\n'))
|
98
|
114
|
hunk.append((' ', 'world\n'))
|
|
115
|
+ hunk.append(('-', 'garb\n'))
|
|
116
|
+ hunk.append(('-', 'Again\n'))
|
|
117
|
+ hunk.append(('+', 'again\n'))
|
99
|
118
|
diff = cdiff.Diff(['header\n'], '--- old\n', '+++ new\n', [hunk])
|
100
|
119
|
return diff
|
101
|
120
|
|
|
@@ -109,10 +128,71 @@ class TestDiff(unittest.TestCase):
|
109
|
128
|
'\x1b[7m\x1b[31madd\x1b[0m\x1b[31m '
|
110
|
129
|
'\x1b[4m\x1b[31mchg\x1b[0m\x1b[31m bar\x1b[0m')
|
111
|
130
|
|
112
|
|
- def test_markup_traditional(self):
|
113
|
|
- diff = self._init_diff()
|
|
131
|
+ def test_markup_traditional_hunk_header(self):
|
|
132
|
+ hunk = cdiff.Hunk(['hunk header\n'], '@@ -0 +0 @@\n', (0, 0), (0, 0))
|
|
133
|
+ diff = cdiff.Diff([], '--- old\n', '+++ new\n', [hunk])
|
|
134
|
+
|
|
135
|
+ out = list(diff.markup_traditional())
|
|
136
|
+ self.assertEqual(len(out), 4)
|
|
137
|
+
|
|
138
|
+ self.assertEqual(out[0], '\x1b[33m--- old\n\x1b[0m')
|
|
139
|
+ self.assertEqual(out[1], '\x1b[33m+++ new\n\x1b[0m')
|
|
140
|
+ self.assertEqual(out[2], '\x1b[1;36mhunk header\n\x1b[0m')
|
|
141
|
+ self.assertEqual(out[3], '\x1b[1;34m@@ -0 +0 @@\n\x1b[0m')
|
|
142
|
+
|
|
143
|
+ def test_markup_traditional_old_changed(self):
|
|
144
|
+ hunk = cdiff.Hunk([], '@@ -1 +0,0 @@\n', (1, 0), (0, 0))
|
|
145
|
+ hunk.append(('-', 'spam\n'))
|
|
146
|
+ diff = cdiff.Diff([], '--- old\n', '+++ new\n', [hunk])
|
|
147
|
+
|
|
148
|
+ out = list(diff.markup_traditional())
|
|
149
|
+ self.assertEqual(len(out), 4)
|
|
150
|
+
|
|
151
|
+ self.assertEqual(out[0], '\x1b[33m--- old\n\x1b[0m')
|
|
152
|
+ self.assertEqual(out[1], '\x1b[33m+++ new\n\x1b[0m')
|
|
153
|
+ self.assertEqual(out[2], '\x1b[1;34m@@ -1 +0,0 @@\n\x1b[0m')
|
|
154
|
+ self.assertEqual(out[3], '\x1b[1;31m-spam\n\x1b[0m')
|
|
155
|
+
|
|
156
|
+ def test_markup_traditional_new_changed(self):
|
|
157
|
+ hunk = cdiff.Hunk([], '@@ -0,0 +1 @@\n', (0, 0), (1, 0))
|
|
158
|
+ hunk.append(('+', 'spam\n'))
|
|
159
|
+ diff = cdiff.Diff([], '--- old\n', '+++ new\n', [hunk])
|
|
160
|
+
|
|
161
|
+ out = list(diff.markup_traditional())
|
|
162
|
+ self.assertEqual(len(out), 4)
|
|
163
|
+
|
|
164
|
+ self.assertEqual(out[0], '\x1b[33m--- old\n\x1b[0m')
|
|
165
|
+ self.assertEqual(out[1], '\x1b[33m+++ new\n\x1b[0m')
|
|
166
|
+ self.assertEqual(out[2], '\x1b[1;34m@@ -0,0 +1 @@\n\x1b[0m')
|
|
167
|
+ self.assertEqual(out[3], '\x1b[1;32m+spam\n\x1b[0m')
|
|
168
|
+
|
|
169
|
+ def test_markup_traditional_both_changed(self):
|
|
170
|
+ hunk = cdiff.Hunk([], '@@ -1,2 +1,2 @@\n', (1, 2), (1, 2))
|
|
171
|
+ hunk.append(('-', 'hella\n'))
|
|
172
|
+ hunk.append(('+', 'hello\n'))
|
|
173
|
+ hunk.append((' ', 'common\n'))
|
|
174
|
+ diff = cdiff.Diff([], '--- old\n', '+++ new\n', [hunk])
|
|
175
|
+
|
114
|
176
|
out = list(diff.markup_traditional())
|
115
|
|
- self.assertEqual(len(out), 8)
|
|
177
|
+ self.assertEqual(len(out), 6)
|
|
178
|
+
|
|
179
|
+ self.assertEqual(out[0], '\x1b[33m--- old\n\x1b[0m')
|
|
180
|
+ self.assertEqual(out[1], '\x1b[33m+++ new\n\x1b[0m')
|
|
181
|
+ self.assertEqual(out[2], '\x1b[1;34m@@ -1,2 +1,2 @@\n\x1b[0m')
|
|
182
|
+ self.assertEqual(
|
|
183
|
+ out[3],
|
|
184
|
+ '\x1b[1;31m-\x1b[0m\x1b[31mhell'
|
|
185
|
+ '\x1b[4m\x1b[31ma\x1b[0m\x1b[31m\n\x1b[0m')
|
|
186
|
+ self.assertEqual(
|
|
187
|
+ out[4],
|
|
188
|
+ '\x1b[1;32m+\x1b[0m\x1b[32mhell'
|
|
189
|
+ '\x1b[4m\x1b[32mo\x1b[0m\x1b[32m\n\x1b[0m')
|
|
190
|
+ self.assertEqual(out[5], '\x1b[0m common\n\x1b[0m')
|
|
191
|
+
|
|
192
|
+ def test_markup_side_by_side_padded(self):
|
|
193
|
+ diff = self._init_diff()
|
|
194
|
+ out = list(diff.markup_side_by_side(7))
|
|
195
|
+ self.assertEqual(len(out), 10)
|
116
|
196
|
|
117
|
197
|
sys.stdout.write('\n')
|
118
|
198
|
for markup in out:
|
|
@@ -122,48 +202,85 @@ class TestDiff(unittest.TestCase):
|
122
|
202
|
self.assertEqual(out[1], '\x1b[33m--- old\n\x1b[0m')
|
123
|
203
|
self.assertEqual(out[2], '\x1b[33m+++ new\n\x1b[0m')
|
124
|
204
|
self.assertEqual(out[3], '\x1b[1;36mhunk header\n\x1b[0m')
|
125
|
|
- self.assertEqual(out[4], '\x1b[1;34m@@ -1,2 +1,2 @@\n\x1b[0m')
|
|
205
|
+ self.assertEqual(out[4], '\x1b[1;34m@@ -1,4 +1,4 @@\n\x1b[0m')
|
126
|
206
|
self.assertEqual(
|
127
|
207
|
out[5],
|
128
|
|
- '\x1b[1;31m-\x1b[0m\x1b[31mhell\x1b[4m'
|
129
|
|
- '\x1b[31ma\x1b[0m\x1b[31m\n\x1b[0m')
|
|
208
|
+ '\x1b[33m1\x1b[0m '
|
|
209
|
+ '\x1b[31m\x1b[7m\x1b[31mh\x1b[0m\x1b[31mhello\x1b[0m '
|
|
210
|
+ '\x1b[0m\x1b[33m1\x1b[0m '
|
|
211
|
+ '\x1b[32mhello\x1b[7m\x1b[32mo\x1b[0m\x1b[32m\x1b[0m\n')
|
130
|
212
|
self.assertEqual(
|
131
|
213
|
out[6],
|
132
|
|
- '\x1b[1;32m+\x1b[0m\x1b[32mhell\x1b[4m'
|
133
|
|
- '\x1b[32mo\x1b[0m\x1b[32m\n\x1b[0m')
|
134
|
|
- self.assertEqual(out[7], '\x1b[0m world\n\x1b[0m')
|
|
214
|
+ '\x1b[33m '
|
|
215
|
+ '\x1b[0m '
|
|
216
|
+ '\x1b[0m\x1b[33m2\x1b[0m '
|
|
217
|
+ '\x1b[1;32mspammm\x1b[0m\n')
|
|
218
|
+ self.assertEqual(
|
|
219
|
+ out[7],
|
|
220
|
+ '\x1b[33m2\x1b[0m '
|
|
221
|
+ '\x1b[0mworld\x1b[0m '
|
|
222
|
+ '\x1b[0m\x1b[33m3\x1b[0m '
|
|
223
|
+ '\x1b[0mworld\x1b[0m\n')
|
|
224
|
+ self.assertEqual(
|
|
225
|
+ out[8],
|
|
226
|
+ '\x1b[33m3\x1b[0m '
|
|
227
|
+ '\x1b[1;31mgarb\x1b[0m '
|
|
228
|
+ '\x1b[0m\x1b[33m '
|
|
229
|
+ '\x1b[0m \n')
|
|
230
|
+ self.assertEqual(
|
|
231
|
+ out[9],
|
|
232
|
+ '\x1b[33m4\x1b[0m '
|
|
233
|
+ '\x1b[31m\x1b[4m\x1b[31mA\x1b[0m\x1b[31mgain\x1b[0m '
|
|
234
|
+ '\x1b[0m\x1b[33m4\x1b[0m '
|
|
235
|
+ '\x1b[32m\x1b[4m\x1b[32ma\x1b[0m\x1b[32mgain\x1b[0m\n')
|
135
|
236
|
|
136
|
|
- def test_markup_side_by_side_padded(self):
|
|
237
|
+ def test_markup_side_by_side_neg_width(self):
|
137
|
238
|
diff = self._init_diff()
|
138
|
|
- out = list(diff.markup_side_by_side(6))
|
139
|
|
- self.assertEqual(len(out), 7)
|
140
|
|
-
|
141
|
|
- sys.stdout.write('\n')
|
142
|
|
- for markup in out:
|
143
|
|
- sys.stdout.write(markup)
|
|
239
|
+ out = list(diff.markup_side_by_side(-1))
|
|
240
|
+ self.assertEqual(len(out), 10)
|
144
|
241
|
|
145
|
242
|
self.assertEqual(out[0], '\x1b[36mheader\n\x1b[0m')
|
146
|
243
|
self.assertEqual(out[1], '\x1b[33m--- old\n\x1b[0m')
|
147
|
244
|
self.assertEqual(out[2], '\x1b[33m+++ new\n\x1b[0m')
|
148
|
245
|
self.assertEqual(out[3], '\x1b[1;36mhunk header\n\x1b[0m')
|
149
|
|
- self.assertEqual(out[4], '\x1b[1;34m@@ -1,2 +1,2 @@\n\x1b[0m')
|
|
246
|
+ self.assertEqual(out[4], '\x1b[1;34m@@ -1,4 +1,4 @@\n\x1b[0m')
|
150
|
247
|
self.assertEqual(
|
151
|
248
|
out[5],
|
152
|
249
|
'\x1b[33m1\x1b[0m '
|
153
|
|
- '\x1b[31mhell\x1b[4m\x1b[31ma\x1b[0m\x1b[31m\x1b[0m '
|
|
250
|
+ '\x1b[31m\x1b[7m\x1b[31mh\x1b[0m\x1b[31mhello\x1b[0m ' +
|
|
251
|
+ (' ' * 74) +
|
154
|
252
|
'\x1b[0m\x1b[33m1\x1b[0m '
|
155
|
|
- '\x1b[32mhell\x1b[4m\x1b[32mo\x1b[0m\x1b[32m\x1b[0m\n')
|
|
253
|
+ '\x1b[32mhello\x1b[7m\x1b[32mo\x1b[0m\x1b[32m\x1b[0m\n')
|
156
|
254
|
self.assertEqual(
|
157
|
255
|
out[6],
|
158
|
|
- '\x1b[33m2\x1b[0m '
|
159
|
|
- '\x1b[0mworld\x1b[0m '
|
|
256
|
+ '\x1b[33m '
|
|
257
|
+ '\x1b[0m ' + (' ' * 80) +
|
160
|
258
|
'\x1b[0m\x1b[33m2\x1b[0m '
|
|
259
|
+ '\x1b[1;32mspammm\x1b[0m\n')
|
|
260
|
+ self.assertEqual(
|
|
261
|
+ out[7],
|
|
262
|
+ '\x1b[33m2\x1b[0m '
|
|
263
|
+ '\x1b[0mworld\x1b[0m ' + (' ' * 75) +
|
|
264
|
+ '\x1b[0m\x1b[33m3\x1b[0m '
|
161
|
265
|
'\x1b[0mworld\x1b[0m\n')
|
|
266
|
+ self.assertEqual(
|
|
267
|
+ out[8],
|
|
268
|
+ '\x1b[33m3\x1b[0m '
|
|
269
|
+ '\x1b[1;31mgarb\x1b[0m '
|
|
270
|
+ '\x1b[0m\x1b[33m '
|
|
271
|
+ '\x1b[0m \n')
|
|
272
|
+ self.assertEqual(
|
|
273
|
+ out[9],
|
|
274
|
+ '\x1b[33m4\x1b[0m '
|
|
275
|
+ '\x1b[31m\x1b[4m\x1b[31mA\x1b[0m\x1b[31mgain\x1b[0m ' +
|
|
276
|
+ (' ' * 75) +
|
|
277
|
+ '\x1b[0m\x1b[33m4\x1b[0m '
|
|
278
|
+ '\x1b[32m\x1b[4m\x1b[32ma\x1b[0m\x1b[32mgain\x1b[0m\n')
|
162
|
279
|
|
163
|
280
|
def test_markup_side_by_side_off_by_one(self):
|
164
|
281
|
diff = self._init_diff()
|
165
|
|
- out = list(diff.markup_side_by_side(5))
|
166
|
|
- self.assertEqual(len(out), 7)
|
|
282
|
+ out = list(diff.markup_side_by_side(6))
|
|
283
|
+ self.assertEqual(len(out), 10)
|
167
|
284
|
|
168
|
285
|
sys.stdout.write('\n')
|
169
|
286
|
for markup in out:
|
|
@@ -173,24 +290,41 @@ class TestDiff(unittest.TestCase):
|
173
|
290
|
self.assertEqual(out[1], '\x1b[33m--- old\n\x1b[0m')
|
174
|
291
|
self.assertEqual(out[2], '\x1b[33m+++ new\n\x1b[0m')
|
175
|
292
|
self.assertEqual(out[3], '\x1b[1;36mhunk header\n\x1b[0m')
|
176
|
|
- self.assertEqual(out[4], '\x1b[1;34m@@ -1,2 +1,2 @@\n\x1b[0m')
|
|
293
|
+ self.assertEqual(out[4], '\x1b[1;34m@@ -1,4 +1,4 @@\n\x1b[0m')
|
177
|
294
|
self.assertEqual(
|
178
|
295
|
out[5],
|
179
|
296
|
'\x1b[33m1\x1b[0m '
|
180
|
|
- '\x1b[31mhell\x1b[4m\x1b[31ma\x1b[0m '
|
|
297
|
+ '\x1b[31m\x1b[7m\x1b[31mh\x1b[0m\x1b[31mhello\x1b[0m '
|
181
|
298
|
'\x1b[0m\x1b[33m1\x1b[0m '
|
182
|
|
- '\x1b[32mhell\x1b[4m\x1b[32mo\x1b[0m\n')
|
|
299
|
+ '\x1b[32mhello\x1b[7m\x1b[32mo\x1b[0m\n')
|
183
|
300
|
self.assertEqual(
|
184
|
301
|
out[6],
|
185
|
|
- '\x1b[33m2\x1b[0m '
|
186
|
|
- '\x1b[0mworld\x1b[0m '
|
|
302
|
+ '\x1b[33m \x1b[0m '
|
187
|
303
|
'\x1b[0m\x1b[33m2\x1b[0m '
|
|
304
|
+ '\x1b[1;32mspammm\x1b[0m\n')
|
|
305
|
+ self.assertEqual(
|
|
306
|
+ out[7],
|
|
307
|
+ '\x1b[33m2\x1b[0m '
|
|
308
|
+ '\x1b[0mworld\x1b[0m '
|
|
309
|
+ '\x1b[0m\x1b[33m3\x1b[0m '
|
188
|
310
|
'\x1b[0mworld\x1b[0m\n')
|
|
311
|
+ self.assertEqual(
|
|
312
|
+ out[8],
|
|
313
|
+ '\x1b[33m3\x1b[0m '
|
|
314
|
+ '\x1b[1;31mgarb\x1b[0m '
|
|
315
|
+ '\x1b[0m\x1b[33m '
|
|
316
|
+ '\x1b[0m \n')
|
|
317
|
+ self.assertEqual(
|
|
318
|
+ out[9],
|
|
319
|
+ '\x1b[33m4\x1b[0m '
|
|
320
|
+ '\x1b[31m\x1b[4m\x1b[31mA\x1b[0m\x1b[31mgain\x1b[0m '
|
|
321
|
+ '\x1b[0m\x1b[33m4\x1b[0m '
|
|
322
|
+ '\x1b[32m\x1b[4m\x1b[32ma\x1b[0m\x1b[32mgain\x1b[0m\n')
|
189
|
323
|
|
190
|
324
|
def test_markup_side_by_side_wrapped(self):
|
191
|
325
|
diff = self._init_diff()
|
192
|
|
- out = list(diff.markup_side_by_side(4))
|
193
|
|
- self.assertEqual(len(out), 7)
|
|
326
|
+ out = list(diff.markup_side_by_side(5))
|
|
327
|
+ self.assertEqual(len(out), 10)
|
194
|
328
|
|
195
|
329
|
sys.stdout.write('\n')
|
196
|
330
|
for markup in out:
|
|
@@ -200,19 +334,37 @@ class TestDiff(unittest.TestCase):
|
200
|
334
|
self.assertEqual(out[1], '\x1b[33m--- old\n\x1b[0m')
|
201
|
335
|
self.assertEqual(out[2], '\x1b[33m+++ new\n\x1b[0m')
|
202
|
336
|
self.assertEqual(out[3], '\x1b[1;36mhunk header\n\x1b[0m')
|
203
|
|
- self.assertEqual(out[4], '\x1b[1;34m@@ -1,2 +1,2 @@\n\x1b[0m')
|
|
337
|
+ self.assertEqual(out[4], '\x1b[1;34m@@ -1,4 +1,4 @@\n\x1b[0m')
|
204
|
338
|
self.assertEqual(
|
205
|
339
|
out[5],
|
206
|
340
|
'\x1b[33m1\x1b[0m '
|
207
|
|
- '\x1b[31mhel\x1b[0m\x1b[1;35m>\x1b[0m '
|
|
341
|
+ '\x1b[31m\x1b[7m\x1b[31mh\x1b[0m\x1b[31mhel\x1b[0m\x1b[1;35m>\x1b[0m '
|
208
|
342
|
'\x1b[0m\x1b[33m1\x1b[0m '
|
209
|
|
- '\x1b[32mhel\x1b[0m\x1b[1;35m>\x1b[0m\n')
|
|
343
|
+ '\x1b[32mhell\x1b[0m\x1b[1;35m>\x1b[0m\n')
|
210
|
344
|
self.assertEqual(
|
211
|
345
|
out[6],
|
212
|
|
- '\x1b[33m2\x1b[0m '
|
213
|
|
- '\x1b[0mwor\x1b[0m\x1b[1;35m>\x1b[0m '
|
|
346
|
+ '\x1b[33m \x1b[0m '
|
214
|
347
|
'\x1b[0m\x1b[33m2\x1b[0m '
|
215
|
|
- '\x1b[0mwor\x1b[0m\x1b[1;35m>\x1b[0m\n')
|
|
348
|
+ ''
|
|
349
|
+ '\x1b[1;32mspam\x1b[0m\x1b[1;35m>\x1b[0m\n')
|
|
350
|
+ self.assertEqual(
|
|
351
|
+ out[7],
|
|
352
|
+ '\x1b[33m2\x1b[0m '
|
|
353
|
+ '\x1b[0mworld\x1b[0m '
|
|
354
|
+ '\x1b[0m\x1b[33m3\x1b[0m '
|
|
355
|
+ '\x1b[0mworld\x1b[0m\n')
|
|
356
|
+ self.assertEqual(
|
|
357
|
+ out[8],
|
|
358
|
+ '\x1b[33m3\x1b[0m '
|
|
359
|
+ '\x1b[1;31mgarb\x1b[0m '
|
|
360
|
+ '\x1b[0m\x1b[33m '
|
|
361
|
+ '\x1b[0m \n')
|
|
362
|
+ self.assertEqual(
|
|
363
|
+ out[9],
|
|
364
|
+ '\x1b[33m4\x1b[0m '
|
|
365
|
+ '\x1b[31m\x1b[4m\x1b[31mA\x1b[0m\x1b[31mgain\x1b[0m '
|
|
366
|
+ '\x1b[0m\x1b[33m4\x1b[0m '
|
|
367
|
+ '\x1b[32m\x1b[4m\x1b[32ma\x1b[0m\x1b[32mgain\x1b[0m\n')
|
216
|
368
|
|
217
|
369
|
|
218
|
370
|
class TestUdiff(unittest.TestCase):
|
|
@@ -294,6 +446,19 @@ spam
|
294
|
446
|
stream = cdiff.PatchStream(Sequential(items))
|
295
|
447
|
self.assertRaises(RuntimeError, cdiff.DiffParser, stream)
|
296
|
448
|
|
|
449
|
+ def test_parse_invalid_hunk_meta(self):
|
|
450
|
+ patch = r"""\
|
|
451
|
+spam
|
|
452
|
+--- a
|
|
453
|
++++ b
|
|
454
|
+spam
|
|
455
|
+@@ -a,a +0 @@
|
|
456
|
+"""
|
|
457
|
+ items = patch.splitlines(True)
|
|
458
|
+ stream = cdiff.PatchStream(Sequential(items))
|
|
459
|
+ parser = cdiff.DiffParser(stream)
|
|
460
|
+ self.assertRaises(RuntimeError, list, parser.get_diff_generator())
|
|
461
|
+
|
297
|
462
|
def test_parse_dangling_header(self):
|
298
|
463
|
patch = r"""\
|
299
|
464
|
--- a
|
|
@@ -307,7 +472,7 @@ spam
|
307
|
472
|
items = patch.splitlines(True)
|
308
|
473
|
stream = cdiff.PatchStream(Sequential(items))
|
309
|
474
|
parser = cdiff.DiffParser(stream)
|
310
|
|
- self.assertRaises(RuntimeError, list, parser._parse())
|
|
475
|
+ self.assertRaises(RuntimeError, list, parser.get_diff_generator())
|
311
|
476
|
|
312
|
477
|
def test_parse_missing_new_path(self):
|
313
|
478
|
patch = r"""\
|
|
@@ -322,7 +487,7 @@ spam
|
322
|
487
|
items = patch.splitlines(True)
|
323
|
488
|
stream = cdiff.PatchStream(Sequential(items))
|
324
|
489
|
parser = cdiff.DiffParser(stream)
|
325
|
|
- self.assertRaises(AssertionError, list, parser._parse())
|
|
490
|
+ self.assertRaises(AssertionError, list, parser.get_diff_generator())
|
326
|
491
|
|
327
|
492
|
def test_parse_missing_hunk_meta(self):
|
328
|
493
|
patch = r"""\
|
|
@@ -338,7 +503,7 @@ spam
|
338
|
503
|
items = patch.splitlines(True)
|
339
|
504
|
stream = cdiff.PatchStream(Sequential(items))
|
340
|
505
|
parser = cdiff.DiffParser(stream)
|
341
|
|
- self.assertRaises(AssertionError, list, parser._parse())
|
|
506
|
+ self.assertRaises(AssertionError, list, parser.get_diff_generator())
|
342
|
507
|
|
343
|
508
|
def test_parse_missing_hunk_list(self):
|
344
|
509
|
patch = r"""\
|
|
@@ -355,7 +520,7 @@ spam
|
355
|
520
|
items = patch.splitlines(True)
|
356
|
521
|
stream = cdiff.PatchStream(Sequential(items))
|
357
|
522
|
parser = cdiff.DiffParser(stream)
|
358
|
|
- self.assertRaises(AssertionError, list, parser._parse())
|
|
523
|
+ self.assertRaises(AssertionError, list, parser.get_diff_generator())
|
359
|
524
|
|
360
|
525
|
def test_parse_only_in_dir(self):
|
361
|
526
|
patch = r"""\
|
|
@@ -377,7 +542,7 @@ Only in foo: foo
|
377
|
542
|
stream = cdiff.PatchStream(Sequential(items))
|
378
|
543
|
parser = cdiff.DiffParser(stream)
|
379
|
544
|
|
380
|
|
- out = list(parser._parse())
|
|
545
|
+ out = list(parser.get_diff_generator())
|
381
|
546
|
self.assertEqual(len(out), 3)
|
382
|
547
|
self.assertEqual(len(out[1]._hunks), 0)
|
383
|
548
|
self.assertEqual(out[1]._headers, ['Only in foo: foo\n'])
|
|
@@ -398,7 +563,7 @@ Only in foo: foo
|
398
|
563
|
stream = cdiff.PatchStream(Sequential(items))
|
399
|
564
|
parser = cdiff.DiffParser(stream)
|
400
|
565
|
|
401
|
|
- out = list(parser._parse())
|
|
566
|
+ out = list(parser.get_diff_generator())
|
402
|
567
|
self.assertEqual(len(out), 2)
|
403
|
568
|
self.assertEqual(len(out[1]._hunks), 0)
|
404
|
569
|
self.assertEqual(out[1]._headers, ['Only in foo: foo\n'])
|
|
@@ -423,7 +588,7 @@ Binary files a/1.pdf and b/1.pdf differ
|
423
|
588
|
stream = cdiff.PatchStream(Sequential(items))
|
424
|
589
|
parser = cdiff.DiffParser(stream)
|
425
|
590
|
|
426
|
|
- out = list(parser._parse())
|
|
591
|
+ out = list(parser.get_diff_generator())
|
427
|
592
|
self.assertEqual(len(out), 3)
|
428
|
593
|
self.assertEqual(len(out[1]._hunks), 0)
|
429
|
594
|
self.assertEqual(out[1]._old_path, '')
|
|
@@ -459,7 +624,7 @@ index 529e8a3..ad71921 100755
|
459
|
624
|
stream = cdiff.PatchStream(Sequential(items))
|
460
|
625
|
parser = cdiff.DiffParser(stream)
|
461
|
626
|
|
462
|
|
- out = list(parser._parse())
|
|
627
|
+ out = list(parser.get_diff_generator())
|
463
|
628
|
self.assertEqual(len(out), 3)
|
464
|
629
|
self.assertEqual(len(out[1]._hunks), 0)
|
465
|
630
|
self.assertEqual(out[1]._old_path, '')
|
|
@@ -484,7 +649,7 @@ Added: svn:keywords
|
484
|
649
|
items = patch.splitlines(True)
|
485
|
650
|
stream = cdiff.PatchStream(Sequential(items))
|
486
|
651
|
parser = cdiff.DiffParser(stream)
|
487
|
|
- out = list(parser._parse())
|
|
652
|
+ out = list(parser.get_diff_generator())
|
488
|
653
|
self.assertEqual(len(out), 1)
|
489
|
654
|
self.assertEqual(len(out[0]._hunks), 2)
|
490
|
655
|
|