]>
Commit | Line | Data |
---|---|---|
1 | #!/bin/sh | |
2 | ||
3 | test_description='basic rebase topology tests' | |
4 | . ./test-lib.sh | |
5 | . "$TEST_DIRECTORY"/lib-rebase.sh | |
6 | ||
7 | # a---b---c | |
8 | # \ | |
9 | # d---e | |
10 | test_expect_success 'setup' ' | |
11 | test_commit a && | |
12 | test_commit b && | |
13 | test_commit c && | |
14 | git checkout b && | |
15 | test_commit d && | |
16 | test_commit e | |
17 | ' | |
18 | ||
19 | test_run_rebase () { | |
20 | result=$1 | |
21 | shift | |
22 | test_expect_$result "simple rebase $*" " | |
23 | reset_rebase && | |
24 | git rebase $* c e && | |
25 | test_cmp_rev c HEAD~2 && | |
26 | test_linear_range 'd e' c.. | |
27 | " | |
28 | } | |
29 | test_run_rebase success --apply | |
30 | test_run_rebase success -m | |
31 | test_run_rebase success -i | |
32 | ||
33 | test_expect_success 'setup branches and remote tracking' ' | |
34 | git tag -l >tags && | |
35 | for tag in $(cat tags) | |
36 | do | |
37 | git branch branch-$tag $tag || return 1 | |
38 | done && | |
39 | git remote add origin "file://$PWD" && | |
40 | git fetch origin | |
41 | ' | |
42 | ||
43 | test_run_rebase () { | |
44 | result=$1 | |
45 | shift | |
46 | test_expect_$result "rebase $* is no-op if upstream is an ancestor" " | |
47 | reset_rebase && | |
48 | git rebase $* b e && | |
49 | test_cmp_rev e HEAD | |
50 | " | |
51 | } | |
52 | test_run_rebase success --apply | |
53 | test_run_rebase success -m | |
54 | test_run_rebase success -i | |
55 | ||
56 | test_run_rebase () { | |
57 | result=$1 | |
58 | shift | |
59 | test_expect_$result "rebase $* -f rewrites even if upstream is an ancestor" " | |
60 | reset_rebase && | |
61 | git rebase $* -f b e && | |
62 | test_cmp_rev ! e HEAD && | |
63 | test_cmp_rev b HEAD~2 && | |
64 | test_linear_range 'd e' b.. | |
65 | " | |
66 | } | |
67 | test_run_rebase success --apply | |
68 | test_run_rebase success --fork-point | |
69 | test_run_rebase success -m | |
70 | test_run_rebase success -i | |
71 | ||
72 | test_run_rebase () { | |
73 | result=$1 | |
74 | shift | |
75 | test_expect_$result "rebase $* -f rewrites even if remote upstream is an ancestor" " | |
76 | reset_rebase && | |
77 | git rebase $* -f branch-b branch-e && | |
78 | test_cmp_rev ! branch-e origin/branch-e && | |
79 | test_cmp_rev branch-b HEAD~2 && | |
80 | test_linear_range 'd e' branch-b.. | |
81 | " | |
82 | } | |
83 | test_run_rebase success --apply | |
84 | test_run_rebase success --fork-point | |
85 | test_run_rebase success -m | |
86 | test_run_rebase success -i | |
87 | ||
88 | test_run_rebase () { | |
89 | result=$1 | |
90 | shift | |
91 | test_expect_$result "rebase $* fast-forwards from ancestor of upstream" " | |
92 | reset_rebase && | |
93 | git rebase $* e b && | |
94 | test_cmp_rev e HEAD | |
95 | " | |
96 | } | |
97 | test_run_rebase success --apply | |
98 | test_run_rebase success --fork-point | |
99 | test_run_rebase success -m | |
100 | test_run_rebase success -i | |
101 | ||
102 | # f | |
103 | # / | |
104 | # a---b---c---g---h | |
105 | # \ | |
106 | # d---gp--i | |
107 | # | |
108 | # gp = cherry-picked g | |
109 | # h = reverted g | |
110 | # | |
111 | # Reverted patches are there for tests to be able to check if a commit | |
112 | # that introduced the same change as another commit is | |
113 | # dropped. Without reverted commits, we could get false positives | |
114 | # because applying the patch succeeds, but simply results in no | |
115 | # changes. | |
116 | test_expect_success 'setup of linear history for range selection tests' ' | |
117 | git checkout c && | |
118 | test_commit g && | |
119 | revert h g && | |
120 | git checkout d && | |
121 | cherry_pick gp g && | |
122 | test_commit i && | |
123 | git checkout b && | |
124 | test_commit f | |
125 | ' | |
126 | ||
127 | test_run_rebase () { | |
128 | result=$1 | |
129 | shift | |
130 | test_expect_$result "rebase $* drops patches in upstream" " | |
131 | reset_rebase && | |
132 | git rebase $* h i && | |
133 | test_cmp_rev h HEAD~2 && | |
134 | test_linear_range 'd i' h.. | |
135 | " | |
136 | } | |
137 | test_run_rebase success --apply | |
138 | test_run_rebase success -m | |
139 | test_run_rebase success -i | |
140 | ||
141 | test_run_rebase () { | |
142 | result=$1 | |
143 | shift | |
144 | test_expect_$result "rebase $* can drop last patch if in upstream" " | |
145 | reset_rebase && | |
146 | git rebase $* h gp && | |
147 | test_cmp_rev h HEAD^ && | |
148 | test_linear_range 'd' h.. | |
149 | " | |
150 | } | |
151 | test_run_rebase success --apply | |
152 | test_run_rebase success -m | |
153 | test_run_rebase success -i | |
154 | ||
155 | test_run_rebase () { | |
156 | result=$1 | |
157 | shift | |
158 | test_expect_$result "rebase $* --onto drops patches in upstream" " | |
159 | reset_rebase && | |
160 | git rebase $* --onto f h i && | |
161 | test_cmp_rev f HEAD~2 && | |
162 | test_linear_range 'd i' f.. | |
163 | " | |
164 | } | |
165 | test_run_rebase success --apply | |
166 | test_run_rebase success -m | |
167 | test_run_rebase success -i | |
168 | ||
169 | test_run_rebase () { | |
170 | result=$1 | |
171 | shift | |
172 | test_expect_$result "rebase $* --onto does not drop patches in onto" " | |
173 | reset_rebase && | |
174 | git rebase $* --onto h f i && | |
175 | test_cmp_rev h HEAD~3 && | |
176 | test_linear_range 'd gp i' h.. | |
177 | " | |
178 | } | |
179 | test_run_rebase success --apply | |
180 | test_run_rebase success -m | |
181 | test_run_rebase success -i | |
182 | ||
183 | # a---b---c---j! | |
184 | # \ | |
185 | # d---k!--l | |
186 | # | |
187 | # ! = empty | |
188 | test_expect_success 'setup of linear history for empty commit tests' ' | |
189 | git checkout c && | |
190 | make_empty j && | |
191 | git checkout d && | |
192 | make_empty k && | |
193 | test_commit l | |
194 | ' | |
195 | ||
196 | test_run_rebase () { | |
197 | result=$1 | |
198 | shift | |
199 | test_expect_$result "rebase $* keeps begin-empty commits" " | |
200 | reset_rebase && | |
201 | git rebase $* j l && | |
202 | test_cmp_rev c HEAD~4 && | |
203 | test_linear_range 'j d k l' c.. | |
204 | " | |
205 | } | |
206 | test_run_rebase failure --apply | |
207 | test_run_rebase success -m | |
208 | test_run_rebase success -i | |
209 | ||
210 | test_run_rebase () { | |
211 | result=$1 | |
212 | shift | |
213 | test_expect_$result "rebase $* --no-keep-empty drops begin-empty commits" " | |
214 | reset_rebase && | |
215 | git rebase $* --no-keep-empty c l && | |
216 | test_cmp_rev c HEAD~2 && | |
217 | test_linear_range 'd l' c.. | |
218 | " | |
219 | } | |
220 | test_run_rebase success -m | |
221 | test_run_rebase success -i | |
222 | ||
223 | test_run_rebase () { | |
224 | result=$1 | |
225 | shift | |
226 | test_expect_$result "rebase $* --keep-empty keeps empty even if already in upstream" " | |
227 | reset_rebase && | |
228 | git rebase $* --keep-empty j l && | |
229 | test_cmp_rev j HEAD~3 && | |
230 | test_linear_range 'd k l' j.. | |
231 | " | |
232 | } | |
233 | test_run_rebase success -m | |
234 | test_run_rebase success -i | |
235 | test_run_rebase success --rebase-merges | |
236 | ||
237 | # m | |
238 | # / | |
239 | # a---b---c---g | |
240 | # | |
241 | # x---y---bp | |
242 | # | |
243 | # bp = cherry-picked b | |
244 | # m = reverted b | |
245 | # | |
246 | # Reverted patches are there for tests to be able to check if a commit | |
247 | # that introduced the same change as another commit is | |
248 | # dropped. Without reverted commits, we could get false positives | |
249 | # because applying the patch succeeds, but simply results in no | |
250 | # changes. | |
251 | test_expect_success 'setup of linear history for test involving root' ' | |
252 | git checkout b && | |
253 | revert m b && | |
254 | git checkout --orphan disjoint && | |
255 | git rm -rf . && | |
256 | test_commit x && | |
257 | test_commit y && | |
258 | cherry_pick bp b | |
259 | ' | |
260 | ||
261 | test_run_rebase () { | |
262 | result=$1 | |
263 | shift | |
264 | test_expect_$result "rebase $* --onto --root" " | |
265 | reset_rebase && | |
266 | git rebase $* --onto c --root y && | |
267 | test_cmp_rev c HEAD~2 && | |
268 | test_linear_range 'x y' c.. | |
269 | " | |
270 | } | |
271 | test_run_rebase success --apply | |
272 | test_run_rebase success -m | |
273 | test_run_rebase success -i | |
274 | ||
275 | test_run_rebase () { | |
276 | result=$1 | |
277 | shift | |
278 | test_expect_$result "rebase $* without --onto --root with disjoint history" " | |
279 | reset_rebase && | |
280 | git rebase $* c y && | |
281 | test_cmp_rev c HEAD~2 && | |
282 | test_linear_range 'x y' c.. | |
283 | " | |
284 | } | |
285 | test_run_rebase success --apply | |
286 | test_run_rebase success -m | |
287 | test_run_rebase success -i | |
288 | ||
289 | test_run_rebase () { | |
290 | result=$1 | |
291 | shift | |
292 | test_expect_$result "rebase $* --onto --root drops patch in onto" " | |
293 | reset_rebase && | |
294 | git rebase $* --onto m --root bp && | |
295 | test_cmp_rev m HEAD~2 && | |
296 | test_linear_range 'x y' m.. | |
297 | " | |
298 | } | |
299 | test_run_rebase success --apply | |
300 | test_run_rebase success -m | |
301 | test_run_rebase success -i | |
302 | ||
303 | test_run_rebase () { | |
304 | result=$1 | |
305 | shift | |
306 | test_expect_$result "rebase $* --onto --root with merge-base does not go to root" " | |
307 | reset_rebase && | |
308 | git rebase $* --onto m --root g && | |
309 | test_cmp_rev m HEAD~2 && | |
310 | test_linear_range 'c g' m.. | |
311 | " | |
312 | } | |
313 | ||
314 | test_run_rebase success --apply | |
315 | test_run_rebase success -m | |
316 | test_run_rebase success -i | |
317 | ||
318 | test_run_rebase () { | |
319 | result=$1 | |
320 | shift | |
321 | test_expect_$result "rebase $* without --onto --root with disjoint history drops patch in onto" " | |
322 | reset_rebase && | |
323 | git rebase $* m bp && | |
324 | test_cmp_rev m HEAD~2 && | |
325 | test_linear_range 'x y' m.. | |
326 | " | |
327 | } | |
328 | test_run_rebase success --apply | |
329 | test_run_rebase success -m | |
330 | test_run_rebase success -i | |
331 | ||
332 | test_run_rebase () { | |
333 | result=$1 | |
334 | shift | |
335 | test_expect_$result "rebase $* --root on linear history is a no-op" " | |
336 | reset_rebase && | |
337 | git rebase $* --root c && | |
338 | test_cmp_rev c HEAD | |
339 | " | |
340 | } | |
341 | test_run_rebase success '' | |
342 | test_run_rebase success -m | |
343 | test_run_rebase success -i | |
344 | ||
345 | test_run_rebase () { | |
346 | result=$1 | |
347 | shift | |
348 | test_expect_$result "rebase $* -f --root on linear history causes re-write" " | |
349 | reset_rebase && | |
350 | git rebase $* -f --root c && | |
351 | test_cmp_rev ! a HEAD~2 && | |
352 | test_linear_range 'a b c' HEAD | |
353 | " | |
354 | } | |
355 | test_run_rebase success '' | |
356 | test_run_rebase success -m | |
357 | test_run_rebase success -i | |
358 | ||
359 | test_done |