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