op public repos

Blob

Date:: Fri Apr 14 12:15:45 2023 UTC
Message:: when aborting rebase/histedit/merge, unlink files added by merged changes Otherwise we leave unversioned files behind in the work tree which may interfere with new attempts to rebase or merge the changes again. Problem found by + ok naddy@
Actions:: History | Blame | Raw File
1 #!/bin/sh
2 #
3 # Copyright (c) 2019, 2020 Stefan Sperling <stsp@openbsd.org>
4 #
5 # Permission to use, copy, modify, and distribute this software for any
6 # purpose with or without fee is hereby granted, provided that the above
7 # copyright notice and this permission notice appear in all copies.
8 #
9 # THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
10 # WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
11 # MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
12 # ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
13 # WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
14 # ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
15 # OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
16 
17 . ./common.sh
18 
19 test_rebase_basic() {
20 	local testroot=`test_init rebase_basic`
21 	local commit0=`git_show_head $testroot/repo`
22 	local commit0_author_time=`git_show_author_time $testroot/repo`
23 
24 	(cd $testroot/repo && git checkout -q -b newbranch)
25 	echo "modified delta on branch" > $testroot/repo/gamma/delta
26 	git_commit $testroot/repo -m "committing to delta on newbranch"
27 
28 	echo "modified alpha on branch" > $testroot/repo/alpha
29 	(cd $testroot/repo && git rm -q beta)
30 	echo "new file on branch" > $testroot/repo/epsilon/new
31 	(cd $testroot/repo && git add epsilon/new)
32 	git_commit $testroot/repo -m "committing more changes on newbranch"
33 
34 	local orig_commit1=`git_show_parent_commit $testroot/repo`
35 	local orig_commit2=`git_show_head $testroot/repo`
36 	local orig_author_time2=`git_show_author_time $testroot/repo`
37 
38 	(cd $testroot/repo && git checkout -q master)
39 	echo "modified zeta on master" > $testroot/repo/epsilon/zeta
40 	git_commit $testroot/repo -m "committing to zeta on master"
41 	local master_commit=`git_show_head $testroot/repo`
42 
43 	got checkout $testroot/repo $testroot/wt > /dev/null
44 	ret=$?
45 	if [ $ret -ne 0 ]; then
46 		test_done "$testroot" "$ret"
47 		return 1
48 	fi
49 
50 	(cd $testroot/wt && got rebase newbranch > $testroot/stdout)
51 
52 	(cd $testroot/repo && git checkout -q newbranch)
53 	local new_commit1=`git_show_parent_commit $testroot/repo`
54 	local new_commit2=`git_show_head $testroot/repo`
55 	local new_author_time2=`git_show_author_time $testroot/repo`
56 
57 	local short_orig_commit1=`trim_obj_id 28 $orig_commit1`
58 	local short_orig_commit2=`trim_obj_id 28 $orig_commit2`
59 	local short_new_commit1=`trim_obj_id 28 $new_commit1`
60 	local short_new_commit2=`trim_obj_id 28 $new_commit2`
61 
62 	echo "G  gamma/delta" >> $testroot/stdout.expected
63 	echo -n "$short_orig_commit1 -> $short_new_commit1" \
64 		>> $testroot/stdout.expected
65 	echo ": committing to delta on newbranch" >> $testroot/stdout.expected
66 	echo "G  alpha" >> $testroot/stdout.expected
67 	echo "D  beta" >> $testroot/stdout.expected
68 	echo "A  epsilon/new" >> $testroot/stdout.expected
69 	echo -n "$short_orig_commit2 -> $short_new_commit2" \
70 		>> $testroot/stdout.expected
71 	echo ": committing more changes on newbranch" \
72 		>> $testroot/stdout.expected
73 	echo "Switching work tree to refs/heads/newbranch" \
74 		>> $testroot/stdout.expected
75 
76 	cmp -s $testroot/stdout.expected $testroot/stdout
77 	ret=$?
78 	if [ $ret -ne 0 ]; then
79 		diff -u $testroot/stdout.expected $testroot/stdout
80 		test_done "$testroot" "$ret"
81 		return 1
82 	fi
83 
84 	echo "modified delta on branch" > $testroot/content.expected
85 	cat $testroot/wt/gamma/delta > $testroot/content
86 	cmp -s $testroot/content.expected $testroot/content
87 	ret=$?
88 	if [ $ret -ne 0 ]; then
89 		diff -u $testroot/content.expected $testroot/content
90 		test_done "$testroot" "$ret"
91 		return 1
92 	fi
93 
94 	echo "modified alpha on branch" > $testroot/content.expected
95 	cat $testroot/wt/alpha > $testroot/content
96 	cmp -s $testroot/content.expected $testroot/content
97 	ret=$?
98 	if [ $ret -ne 0 ]; then
99 		diff -u $testroot/content.expected $testroot/content
100 		test_done "$testroot" "$ret"
101 		return 1
102 	fi
103 
104 	if [ -e $testroot/wt/beta ]; then
105 		echo "removed file beta still exists on disk" >&2
106 		test_done "$testroot" "1"
107 		return 1
108 	fi
109 
110 	echo "new file on branch" > $testroot/content.expected
111 	cat $testroot/wt/epsilon/new > $testroot/content
112 	cmp -s $testroot/content.expected $testroot/content
113 	ret=$?
114 	if [ $ret -ne 0 ]; then
115 		diff -u $testroot/content.expected $testroot/content
116 		test_done "$testroot" "$ret"
117 		return 1
118 	fi
119 
120 	(cd $testroot/wt && got status > $testroot/stdout)
121 
122 	echo -n > $testroot/stdout.expected
123 	cmp -s $testroot/stdout.expected $testroot/stdout
124 	ret=$?
125 	if [ $ret -ne 0 ]; then
126 		diff -u $testroot/stdout.expected $testroot/stdout
127 		test_done "$testroot" "$ret"
128 		return 1
129 	fi
130 
131 	(cd $testroot/wt && got log -l3 | grep ^commit > $testroot/stdout)
132 	echo "commit $new_commit2 (newbranch)" > $testroot/stdout.expected
133 	echo "commit $new_commit1" >> $testroot/stdout.expected
134 	echo "commit $master_commit (master)" >> $testroot/stdout.expected
135 	cmp -s $testroot/stdout.expected $testroot/stdout
136 	ret=$?
137 	if [ $ret -ne 0 ]; then
138 		diff -u $testroot/stdout.expected $testroot/stdout
139 		test_done "$testroot" "$ret"
140 		return 1
141 	fi
142 
143 	(cd $testroot/wt && got update > $testroot/stdout)
144 
145 	echo 'Already up-to-date' > $testroot/stdout.expected
146 	cmp -s $testroot/stdout.expected $testroot/stdout
147 	ret=$?
148 	if [ $ret -ne 0 ]; then
149 		diff -u $testroot/stdout.expected $testroot/stdout
150 		test_done "$testroot" "$ret"
151 		return 1
152 	fi
153 
154 	# We should have a backup of old commits
155 	(cd $testroot/repo && got rebase -l > $testroot/stdout)
156 	d_orig2=`date -u -r $orig_author_time2 +"%a %b %e %X %Y UTC"`
157 	d_new2=`date -u -r $new_author_time2 +"%G-%m-%d"`
158 	d_0=`date -u -r $commit0_author_time +"%G-%m-%d"`
159 	cat > $testroot/stdout.expected <<EOF
160 -----------------------------------------------
161 commit $orig_commit2 (formerly newbranch)
162 from: $GOT_AUTHOR
163 date: $d_orig2
164  
165  committing more changes on newbranch
166  
167 has become commit $new_commit2 (newbranch)
168  $d_new2 $GOT_AUTHOR_11  committing more changes on newbranch
169 history forked at $commit0
170  $d_0 $GOT_AUTHOR_11  adding the test tree
171 EOF
172 	cmp -s $testroot/stdout.expected $testroot/stdout
173 	ret=$?
174 	if [ $ret -ne 0 ]; then
175 		diff -u $testroot/stdout.expected $testroot/stdout
176 		test_done "$testroot" "$ret"
177 		return 1
178 	fi
179 
180 	# Asking for backups of a branch which has none should yield an error
181 	(cd $testroot/repo && got rebase -l master \
182 		> $testroot/stdout 2> $testroot/stderr)
183 	echo -n > $testroot/stdout.expected
184 	echo "got: refs/got/backup/rebase/master/: no such reference found" \
185 		> $testroot/stderr.expected
186 	cmp -s $testroot/stdout.expected $testroot/stdout
187 	ret=$?
188 	if [ $ret -ne 0 ]; then
189 		diff -u $testroot/stdout.expected $testroot/stdout
190 		test_done "$testroot" "$ret"
191 		return 1
192 	fi
193 	cmp -s $testroot/stderr.expected $testroot/stderr
194 	ret=$?
195 	if [ $ret -ne 0 ]; then
196 		diff -u $testroot/stderr.expected $testroot/stderr
197 		test_done "$testroot" "$ret"
198 		return 1
199 	fi
200 
201 	# Delete all backup refs
202 	(cd $testroot/repo && got rebase -X \
203 		> $testroot/stdout 2> $testroot/stderr)
204 	echo -n "Deleted refs/got/backup/rebase/newbranch/$new_commit2: " \
205 		> $testroot/stdout.expected
206 	echo "$orig_commit2" >> $testroot/stdout.expected
207 	echo -n > $testroot/stderr.expected
208 	cmp -s $testroot/stdout.expected $testroot/stdout
209 	ret=$?
210 	if [ $ret -ne 0 ]; then
211 		diff -u $testroot/stdout.expected $testroot/stdout
212 		test_done "$testroot" "$ret"
213 		return 1
214 	fi
215 	cmp -s $testroot/stderr.expected $testroot/stderr
216 	ret=$?
217 	if [ $ret -ne 0 ]; then
218 		diff -u $testroot/stderr.expected $testroot/stderr
219 		test_done "$testroot" "$ret"
220 		return 1
221 	fi
222 
223 	(cd $testroot/repo && got rebase -l > $testroot/stdout)
224 	echo -n > $testroot/stdout.expected
225 	cmp -s $testroot/stdout.expected $testroot/stdout
226 	ret=$?
227 	if [ $ret -ne 0 ]; then
228 		diff -u $testroot/stdout.expected $testroot/stdout
229 	fi
230 	test_done "$testroot" "$ret"
231 }
232 
233 test_rebase_ancestry_check() {
234 	local testroot=`test_init rebase_ancestry_check`
235 
236 	got checkout $testroot/repo $testroot/wt > /dev/null
237 	ret=$?
238 	if [ $ret -ne 0 ]; then
239 		test_done "$testroot" "$ret"
240 		return 1
241 	fi
242 
243 	(cd $testroot/repo && git checkout -q -b newbranch)
244 	echo "modified delta on branch" > $testroot/repo/gamma/delta
245 	git_commit $testroot/repo -m "committing to delta on newbranch"
246 	local newbranch_id=`git_show_head $testroot/repo`
247 
248 	(cd $testroot/wt && got rebase newbranch > $testroot/stdout \
249 		2> $testroot/stderr)
250 
251 	echo "refs/heads/newbranch is already based on refs/heads/master" \
252 		> $testroot/stdout.expected
253 	echo "Switching work tree from refs/heads/master to refs/heads/newbranch" \
254 		>> $testroot/stdout.expected
255 	echo "U  gamma/delta" >> $testroot/stdout.expected
256 	echo "Updated to refs/heads/newbranch: ${newbranch_id}" \
257 		>> $testroot/stdout.expected
258 	cmp -s $testroot/stdout.expected $testroot/stdout
259 	ret=$?
260 	if [ $ret -ne 0 ]; then
261 		diff -u $testroot/stdout.expected $testroot/stdout
262 		test_done "$testroot" "$ret"
263 		return 1
264 	fi
265 
266 	echo -n > $testroot/stderr.expected
267 	cmp -s $testroot/stderr.expected $testroot/stderr
268 	ret=$?
269 	if [ $ret -ne 0 ]; then
270 		diff -u $testroot/stderr.expected $testroot/stderr
271 	fi
272 	test_done "$testroot" "$ret"
273 }
274 
275 test_rebase_continue() {
276 	local testroot=`test_init rebase_continue`
277 	local init_commit=`git_show_head $testroot/repo`
278 
279 	(cd $testroot/repo && git checkout -q -b newbranch)
280 	echo "modified alpha on branch" > $testroot/repo/alpha
281 	git_commit $testroot/repo -m "committing to alpha on newbranch"
282 	local orig_commit1=`git_show_head $testroot/repo`
283 	local short_orig_commit1=`trim_obj_id 28 $orig_commit1`
284 
285 	(cd $testroot/repo && git checkout -q master)
286 	echo "modified alpha on master" > $testroot/repo/alpha
287 	git_commit $testroot/repo -m "committing to alpha on master"
288 	local master_commit=`git_show_head $testroot/repo`
289 
290 	got checkout $testroot/repo $testroot/wt > /dev/null
291 	ret=$?
292 	if [ $ret -ne 0 ]; then
293 		test_done "$testroot" "$ret"
294 		return 1
295 	fi
296 
297 	(cd $testroot/wt && got rebase newbranch > $testroot/stdout \
298 		2> $testroot/stderr)
299 
300 	echo "C  alpha" > $testroot/stdout.expected
301 	echo "Files with new merge conflicts: 1" >> $testroot/stdout.expected
302 	echo -n "$short_orig_commit1 -> merge conflict" \
303 		>> $testroot/stdout.expected
304 	echo ": committing to alpha on newbranch" >> $testroot/stdout.expected
305 	cmp -s $testroot/stdout.expected $testroot/stdout
306 	ret=$?
307 	if [ $ret -ne 0 ]; then
308 		diff -u $testroot/stdout.expected $testroot/stdout
309 		test_done "$testroot" "$ret"
310 		return 1
311 	fi
312 
313 	echo "got: conflicts must be resolved before rebasing can continue" \
314 		> $testroot/stderr.expected
315 	cmp -s $testroot/stderr.expected $testroot/stderr
316 	ret=$?
317 	if [ $ret -ne 0 ]; then
318 		diff -u $testroot/stderr.expected $testroot/stderr
319 		test_done "$testroot" "$ret"
320 		return 1
321 	fi
322 
323 	echo '<<<<<<<' > $testroot/content.expected
324 	echo "modified alpha on master" >> $testroot/content.expected
325 	echo "||||||| 3-way merge base: commit $init_commit" \
326 		>> $testroot/content.expected
327 	echo "alpha" >> $testroot/content.expected
328 	echo "=======" >> $testroot/content.expected
329 	echo "modified alpha on branch" >> $testroot/content.expected
330 	echo ">>>>>>> merged change: commit $orig_commit1" \
331 		>> $testroot/content.expected
332 	cat $testroot/wt/alpha > $testroot/content
333 	cmp -s $testroot/content.expected $testroot/content
334 	ret=$?
335 	if [ $ret -ne 0 ]; then
336 		diff -u $testroot/content.expected $testroot/content
337 		test_done "$testroot" "$ret"
338 		return 1
339 	fi
340 
341 	(cd $testroot/wt && got status > $testroot/stdout)
342 
343 	echo "C  alpha" > $testroot/stdout.expected
344 	cmp -s $testroot/stdout.expected $testroot/stdout
345 	ret=$?
346 	if [ $ret -ne 0 ]; then
347 		diff -u $testroot/stdout.expected $testroot/stdout
348 		test_done "$testroot" "$ret"
349 		return 1
350 	fi
351 
352 	# resolve the conflict
353 	echo "modified alpha on branch and master" > $testroot/wt/alpha
354 
355 	# test interaction of 'got stage' and rebase -c
356 	(cd $testroot/wt && got stage alpha > /dev/null)
357 	(cd $testroot/wt && got rebase -c > $testroot/stdout \
358 		2> $testroot/stderr)
359 	ret=$?
360 	if [ $ret -eq 0 ]; then
361 		echo "rebase succeeded unexpectedly" >&2
362 		test_done "$testroot" "1"
363 		return 1
364 	fi
365 	echo -n "got: work tree contains files with staged changes; " \
366 		> $testroot/stderr.expected
367 	echo "these changes must be committed or unstaged first" \
368 		>> $testroot/stderr.expected
369 	cmp -s $testroot/stderr.expected $testroot/stderr
370 	ret=$?
371 	if [ $ret -ne 0 ]; then
372 		diff -u $testroot/stderr.expected $testroot/stderr
373 		test_done "$testroot" "$ret"
374 		return 1
375 	fi
376 
377 	(cd $testroot/wt && got unstage alpha > /dev/null)
378 	(cd $testroot/wt && got rebase -c > $testroot/stdout)
379 
380 	(cd $testroot/repo && git checkout -q newbranch)
381 	local new_commit1=`git_show_head $testroot/repo`
382 	local short_new_commit1=`trim_obj_id 28 $new_commit1`
383 
384 	echo -n "$short_orig_commit1 -> $short_new_commit1" \
385 		> $testroot/stdout.expected
386 	echo ": committing to alpha on newbranch" >> $testroot/stdout.expected
387 	echo "Switching work tree to refs/heads/newbranch" \
388 		>> $testroot/stdout.expected
389 
390 	cmp -s $testroot/stdout.expected $testroot/stdout
391 	ret=$?
392 	if [ $ret -ne 0 ]; then
393 		diff -u $testroot/stdout.expected $testroot/stdout
394 		test_done "$testroot" "$ret"
395 		return 1
396 	fi
397 
398 
399 	(cd $testroot/wt && got log -l2 | grep ^commit > $testroot/stdout)
400 	echo "commit $new_commit1 (newbranch)" > $testroot/stdout.expected
401 	echo "commit $master_commit (master)" >> $testroot/stdout.expected
402 	cmp -s $testroot/stdout.expected $testroot/stdout
403 	ret=$?
404 	if [ $ret -ne 0 ]; then
405 		diff -u $testroot/stdout.expected $testroot/stdout
406 	fi
407 	test_done "$testroot" "$ret"
408 }
409 
410 test_rebase_abort() {
411 	local testroot=`test_init rebase_abort`
412 
413 	local init_commit=`git_show_head $testroot/repo`
414 
415 	(cd $testroot/repo && git checkout -q -b newbranch)
416 	echo "modified beta on branch" > $testroot/repo/beta
417 	git_commit $testroot/repo -m "committing to beta on newbranch"
418 	local orig_commit1=`git_show_head $testroot/repo`
419 	local short_orig_commit1=`trim_obj_id 28 $orig_commit1`
420 
421 	echo "modified alpha on branch" > $testroot/repo/alpha
422 	echo "new file on branch" > $testroot/repo/epsilon/new
423 	(cd $testroot/repo && git add epsilon/new)
424 	git_commit $testroot/repo \
425 		-m "changing alpha and adding new on newbranch"
426 	local orig_commit2=`git_show_head $testroot/repo`
427 	local short_orig_commit2=`trim_obj_id 28 $orig_commit2`
428 
429 	(cd $testroot/repo && git checkout -q master)
430 	echo "modified alpha on master" > $testroot/repo/alpha
431 	git_commit $testroot/repo -m "committing to alpha on master"
432 	local master_commit=`git_show_head $testroot/repo`
433 
434 	got checkout $testroot/repo $testroot/wt > /dev/null
435 	ret=$?
436 	if [ $ret -ne 0 ]; then
437 		test_done "$testroot" "$ret"
438 		return 1
439 	fi
440 
441 	# unrelated unversioned file in work tree
442 	touch $testroot/wt/unversioned-file
443 
444 	(cd $testroot/wt && got rebase newbranch > $testroot/stdout \
445 		2> $testroot/stderr)
446 
447 	new_commit1=$(cd $testroot/wt && got info beta | \
448 		grep '^based on commit:' | cut -d' ' -f4)
449 	local short_new_commit1=`trim_obj_id 28 $new_commit1`
450 	
451 	echo "G  beta" > $testroot/stdout.expected
452 	echo -n "$short_orig_commit1 -> $short_new_commit1" \
453 		>> $testroot/stdout.expected
454 	echo ": committing to beta on newbranch" >> $testroot/stdout.expected
455 	echo "C  alpha" >> $testroot/stdout.expected
456 	echo "A  epsilon/new" >> $testroot/stdout.expected
457 	echo "Files with new merge conflicts: 1" >> $testroot/stdout.expected
458 	echo -n "$short_orig_commit2 -> merge conflict" \
459 		>> $testroot/stdout.expected
460 	echo ": changing alpha and adding new on newbranch" \
461 		>> $testroot/stdout.expected
462 	cmp -s $testroot/stdout.expected $testroot/stdout
463 	ret=$?
464 	if [ $ret -ne 0 ]; then
465 		diff -u $testroot/stdout.expected $testroot/stdout
466 		test_done "$testroot" "$ret"
467 		return 1
468 	fi
469 
470 	echo "got: conflicts must be resolved before rebasing can continue" \
471 		> $testroot/stderr.expected
472 	cmp -s $testroot/stderr.expected $testroot/stderr
473 	ret=$?
474 	if [ $ret -ne 0 ]; then
475 		diff -u $testroot/stderr.expected $testroot/stderr
476 		test_done "$testroot" "$ret"
477 		return 1
478 	fi
479 
480 	echo '<<<<<<<' > $testroot/content.expected
481 	echo "modified alpha on master" >> $testroot/content.expected
482 	echo "||||||| 3-way merge base: commit $orig_commit1" \
483 		>> $testroot/content.expected
484 	echo "alpha" >> $testroot/content.expected
485 	echo "=======" >> $testroot/content.expected
486 	echo "modified alpha on branch" >> $testroot/content.expected
487 	echo ">>>>>>> merged change: commit $orig_commit2" \
488 		>> $testroot/content.expected
489 	cat $testroot/wt/alpha > $testroot/content
490 	cmp -s $testroot/content.expected $testroot/content
491 	ret=$?
492 	if [ $ret -ne 0 ]; then
493 		diff -u $testroot/content.expected $testroot/content
494 		test_done "$testroot" "$ret"
495 		return 1
496 	fi
497 
498 	# unrelated file in work tree added during conflict resolution
499 	touch $testroot/wt/added-file
500 	(cd $testroot/wt && got add added-file > /dev/null)
501 
502 	(cd $testroot/wt && got status > $testroot/stdout)
503 
504 	echo "A  added-file" > $testroot/stdout.expected
505 	echo "C  alpha" >> $testroot/stdout.expected
506 	echo "A  epsilon/new" >> $testroot/stdout.expected
507 	echo "?  unversioned-file" >> $testroot/stdout.expected
508 	cmp -s $testroot/stdout.expected $testroot/stdout
509 	ret=$?
510 	if [ $ret -ne 0 ]; then
511 		diff -u $testroot/stdout.expected $testroot/stdout
512 		test_done "$testroot" "$ret"
513 		return 1
514 	fi
515 
516 	(cd $testroot/wt && got rebase -a > $testroot/stdout)
517 
518 	(cd $testroot/repo && git checkout -q newbranch)
519 
520 	echo "Switching work tree to refs/heads/master" \
521 		> $testroot/stdout.expected
522 	echo 'R  added-file' >> $testroot/stdout.expected
523 	echo 'R  alpha' >> $testroot/stdout.expected
524 	echo 'R  epsilon/new' >> $testroot/stdout.expected
525 	echo 'G  added-file' >> $testroot/stdout.expected
526 	echo 'U  beta' >> $testroot/stdout.expected
527 	echo "Rebase of refs/heads/newbranch aborted" \
528 		>> $testroot/stdout.expected
529 
530 	cmp -s $testroot/stdout.expected $testroot/stdout
531 	ret=$?
532 	if [ $ret -ne 0 ]; then
533 		diff -u $testroot/stdout.expected $testroot/stdout
534 		test_done "$testroot" "$ret"
535 		return 1
536 	fi
537 
538 	echo "modified alpha on master" > $testroot/content.expected
539 	cat $testroot/wt/alpha > $testroot/content
540 	cmp -s $testroot/content.expected $testroot/content
541 	ret=$?
542 	if [ $ret -ne 0 ]; then
543 		diff -u $testroot/content.expected $testroot/content
544 		test_done "$testroot" "$ret"
545 		return 1
546 	fi
547 
548 	(cd $testroot/wt && got log -l3 -c newbranch \
549 		| grep ^commit > $testroot/stdout)
550 	echo "commit $orig_commit2 (newbranch)" > $testroot/stdout.expected
551 	echo "commit $orig_commit1" >> $testroot/stdout.expected
552 	echo "commit $init_commit" >> $testroot/stdout.expected
553 	cmp -s $testroot/stdout.expected $testroot/stdout
554 	ret=$?
555 	if [ $ret -ne 0 ]; then
556 		diff -u $testroot/stdout.expected $testroot/stdout
557 		test_done "$testroot" "$ret"
558 		return 1
559 	fi
560 
561 	(cd $testroot/wt && got info .| \
562 		grep '^based on commit:' | sort | uniq > $testroot/stdout)
563 	echo "based on commit: $master_commit" > $testroot/stdout.expected
564 	cmp -s $testroot/stdout.expected $testroot/stdout
565 	ret=$?
566 	if [ $ret -ne 0 ]; then
567 		diff -u $testroot/stdout.expected $testroot/stdout
568 		test_done "$testroot" "$ret"
569 		return 1
570 	fi
571 
572 	(cd $testroot/wt && got status > $testroot/stdout)
573 	echo "?  added-file" > $testroot/stdout.expected
574 	echo "?  unversioned-file" >> $testroot/stdout.expected
575 	cmp -s $testroot/stdout.expected $testroot/stdout
576 	ret=$?
577 	if [ $ret -ne 0 ]; then
578 		diff -u $testroot/stdout.expected $testroot/stdout
579 		test_done "$testroot" "$ret"
580 		return 1
581 	fi
582 
583 	cat $testroot/wt/beta > $testroot/content
584 	echo 'beta' > $testroot/content.expected
585 	cmp -s $testroot/content.expected $testroot/content
586 	ret=$?
587 	if [ $ret -ne 0 ]; then
588 		diff -u $testroot/content.expected $testroot/content
589 		test_done "$testroot" "$ret"
590 		return 1
591 	fi
592 
593 	# A subsequent update should be a no-op.
594 	(cd $testroot/wt && got update > $testroot/stdout)
595 	echo 'Already up-to-date' > $testroot/stdout.expected
596 	cmp -s $testroot/stdout.expected $testroot/stdout
597 	ret=$?
598 	if [ $ret -ne 0 ]; then
599 		diff -u $testroot/stdout.expected $testroot/stdout
600 	fi
601 	test_done "$testroot" "$ret"
602 }
603 
604 test_rebase_no_op_change() {
605 	local testroot=`test_init rebase_no_op_change`
606 	local init_commit=`git_show_head $testroot/repo`
607 
608 	(cd $testroot/repo && git checkout -q -b newbranch)
609 	echo "modified alpha on branch" > $testroot/repo/alpha
610 	git_commit $testroot/repo -m "committing to alpha on newbranch"
611 	local orig_commit1=`git_show_head $testroot/repo`
612 	local short_orig_commit1=`trim_obj_id 28 $orig_commit1`
613 
614 	(cd $testroot/repo && git checkout -q master)
615 	echo "modified alpha on master" > $testroot/repo/alpha
616 	git_commit $testroot/repo -m "committing to alpha on master"
617 	local master_commit=`git_show_head $testroot/repo`
618 
619 	got checkout $testroot/repo $testroot/wt > /dev/null
620 	ret=$?
621 	if [ $ret -ne 0 ]; then
622 		test_done "$testroot" "$ret"
623 		return 1
624 	fi
625 
626 	(cd $testroot/wt && got rebase newbranch > $testroot/stdout \
627 		2> $testroot/stderr)
628 
629 	echo "C  alpha" > $testroot/stdout.expected
630 	echo "Files with new merge conflicts: 1" >> $testroot/stdout.expected
631 	echo -n "$short_orig_commit1 -> merge conflict" \
632 		>> $testroot/stdout.expected
633 	echo ": committing to alpha on newbranch" >> $testroot/stdout.expected
634 	cmp -s $testroot/stdout.expected $testroot/stdout
635 	ret=$?
636 	if [ $ret -ne 0 ]; then
637 		diff -u $testroot/stdout.expected $testroot/stdout
638 		test_done "$testroot" "$ret"
639 		return 1
640 	fi
641 
642 	echo "got: conflicts must be resolved before rebasing can continue" \
643 		> $testroot/stderr.expected
644 	cmp -s $testroot/stderr.expected $testroot/stderr
645 	ret=$?
646 	if [ $ret -ne 0 ]; then
647 		diff -u $testroot/stderr.expected $testroot/stderr
648 		test_done "$testroot" "$ret"
649 		return 1
650 	fi
651 
652 	echo '<<<<<<<' > $testroot/content.expected
653 	echo "modified alpha on master" >> $testroot/content.expected
654 	echo "||||||| 3-way merge base: commit $init_commit" \
655 		>> $testroot/content.expected
656 	echo "alpha" >> $testroot/content.expected
657 	echo "=======" >> $testroot/content.expected
658 	echo "modified alpha on branch" >> $testroot/content.expected
659 	echo ">>>>>>> merged change: commit $orig_commit1" \
660 		>> $testroot/content.expected
661 	cat $testroot/wt/alpha > $testroot/content
662 	cmp -s $testroot/content.expected $testroot/content
663 	ret=$?
664 	if [ $ret -ne 0 ]; then
665 		diff -u $testroot/content.expected $testroot/content
666 		test_done "$testroot" "$ret"
667 		return 1
668 	fi
669 
670 	(cd $testroot/wt && got status > $testroot/stdout)
671 
672 	echo "C  alpha" > $testroot/stdout.expected
673 	cmp -s $testroot/stdout.expected $testroot/stdout
674 	ret=$?
675 	if [ $ret -ne 0 ]; then
676 		diff -u $testroot/stdout.expected $testroot/stdout
677 		test_done "$testroot" "$ret"
678 		return 1
679 	fi
680 
681 	# resolve the conflict
682 	echo "modified alpha on master" > $testroot/wt/alpha
683 
684 	(cd $testroot/wt && got rebase -c > $testroot/stdout)
685 
686 	(cd $testroot/repo && git checkout -q newbranch)
687 	local new_commit1=`git_show_head $testroot/repo`
688 
689 	echo -n "$short_orig_commit1 -> no-op change" \
690 		> $testroot/stdout.expected
691 	echo ": committing to alpha on newbranch" >> $testroot/stdout.expected
692 	echo "Switching work tree to refs/heads/newbranch" \
693 		>> $testroot/stdout.expected
694 
695 	cmp -s $testroot/stdout.expected $testroot/stdout
696 	ret=$?
697 	if [ $ret -ne 0 ]; then
698 		diff -u $testroot/stdout.expected $testroot/stdout
699 		test_done "$testroot" "$ret"
700 		return 1
701 	fi
702 
703 
704 	(cd $testroot/wt && got log -l2 | grep ^commit > $testroot/stdout)
705 	echo "commit $master_commit (master, newbranch)" \
706 		> $testroot/stdout.expected
707 	echo "commit $init_commit" >> $testroot/stdout.expected
708 	cmp -s $testroot/stdout.expected $testroot/stdout
709 	ret=$?
710 	if [ $ret -ne 0 ]; then
711 		diff -u $testroot/stdout.expected $testroot/stdout
712 	fi
713 	test_done "$testroot" "$ret"
714 }
715 
716 test_rebase_in_progress() {
717 	local testroot=`test_init rebase_in_progress`
718 	local init_commit=`git_show_head $testroot/repo`
719 
720 	(cd $testroot/repo && git checkout -q -b newbranch)
721 	echo "modified alpha on branch" > $testroot/repo/alpha
722 	git_commit $testroot/repo -m "committing to alpha on newbranch"
723 	local orig_commit1=`git_show_head $testroot/repo`
724 	local short_orig_commit1=`trim_obj_id 28 $orig_commit1`
725 
726 	(cd $testroot/repo && git checkout -q master)
727 	echo "modified alpha on master" > $testroot/repo/alpha
728 	git_commit $testroot/repo -m "committing to alpha on master"
729 	local master_commit=`git_show_head $testroot/repo`
730 
731 	got checkout $testroot/repo $testroot/wt > /dev/null
732 	ret=$?
733 	if [ $ret -ne 0 ]; then
734 		test_done "$testroot" "$ret"
735 		return 1
736 	fi
737 
738 	(cd $testroot/wt && got rebase newbranch > $testroot/stdout \
739 		2> $testroot/stderr)
740 
741 	echo "C  alpha" > $testroot/stdout.expected
742 	echo "Files with new merge conflicts: 1" >> $testroot/stdout.expected
743 	echo -n "$short_orig_commit1 -> merge conflict" \
744 		>> $testroot/stdout.expected
745 	echo ": committing to alpha on newbranch" >> $testroot/stdout.expected
746 	cmp -s $testroot/stdout.expected $testroot/stdout
747 	ret=$?
748 	if [ $ret -ne 0 ]; then
749 		diff -u $testroot/stdout.expected $testroot/stdout
750 		test_done "$testroot" "$ret"
751 		return 1
752 	fi
753 
754 	echo "got: conflicts must be resolved before rebasing can continue" \
755 		> $testroot/stderr.expected
756 	cmp -s $testroot/stderr.expected $testroot/stderr
757 	ret=$?
758 	if [ $ret -ne 0 ]; then
759 		diff -u $testroot/stderr.expected $testroot/stderr
760 		test_done "$testroot" "$ret"
761 		return 1
762 	fi
763 
764 	echo '<<<<<<<' > $testroot/content.expected
765 	echo "modified alpha on master" >> $testroot/content.expected
766 	echo "||||||| 3-way merge base: commit $init_commit" \
767 		>> $testroot/content.expected
768 	echo "alpha" >> $testroot/content.expected
769 	echo "=======" >> $testroot/content.expected
770 	echo "modified alpha on branch" >> $testroot/content.expected
771 	echo ">>>>>>> merged change: commit $orig_commit1" \
772 		>> $testroot/content.expected
773 	cat $testroot/wt/alpha > $testroot/content
774 	cmp -s $testroot/content.expected $testroot/content
775 	ret=$?
776 	if [ $ret -ne 0 ]; then
777 		diff -u $testroot/content.expected $testroot/content
778 		test_done "$testroot" "$ret"
779 		return 1
780 	fi
781 
782 	(cd $testroot/wt && got status > $testroot/stdout)
783 
784 	echo "C  alpha" > $testroot/stdout.expected
785 	cmp -s $testroot/stdout.expected $testroot/stdout
786 	ret=$?
787 	if [ $ret -ne 0 ]; then
788 		diff -u $testroot/stdout.expected $testroot/stdout
789 		test_done "$testroot" "$ret"
790 		return 1
791 	fi
792 
793 	for cmd in update commit; do
794 		(cd $testroot/wt && got $cmd > $testroot/stdout \
795 			2> $testroot/stderr)
796 
797 		echo -n > $testroot/stdout.expected
798 		cmp -s $testroot/stdout.expected $testroot/stdout
799 		ret=$?
800 		if [ $ret -ne 0 ]; then
801 			diff -u $testroot/stdout.expected $testroot/stdout
802 			test_done "$testroot" "$ret"
803 			return 1
804 		fi
805 
806 		echo -n "got: a rebase operation is in progress in this " \
807 			> $testroot/stderr.expected
808 		echo "work tree and must be continued or aborted first" \
809 			>> $testroot/stderr.expected
810 		cmp -s $testroot/stderr.expected $testroot/stderr
811 		ret=$?
812 		if [ $ret -ne 0 ]; then
813 			diff -u $testroot/stderr.expected $testroot/stderr
814 			test_done "$testroot" "$ret"
815 			return 1
816 		fi
817 	done
818 
819 	test_done "$testroot" "$ret"
820 }
821 
822 test_rebase_path_prefix() {
823 	local testroot=`test_init rebase_path_prefix`
824 
825 	(cd $testroot/repo && git checkout -q -b newbranch)
826 	echo "modified delta on branch" > $testroot/repo/gamma/delta
827 	git_commit $testroot/repo -m "committing to delta on newbranch"
828 
829 	local orig_commit1=`git_show_parent_commit $testroot/repo`
830 	local orig_commit2=`git_show_head $testroot/repo`
831 
832 	(cd $testroot/repo && git checkout -q master)
833 	echo "modified zeta on master" > $testroot/repo/epsilon/zeta
834 	git_commit $testroot/repo -m "committing to zeta on master"
835 	local master_commit=`git_show_head $testroot/repo`
836 
837 	got checkout -p epsilon $testroot/repo $testroot/wt > /dev/null
838 	ret=$?
839 	if [ $ret -ne 0 ]; then
840 		test_done "$testroot" "$ret"
841 		return 1
842 	fi
843 
844 	(cd $testroot/wt && got rebase newbranch \
845 		> $testroot/stdout 2> $testroot/stderr)
846 
847 	echo -n > $testroot/stdout.expected
848 	cmp -s $testroot/stdout.expected $testroot/stdout
849 	ret=$?
850 	if [ $ret -ne 0 ]; then
851 		diff -u $testroot/stdout.expected $testroot/stdout
852 		test_done "$testroot" "$ret"
853 		return 1
854 	fi
855 
856 	echo -n "got: cannot rebase branch which contains changes outside " \
857 		> $testroot/stderr.expected
858 	echo "of this work tree's path prefix" >> $testroot/stderr.expected
859 	cmp -s $testroot/stderr.expected $testroot/stderr
860 	ret=$?
861 	if [ $ret -ne 0 ]; then
862 		diff -u $testroot/stderr.expected $testroot/stderr
863 		test_done "$testroot" "$ret"
864 		return 1
865 	fi
866 
867 	# rebase should succeed when using a complete work tree
868 	got checkout $testroot/repo $testroot/wt2 > /dev/null
869 	ret=$?
870 	if [ $ret -ne 0 ]; then
871 		test_done "$testroot" "$ret"
872 		return 1
873 	fi
874 
875 	(cd $testroot/wt2 && got rebase newbranch \
876 		> $testroot/stdout 2> $testroot/stderr)
877 
878 	(cd $testroot/repo && git checkout -q newbranch)
879 	local new_commit1=`git_show_parent_commit $testroot/repo`
880 	local new_commit2=`git_show_head $testroot/repo`
881 
882 	local short_orig_commit2=`trim_obj_id 28 $orig_commit2`
883 	local short_new_commit2=`trim_obj_id 28 $new_commit2`
884 
885 	echo "G  gamma/delta" > $testroot/stdout.expected
886 	echo -n "$short_orig_commit2 -> $short_new_commit2" \
887 		>> $testroot/stdout.expected
888 	echo ": committing to delta on newbranch" \
889 		>> $testroot/stdout.expected
890 	echo "Switching work tree to refs/heads/newbranch" \
891 		>> $testroot/stdout.expected
892 
893 	cmp -s $testroot/stdout.expected $testroot/stdout
894 	ret=$?
895 	if [ $ret -ne 0 ]; then
896 		diff -u $testroot/stdout.expected $testroot/stdout
897 		test_done "$testroot" "$ret"
898 		return 1
899 	fi
900 
901 	# the first work tree should remain usable
902 	(cd $testroot/wt && got update -b master \
903 		> $testroot/stdout 2> $testroot/stderr)
904 	ret=$?
905 	if [ $ret -ne 0 ]; then
906 		echo "update failed unexpectedly" >&2
907 		test_done "$testroot" "1"
908 		return 1
909 	fi
910 
911 	echo 'Already up-to-date' > $testroot/stdout.expected
912 	cmp -s $testroot/stdout.expected $testroot/stdout
913 	ret=$?
914 	if [ $ret -ne 0 ]; then
915 		diff -u $testroot/stdout.expected $testroot/stdout
916 	fi
917 	test_done "$testroot" "$ret"
918 }
919 
920 test_rebase_preserves_logmsg() {
921 	local testroot=`test_init rebase_preserves_logmsg`
922 
923 	(cd $testroot/repo && git checkout -q -b newbranch)
924 	echo "modified delta on branch" > $testroot/repo/gamma/delta
925 	git_commit $testroot/repo -m "modified delta on newbranch"
926 
927 	echo "modified alpha on branch" > $testroot/repo/alpha
928 	git_commit $testroot/repo -m "modified alpha on newbranch"
929 
930 	(cd $testroot/repo && got log -c newbranch -l2 | grep -v ^date: \
931 		> $testroot/log.expected)
932 
933 	local orig_commit1=`git_show_parent_commit $testroot/repo`
934 	local orig_commit2=`git_show_head $testroot/repo`
935 
936 	(cd $testroot/repo && git checkout -q master)
937 	echo "modified zeta on master" > $testroot/repo/epsilon/zeta
938 	git_commit $testroot/repo -m "committing to zeta on master"
939 	local master_commit=`git_show_head $testroot/repo`
940 
941 	got checkout $testroot/repo $testroot/wt > /dev/null
942 	ret=$?
943 	if [ $ret -ne 0 ]; then
944 		test_done "$testroot" "$ret"
945 		return 1
946 	fi
947 
948 	(cd $testroot/wt && got rebase newbranch > /dev/null \
949 		2> $testroot/stderr)
950 
951 	(cd $testroot/repo && git checkout -q newbranch)
952 	local new_commit1=`git_show_parent_commit $testroot/repo`
953 	local new_commit2=`git_show_head $testroot/repo`
954 
955 	echo -n > $testroot/stderr.expected
956 	cmp -s $testroot/stderr.expected $testroot/stderr
957 	ret=$?
958 	if [ $ret -ne 0 ]; then
959 		diff -u $testroot/stderr.expected $testroot/stderr
960 		test_done "$testroot" "$ret"
961 		return 1
962 	fi
963 
964 	(cd $testroot/wt && got log -c newbranch -l2 | grep -v ^date: \
965 		> $testroot/log)
966 	ed -s $testroot/log.expected <<-EOF
967 	,s/$orig_commit1/$new_commit1/
968 	,s/$orig_commit2/$new_commit2/
969 	w
970 	EOF
971 	cmp -s $testroot/log.expected $testroot/log
972 	ret=$?
973 	if [ $ret -ne 0 ]; then
974 		diff -u $testroot/log.expected $testroot/log
975 	fi
976 
977 	test_done "$testroot" "$ret"
978 }
979 
980 test_rebase_no_commits_to_rebase() {
981 	local testroot=`test_init rebase_no_commits_to_rebase`
982 
983 	got checkout $testroot/repo $testroot/wt > /dev/null
984 	ret=$?
985 	if [ $ret -ne 0 ]; then
986 		test_done "$testroot" "$ret"
987 		return 1
988 	fi
989 
990 	# Create an unrelated branch with 'got import'.
991 	mkdir -p $testroot/newtree
992 	echo "new file" > $testroot/newtree/newfile
993 	got import -m new -b newbranch -r $testroot/repo \
994 		$testroot/newtree > /dev/null
995 
996 	echo "modified alpha on master" > $testroot/wt/alpha
997 	(cd $testroot/wt && got commit -m 'test rebase_no_commits_to_rebase' \
998 		> /dev/null)
999 	(cd $testroot/wt && got update > /dev/null)
1000 
1001 	(cd $testroot/wt && got rebase newbranch > $testroot/stdout \
1002 		2> $testroot/stderr)
1003 
1004 	echo -n "got: specified branch shares no common ancestry " \
1005 		> $testroot/stderr.expected
1006 	echo "with work tree's branch" >> $testroot/stderr.expected
1007 	cmp -s $testroot/stderr.expected $testroot/stderr
1008 	ret=$?
1009 	if [ $ret -ne 0 ]; then
1010 		diff -u $testroot/stderr.expected $testroot/stderr
1011 		test_done "$testroot" "$ret"
1012 		return 1
1013 	fi
1014 
1015 	echo -n > $testroot/stdout.expected
1016 	cmp -s $testroot/stdout.expected $testroot/stdout
1017 	ret=$?
1018 	if [ $ret -ne 0 ]; then
1019 		diff -u $testroot/stdout.expected $testroot/stdout
1020 		test_done "$testroot" "$ret"
1021 		return 1
1022 	fi
1023 
1024 	(cd $testroot/wt && got update > $testroot/stdout)
1025 	echo "Already up-to-date" > $testroot/stdout.expected
1026 	cmp -s $testroot/stdout.expected $testroot/stdout
1027 	ret=$?
1028 	if [ $ret -ne 0 ]; then
1029 		diff -u $testroot/stdout.expected $testroot/stdout
1030 	fi
1031 	test_done "$testroot" "$ret"
1032 }
1033 
1034 test_rebase_forward() {
1035 	local testroot=`test_init rebase_forward`
1036 	local commit0=`git_show_head $testroot/repo`
1037 
1038 	got checkout $testroot/repo $testroot/wt > /dev/null
1039 	ret=$?
1040 	if [ $ret -ne 0 ]; then
1041 		test_done "$testroot" "$ret"
1042 		return 1
1043 	fi
1044 
1045 	echo "change alpha 1" > $testroot/wt/alpha
1046 	(cd $testroot/wt && got commit -m 'test rebase_forward' \
1047 		> /dev/null)
1048 	local commit1=`git_show_head $testroot/repo`
1049 
1050 	echo "change alpha 2" > $testroot/wt/alpha
1051 	(cd $testroot/wt && got commit -m 'test rebase_forward' \
1052 		> /dev/null)
1053 	local commit2=`git_show_head $testroot/repo`
1054 
1055 	# Simulate a situation where fast-forward is required.
1056 	# We want to fast-forward master to origin/master:
1057 	# commit 3907e11dceaae2ca7f8db79c2af31794673945ad (origin/master)
1058 	# commit ffcffcd102cf1af6572fbdbb4cf07a0f1fd2d840 (master)
1059 	# commit 87a6a8a2263a15b61c016ff1720b24741d455eb5
1060 	(cd $testroot/repo && got ref -d master >/dev/null)
1061 	(cd $testroot/repo && got ref -c $commit1 refs/heads/master)
1062 	(cd $testroot/repo && got ref -c $commit2 refs/remotes/origin/master)
1063 
1064 	(cd $testroot/wt && got up -b origin/master > /dev/null)
1065 
1066 	(cd $testroot/wt && got rebase master \
1067 		> $testroot/stdout 2> $testroot/stderr)
1068 
1069 	echo "Forwarding refs/heads/master to commit $commit2" \
1070 		> $testroot/stdout.expected
1071 	echo "Switching work tree to refs/heads/master" \
1072 		>> $testroot/stdout.expected
1073 	cmp -s $testroot/stdout.expected $testroot/stdout
1074 	ret=$?
1075 	if [ $ret -ne 0 ]; then
1076 		diff -u $testroot/stdout.expected $testroot/stdout
1077 		test_done "$testroot" "$ret"
1078 		return 1
1079 	fi
1080 
1081 	# Ensure that rebase operation was completed correctly
1082 	(cd $testroot/wt && got rebase -a \
1083 		> $testroot/stdout 2> $testroot/stderr)
1084 	echo -n "" > $testroot/stdout.expected
1085 	cmp -s $testroot/stdout.expected $testroot/stdout
1086 	ret=$?
1087 	if [ $ret -ne 0 ]; then
1088 		diff -u $testroot/stdout.expected $testroot/stdout
1089 		test_done "$testroot" "$ret"
1090 		return 1
1091 	fi
1092 	echo "got: rebase operation not in progress" > $testroot/stderr.expected
1093 	cmp -s $testroot/stderr.expected $testroot/stderr
1094 	ret=$?
1095 	if [ $ret -ne 0 ]; then
1096 		diff -u $testroot/stderr.expected $testroot/stderr
1097 		test_done "$testroot" "$ret"
1098 		return 1
1099 	fi
1100 
1101 	(cd $testroot/wt && got branch -n > $testroot/stdout)
1102 	echo "master" > $testroot/stdout.expected
1103 	cmp -s $testroot/stdout.expected $testroot/stdout
1104 	ret=$?
1105 	if [ $ret -ne 0 ]; then
1106 		diff -u $testroot/stdout.expected $testroot/stdout
1107 		test_done "$testroot" "$ret"
1108 		return 1
1109 	fi
1110 
1111 	(cd $testroot/wt && got log -l3 | grep ^commit > $testroot/stdout)
1112 	echo "commit $commit2 (master, origin/master)" > $testroot/stdout.expected
1113 	echo "commit $commit1" >> $testroot/stdout.expected
1114 	echo "commit $commit0" >> $testroot/stdout.expected
1115 	cmp -s $testroot/stdout.expected $testroot/stdout
1116 	ret=$?
1117 	if [ $ret -ne 0 ]; then
1118 		diff -u $testroot/stdout.expected $testroot/stdout
1119 		test_done "$testroot" "$ret"
1120 		return 1
1121 	fi
1122 
1123 	# Forward-only rebase operations should not be backed up
1124 	(cd $testroot/repo && got rebase -l > $testroot/stdout)
1125 	echo -n > $testroot/stdout.expected
1126 	cmp -s $testroot/stdout.expected $testroot/stdout
1127 	ret=$?
1128 	if [ $ret -ne 0 ]; then
1129 		diff -u $testroot/stdout.expected $testroot/stdout
1130 	fi
1131 	test_done "$testroot" "$ret"
1132 }
1133 
1134 test_rebase_forward_path_prefix() {
1135 	local testroot=`test_init rebase_forward_path_prefix`
1136 	local commit0=`git_show_head $testroot/repo`
1137 
1138 	got checkout $testroot/repo $testroot/wt-full > /dev/null
1139 	ret=$?
1140 	if [ $ret -ne 0 ]; then
1141 		test_done "$testroot" "$ret"
1142 		return 1
1143 	fi
1144 
1145 	echo "change alpha 1" > $testroot/wt-full/alpha
1146 	(cd $testroot/wt-full && got commit -m 'test rebase_forward' \
1147 		> /dev/null)
1148 	local commit1=`git_show_head $testroot/repo`
1149 
1150 	echo "change alpha 2" > $testroot/wt-full/alpha
1151 	(cd $testroot/wt-full && got commit -m 'test rebase_forward' \
1152 		> /dev/null)
1153 	local commit2=`git_show_head $testroot/repo`
1154 
1155 	# Simulate a situation where fast-forward is required.
1156 	# We want to fast-forward master to origin/master:
1157 	# commit 3907e11dceaae2ca7f8db79c2af31794673945ad (origin/master)
1158 	# commit ffcffcd102cf1af6572fbdbb4cf07a0f1fd2d840 (master)
1159 	# commit 87a6a8a2263a15b61c016ff1720b24741d455eb5
1160 	(cd $testroot/repo && got ref -d master >/dev/null)
1161 	(cd $testroot/repo && got ref -c $commit1 refs/heads/master)
1162 	(cd $testroot/repo && got ref -c $commit2 refs/remotes/origin/master)
1163 
1164 	# Work tree which uses a path-prefix and will be used for rebasing
1165 	got checkout -p epsilon -b origin/master $testroot/repo $testroot/wt \
1166 		> /dev/null
1167 	ret=$?
1168 	if [ $ret -ne 0 ]; then
1169 		test_done "$testroot" "$ret"
1170 		return 1
1171 	fi
1172 
1173 	(cd $testroot/wt && got rebase master \
1174 		> $testroot/stdout 2> $testroot/stderr)
1175 
1176 	echo "Forwarding refs/heads/master to commit $commit2" \
1177 		> $testroot/stdout.expected
1178 	echo "Switching work tree to refs/heads/master" \
1179 		>> $testroot/stdout.expected
1180 	cmp -s $testroot/stdout.expected $testroot/stdout
1181 	ret=$?
1182 	if [ $ret -ne 0 ]; then
1183 		diff -u $testroot/stdout.expected $testroot/stdout
1184 		test_done "$testroot" "$ret"
1185 		return 1
1186 	fi
1187 
1188 	# Ensure that rebase operation was completed correctly
1189 	(cd $testroot/wt && got rebase -a \
1190 		> $testroot/stdout 2> $testroot/stderr)
1191 	echo -n "" > $testroot/stdout.expected
1192 	cmp -s $testroot/stdout.expected $testroot/stdout
1193 	ret=$?
1194 	if [ $ret -ne 0 ]; then
1195 		diff -u $testroot/stdout.expected $testroot/stdout
1196 		test_done "$testroot" "$ret"
1197 		return 1
1198 	fi
1199 	echo "got: rebase operation not in progress" > $testroot/stderr.expected
1200 	cmp -s $testroot/stderr.expected $testroot/stderr
1201 	ret=$?
1202 	if [ $ret -ne 0 ]; then
1203 		diff -u $testroot/stderr.expected $testroot/stderr
1204 		test_done "$testroot" "$ret"
1205 		return 1
1206 	fi
1207 
1208 	(cd $testroot/wt && got branch -n > $testroot/stdout)
1209 	echo "master" > $testroot/stdout.expected
1210 	cmp -s $testroot/stdout.expected $testroot/stdout
1211 	ret=$?
1212 	if [ $ret -ne 0 ]; then
1213 		diff -u $testroot/stdout.expected $testroot/stdout
1214 		test_done "$testroot" "$ret"
1215 		return 1
1216 	fi
1217 
1218 	(cd $testroot/wt && got log -l3 | grep ^commit > $testroot/stdout)
1219 	echo "commit $commit2 (master, origin/master)" > $testroot/stdout.expected
1220 	echo "commit $commit1" >> $testroot/stdout.expected
1221 	echo "commit $commit0" >> $testroot/stdout.expected
1222 	cmp -s $testroot/stdout.expected $testroot/stdout
1223 	ret=$?
1224 	if [ $ret -ne 0 ]; then
1225 		diff -u $testroot/stdout.expected $testroot/stdout
1226 		test_done "$testroot" "$ret"
1227 		return 1
1228 	fi
1229 
1230 	# Forward-only rebase operations should not be backed up
1231 	(cd $testroot/repo && got rebase -l > $testroot/stdout)
1232 	echo -n > $testroot/stdout.expected
1233 	cmp -s $testroot/stdout.expected $testroot/stdout
1234 	ret=$?
1235 	if [ $ret -ne 0 ]; then
1236 		diff -u $testroot/stdout.expected $testroot/stdout
1237 	fi
1238 	test_done "$testroot" "$ret"
1239 }
1240 
1241 test_rebase_out_of_date() {
1242 	local testroot=`test_init rebase_out_of_date`
1243 	local initial_commit=`git_show_head $testroot/repo`
1244 
1245 	(cd $testroot/repo && git checkout -q -b newbranch)
1246 	echo "modified delta on branch" > $testroot/repo/gamma/delta
1247 	git_commit $testroot/repo -m "committing to delta on newbranch"
1248 
1249 	echo "modified alpha on branch" > $testroot/repo/alpha
1250 	(cd $testroot/repo && git rm -q beta)
1251 	echo "new file on branch" > $testroot/repo/epsilon/new
1252 	(cd $testroot/repo && git add epsilon/new)
1253 	git_commit $testroot/repo -m "committing more changes on newbranch"
1254 
1255 	local orig_commit1=`git_show_parent_commit $testroot/repo`
1256 	local orig_commit2=`git_show_head $testroot/repo`
1257 
1258 	(cd $testroot/repo && git checkout -q master)
1259 	echo "modified zeta on master" > $testroot/repo/epsilon/zeta
1260 	git_commit $testroot/repo -m "committing to zeta on master"
1261 	local master_commit1=`git_show_head $testroot/repo`
1262 
1263 	(cd $testroot/repo && git checkout -q master)
1264 	echo "modified beta on master" > $testroot/repo/beta
1265 	git_commit $testroot/repo -m "committing to beta on master"
1266 	local master_commit2=`git_show_head $testroot/repo`
1267 
1268 	got checkout -c $master_commit1 $testroot/repo $testroot/wt \
1269 		> /dev/null
1270 	ret=$?
1271 	if [ $ret -ne 0 ]; then
1272 		test_done "$testroot" "$ret"
1273 		return 1
1274 	fi
1275 
1276 	(cd $testroot/wt && got rebase newbranch > $testroot/stdout \
1277 		2> $testroot/stderr)
1278 
1279 	echo -n > $testroot/stdout.expected
1280 	cmp -s $testroot/stdout.expected $testroot/stdout
1281 	ret=$?
1282 	if [ $ret -ne 0 ]; then
1283 		diff -u $testroot/stdout.expected $testroot/stdout
1284 		test_done "$testroot" "$ret"
1285 		return 1
1286 	fi
1287 
1288 	echo -n "got: work tree must be updated before it can be " \
1289 		> $testroot/stderr.expected
1290 	echo "used to rebase a branch" >> $testroot/stderr.expected
1291 	cmp -s $testroot/stderr.expected $testroot/stderr
1292 	ret=$?
1293 	if [ $ret -ne 0 ]; then
1294 		diff -u $testroot/stderr.expected $testroot/stderr
1295 		test_done "$testroot" "$ret"
1296 		return 1
1297 	fi
1298 
1299 	(cd $testroot/wt && got log -l3 | grep ^commit > $testroot/stdout)
1300 	echo "commit $master_commit2 (master)" > $testroot/stdout.expected
1301 	echo "commit $master_commit1" >> $testroot/stdout.expected
1302 	echo "commit $initial_commit" >> $testroot/stdout.expected
1303 	cmp -s $testroot/stdout.expected $testroot/stdout
1304 	ret=$?
1305 	if [ $ret -ne 0 ]; then
1306 		diff -u $testroot/stdout.expected $testroot/stdout
1307 	fi
1308 	test_done "$testroot" "$ret"
1309 }
1310 
1311 test_rebase_trims_empty_dir() {
1312 	local testroot=`test_init rebase_trims_empty_dir`
1313 
1314 	(cd $testroot/repo && git checkout -q -b newbranch)
1315 	echo "modified delta on branch" > $testroot/repo/gamma/delta
1316 	git_commit $testroot/repo -m "committing to delta on newbranch"
1317 
1318 	(cd $testroot/repo && git rm -q epsilon/zeta)
1319 	git_commit $testroot/repo -m "removing zeta on newbranch"
1320 
1321 	local orig_commit1=`git_show_parent_commit $testroot/repo`
1322 	local orig_commit2=`git_show_head $testroot/repo`
1323 
1324 	(cd $testroot/repo && git checkout -q master)
1325 	echo "modified alpha on master" > $testroot/repo/alpha
1326 	git_commit $testroot/repo -m "committing to alpha on master"
1327 	local master_commit=`git_show_head $testroot/repo`
1328 
1329 	got checkout $testroot/repo $testroot/wt > /dev/null
1330 	ret=$?
1331 	if [ $ret -ne 0 ]; then
1332 		test_done "$testroot" "$ret"
1333 		return 1
1334 	fi
1335 
1336 	(cd $testroot/wt && got rebase newbranch > $testroot/stdout)
1337 
1338 	(cd $testroot/repo && git checkout -q newbranch)
1339 	local new_commit1=`git_show_parent_commit $testroot/repo`
1340 	local new_commit2=`git_show_head $testroot/repo`
1341 
1342 	local short_orig_commit1=`trim_obj_id 28 $orig_commit1`
1343 	local short_orig_commit2=`trim_obj_id 28 $orig_commit2`
1344 	local short_new_commit1=`trim_obj_id 28 $new_commit1`
1345 	local short_new_commit2=`trim_obj_id 28 $new_commit2`
1346 
1347 	echo "G  gamma/delta" >> $testroot/stdout.expected
1348 	echo -n "$short_orig_commit1 -> $short_new_commit1" \
1349 		>> $testroot/stdout.expected
1350 	echo ": committing to delta on newbranch" >> $testroot/stdout.expected
1351 	echo "D  epsilon/zeta" >> $testroot/stdout.expected
1352 	echo -n "$short_orig_commit2 -> $short_new_commit2" \
1353 		>> $testroot/stdout.expected
1354 	echo ": removing zeta on newbranch" \
1355 		>> $testroot/stdout.expected
1356 	echo "Switching work tree to refs/heads/newbranch" \
1357 		>> $testroot/stdout.expected
1358 
1359 	cmp -s $testroot/stdout.expected $testroot/stdout
1360 	ret=$?
1361 	if [ $ret -ne 0 ]; then
1362 		diff -u $testroot/stdout.expected $testroot/stdout
1363 		test_done "$testroot" "$ret"
1364 		return 1
1365 	fi
1366 
1367 	echo "modified delta on branch" > $testroot/content.expected
1368 	cat $testroot/wt/gamma/delta > $testroot/content
1369 	cmp -s $testroot/content.expected $testroot/content
1370 	ret=$?
1371 	if [ $ret -ne 0 ]; then
1372 		diff -u $testroot/content.expected $testroot/content
1373 		test_done "$testroot" "$ret"
1374 		return 1
1375 	fi
1376 
1377 	echo "modified alpha on master" > $testroot/content.expected
1378 	cat $testroot/wt/alpha > $testroot/content
1379 	cmp -s $testroot/content.expected $testroot/content
1380 	ret=$?
1381 	if [ $ret -ne 0 ]; then
1382 		diff -u $testroot/content.expected $testroot/content
1383 		test_done "$testroot" "$ret"
1384 		return 1
1385 	fi
1386 
1387 	if [ -e $testroot/wt/epsilon ]; then
1388 		echo "parent of removed zeta still exists on disk" >&2
1389 		test_done "$testroot" "1"
1390 		return 1
1391 	fi
1392 
1393 	(cd $testroot/wt && got status > $testroot/stdout)
1394 
1395 	echo -n > $testroot/stdout.expected
1396 	cmp -s $testroot/stdout.expected $testroot/stdout
1397 	ret=$?
1398 	if [ $ret -ne 0 ]; then
1399 		diff -u $testroot/stdout.expected $testroot/stdout
1400 		test_done "$testroot" "$ret"
1401 		return 1
1402 	fi
1403 
1404 	(cd $testroot/wt && got log -l3 | grep ^commit > $testroot/stdout)
1405 	echo "commit $new_commit2 (newbranch)" > $testroot/stdout.expected
1406 	echo "commit $new_commit1" >> $testroot/stdout.expected
1407 	echo "commit $master_commit (master)" >> $testroot/stdout.expected
1408 	cmp -s $testroot/stdout.expected $testroot/stdout
1409 	ret=$?
1410 	if [ $ret -ne 0 ]; then
1411 		diff -u $testroot/stdout.expected $testroot/stdout
1412 	fi
1413 	test_done "$testroot" "$ret"
1414 }
1415 
1416 test_rebase_delete_missing_file() {
1417 	local testroot=`test_init rebase_delete_missing_file`
1418 
1419 	mkdir -p $testroot/repo/d/f/g
1420 	echo "new file" > $testroot/repo/d/f/g/new
1421 	(cd $testroot/repo && git add d/f/g/new)
1422 	git_commit $testroot/repo -m "adding a subdir"
1423 	local commit0=`git_show_head $testroot/repo`
1424 
1425 	got br -r $testroot/repo -c master newbranch
1426 
1427 	got checkout -b newbranch $testroot/repo $testroot/wt > /dev/null
1428 
1429 	echo "modified delta on branch" > $testroot/wt/gamma/delta
1430 	(cd $testroot/wt && got commit \
1431 		-m "committing to delta on newbranch" > /dev/null)
1432 
1433 	(cd $testroot/wt && got rm beta d/f/g/new > /dev/null)
1434 	(cd $testroot/wt && got commit \
1435 		-m "removing beta and d/f/g/new on newbranch" > /dev/null)
1436 
1437 	(cd $testroot/repo && git checkout -q newbranch)
1438 	local orig_commit1=`git_show_parent_commit $testroot/repo`
1439 	local orig_commit2=`git_show_head $testroot/repo`
1440 
1441 	local short_orig_commit1=`trim_obj_id 28 $orig_commit1`
1442 	local short_orig_commit2=`trim_obj_id 28 $orig_commit2`
1443 
1444 	(cd $testroot/wt && got update -b master > /dev/null)
1445 	(cd $testroot/wt && got rm beta d/f/g/new > /dev/null)
1446 	(cd $testroot/wt && got commit \
1447 		-m "removing beta and d/f/g/new on master" > /dev/null)
1448 
1449 	(cd $testroot/repo && git checkout -q master)
1450 	local master_commit=`git_show_head $testroot/repo`
1451 
1452 	(cd $testroot/wt && got update -b master > /dev/null)
1453 	(cd $testroot/wt && got rebase newbranch > $testroot/stdout \
1454 		2> $testroot/stderr)
1455 	ret=$?
1456 	if [ $ret -eq 0 ]; then
1457 		echo "rebase succeeded unexpectedly" >&2
1458 		test_done "$testroot" "1"
1459 		return 1
1460 	fi
1461 
1462 	local new_commit1=$(cd $testroot/wt && got info | \
1463 		grep '^work tree base commit: ' | cut -d: -f2 | tr -d ' ')
1464 
1465 	local short_orig_commit2=`trim_obj_id 28 $orig_commit2`
1466 	local short_new_commit1=`trim_obj_id 28 $new_commit1`
1467 
1468 	echo "G  gamma/delta" >> $testroot/stdout.expected
1469 	echo -n "$short_orig_commit1 -> $short_new_commit1" \
1470 		>> $testroot/stdout.expected
1471 	echo ": committing to delta on newbranch" >> $testroot/stdout.expected
1472 	echo "!  beta" >> $testroot/stdout.expected
1473 	echo "!  d/f/g/new" >> $testroot/stdout.expected
1474 	echo -n "Files which had incoming changes but could not be found " \
1475 		>> $testroot/stdout.expected
1476 	echo "in the work tree: 2" >> $testroot/stdout.expected
1477 	cmp -s $testroot/stdout.expected $testroot/stdout
1478 	ret=$?
1479 	if [ $ret -ne 0 ]; then
1480 		diff -u $testroot/stdout.expected $testroot/stdout
1481 		test_done "$testroot" "$ret"
1482 		return 1
1483 	fi
1484 
1485 	echo -n "got: changes destined for some files were not yet merged " \
1486 		> $testroot/stderr.expected
1487 	echo -n "and should be merged manually if required before the " \
1488 		>> $testroot/stderr.expected
1489 	echo "rebase operation is continued" >> $testroot/stderr.expected
1490 	cmp -s $testroot/stderr.expected $testroot/stderr
1491 	ret=$?
1492 	if [ $ret -ne 0 ]; then
1493 		diff -u $testroot/stderr.expected $testroot/stderr
1494 		test_done "$testroot" "$ret"
1495 		return 1
1496 	fi
1497 
1498 	# ignore the missing changes and continue
1499 	(cd $testroot/wt && got rebase -c > $testroot/stdout)
1500 	ret=$?
1501 	if [ $ret -ne 0 ]; then
1502 		echo "rebase failed unexpectedly" >&2
1503 		test_done "$testroot" "1"
1504 		return 1
1505 	fi
1506 	echo -n "$short_orig_commit2 -> no-op change" \
1507 		> $testroot/stdout.expected
1508 	echo ": removing beta and d/f/g/new on newbranch" \
1509 		>> $testroot/stdout.expected
1510 	echo "Switching work tree to refs/heads/newbranch" \
1511 		>> $testroot/stdout.expected
1512 
1513 	cmp -s $testroot/stdout.expected $testroot/stdout
1514 	ret=$?
1515 	if [ $ret -ne 0 ]; then
1516 		diff -u $testroot/stdout.expected $testroot/stdout
1517 		test_done "$testroot" "$ret"
1518 		return 1
1519 	fi
1520 
1521 	echo "modified delta on branch" > $testroot/content.expected
1522 	cat $testroot/wt/gamma/delta > $testroot/content
1523 	cmp -s $testroot/content.expected $testroot/content
1524 	ret=$?
1525 	if [ $ret -ne 0 ]; then
1526 		diff -u $testroot/content.expected $testroot/content
1527 		test_done "$testroot" "$ret"
1528 		return 1
1529 	fi
1530 
1531 	if [ -e $testroot/wt/beta ]; then
1532 		echo "removed file beta still exists on disk" >&2
1533 		test_done "$testroot" "1"
1534 		return 1
1535 	fi
1536 
1537 	(cd $testroot/wt && got status > $testroot/stdout)
1538 
1539 	echo -n > $testroot/stdout.expected
1540 	cmp -s $testroot/stdout.expected $testroot/stdout
1541 	ret=$?
1542 	if [ $ret -ne 0 ]; then
1543 		diff -u $testroot/stdout.expected $testroot/stdout
1544 		test_done "$testroot" "$ret"
1545 		return 1
1546 	fi
1547 
1548 	(cd $testroot/repo && git checkout -q newbranch)
1549 	local new_commit1=`git_show_head $testroot/repo`
1550 	local short_new_commit1=`trim_obj_id 28 $new_commit1`
1551 
1552 	(cd $testroot/wt && got log -l3 | grep ^commit > $testroot/stdout)
1553 	echo "commit $new_commit1 (newbranch)" > $testroot/stdout.expected
1554 	echo "commit $master_commit (master)" >> $testroot/stdout.expected
1555 	echo "commit $commit0" >> $testroot/stdout.expected
1556 	cmp -s $testroot/stdout.expected $testroot/stdout
1557 	ret=$?
1558 	if [ $ret -ne 0 ]; then
1559 		diff -u $testroot/stdout.expected $testroot/stdout
1560 	fi
1561 	test_done "$testroot" "$ret"
1562 }
1563 
1564 test_rebase_rm_add_rm_file() {
1565 	local testroot=`test_init rebase_rm_add_rm_file`
1566 
1567 	(cd $testroot/repo && git checkout -q -b newbranch)
1568 	(cd $testroot/repo && git rm -q beta)
1569 	git_commit $testroot/repo -m "removing beta from newbranch"
1570 	local orig_commit1=`git_show_head $testroot/repo`
1571 
1572 	echo 'restored beta' > $testroot/repo/beta
1573 	(cd $testroot/repo && git add beta)
1574 	git_commit $testroot/repo -m "restoring beta on newbranch"
1575 	local orig_commit2=`git_show_head $testroot/repo`
1576 
1577 	(cd $testroot/repo && git rm -q beta)
1578 	git_commit $testroot/repo -m "removing beta from newbranch again"
1579 	local orig_commit3=`git_show_head $testroot/repo`
1580 
1581 	(cd $testroot/repo && git checkout -q master)
1582 	echo "modified zeta on master" > $testroot/repo/epsilon/zeta
1583 	git_commit $testroot/repo -m "committing to zeta on master"
1584 	local master_commit=`git_show_head $testroot/repo`
1585 
1586 	got checkout $testroot/repo $testroot/wt > /dev/null
1587 	ret=$?
1588 	if [ $ret -ne 0 ]; then
1589 		test_done "$testroot" "$ret"
1590 		return 1
1591 	fi
1592 
1593 	(cd $testroot/wt && got rebase newbranch > $testroot/stdout)
1594 
1595 	# this would error out with 'got: file index is corrupt'
1596 	(cd $testroot/wt && got status > /dev/null)
1597 	ret=$?
1598 	if [ $ret -ne 0 ]; then
1599 		echo "got status command failed unexpectedly" >&2
1600 		test_done "$testroot" "$ret"
1601 		return 1
1602 	fi
1603 
1604 	(cd $testroot/repo && git checkout -q newbranch)
1605 	local new_commit3=`git_show_head $testroot/repo`
1606 	local new_commit2=`git_show_parent_commit $testroot/repo`
1607 	local new_commit1=`git_show_parent_commit $testroot/repo $new_commit2`
1608 
1609 	(cd $testroot/repo && git checkout -q newbranch)
1610 
1611 	local short_orig_commit1=`trim_obj_id 28 $orig_commit1`
1612 	local short_orig_commit2=`trim_obj_id 28 $orig_commit2`
1613 	local short_orig_commit3=`trim_obj_id 28 $orig_commit3`
1614 	local short_new_commit1=`trim_obj_id 28 $new_commit1`
1615 	local short_new_commit2=`trim_obj_id 28 $new_commit2`
1616 	local short_new_commit3=`trim_obj_id 28 $new_commit3`
1617 
1618 	echo "D  beta" > $testroot/stdout.expected
1619 	echo -n "$short_orig_commit1 -> $short_new_commit1" \
1620 		>> $testroot/stdout.expected
1621 	echo ": removing beta from newbranch" >> $testroot/stdout.expected
1622 	echo "A  beta" >> $testroot/stdout.expected
1623 	echo -n "$short_orig_commit2 -> $short_new_commit2" \
1624 		>> $testroot/stdout.expected
1625 	echo ": restoring beta on newbranch" >> $testroot/stdout.expected
1626 	echo "D  beta" >> $testroot/stdout.expected
1627 	echo -n "$short_orig_commit3 -> $short_new_commit3" \
1628 		>> $testroot/stdout.expected
1629 	echo ": removing beta from newbranch again" >> $testroot/stdout.expected
1630 	echo "Switching work tree to refs/heads/newbranch" \
1631 		>> $testroot/stdout.expected
1632 
1633 	cmp -s $testroot/stdout.expected $testroot/stdout
1634 	ret=$?
1635 	if [ $ret -ne 0 ]; then
1636 		diff -u $testroot/stdout.expected $testroot/stdout
1637 		test_done "$testroot" "$ret"
1638 		return 1
1639 	fi
1640 
1641 	(cd $testroot/wt && got status > $testroot/stdout)
1642 	ret=$?
1643 	if [ $ret -ne 0 ]; then
1644 		echo "got status command failed unexpectedly" >&2
1645 		test_done "$testroot" "$ret"
1646 		return 1
1647 	fi
1648 
1649 	echo -n > $testroot/stdout.expected
1650 	cmp -s $testroot/stdout.expected $testroot/stdout
1651 	ret=$?
1652 	if [ $ret -ne 0 ]; then
1653 		diff -u $testroot/stdout.expected $testroot/stdout
1654 		test_done "$testroot" "$ret"
1655 		return 1
1656 	fi
1657 
1658 	(cd $testroot/wt && got log -l4 | grep ^commit > $testroot/stdout)
1659 	echo "commit $new_commit3 (newbranch)" > $testroot/stdout.expected
1660 	echo "commit $new_commit2" >> $testroot/stdout.expected
1661 	echo "commit $new_commit1" >> $testroot/stdout.expected
1662 	echo "commit $master_commit (master)" >> $testroot/stdout.expected
1663 	cmp -s $testroot/stdout.expected $testroot/stdout
1664 	ret=$?
1665 	if [ $ret -ne 0 ]; then
1666 		diff -u $testroot/stdout.expected $testroot/stdout
1667 	fi
1668 	test_done "$testroot" "$ret"
1669 }
1670 
1671 test_rebase_resets_committer() {
1672 	local testroot=`test_init rebase_resets_committer`
1673 	local commit0=`git_show_head $testroot/repo`
1674 	local commit0_author_time=`git_show_author_time $testroot/repo`
1675 	local committer="Flan Luck <flan_luck@openbsd.org>"
1676 
1677 	(cd $testroot/repo && git checkout -q -b newbranch)
1678 	echo "modified delta on branch" > $testroot/repo/gamma/delta
1679 	git_commit $testroot/repo -m "committing to delta on newbranch"
1680 
1681 	echo "modified alpha on branch" > $testroot/repo/alpha
1682 	git_commit $testroot/repo -m "committing more changes on newbranch"
1683 
1684 	local orig_commit1=`git_show_parent_commit $testroot/repo`
1685 	local orig_commit2=`git_show_head $testroot/repo`
1686 	local orig_author_time2=`git_show_author_time $testroot/repo`
1687 
1688 	(cd $testroot/repo && git checkout -q master)
1689 	echo "modified zeta on master" > $testroot/repo/epsilon/zeta
1690 	git_commit $testroot/repo -m "committing to zeta on master"
1691 	local master_commit=`git_show_head $testroot/repo`
1692 
1693 	got checkout $testroot/repo $testroot/wt > /dev/null
1694 	ret=$?
1695 	if [ $ret -ne 0 ]; then
1696 		test_done "$testroot" "$ret"
1697 		return 1
1698 	fi
1699 
1700 	(cd $testroot/wt && env GOT_AUTHOR="$committer" \
1701 		got rebase newbranch > $testroot/stdout)
1702 
1703 	(cd $testroot/repo && git checkout -q newbranch)
1704 	local new_commit1=`git_show_parent_commit $testroot/repo`
1705 	local new_commit2=`git_show_head $testroot/repo`
1706 	local new_author_time2=`git_show_author_time $testroot/repo`
1707 
1708 	local short_orig_commit1=`trim_obj_id 28 $orig_commit1`
1709 	local short_orig_commit2=`trim_obj_id 28 $orig_commit2`
1710 	local short_new_commit1=`trim_obj_id 28 $new_commit1`
1711 	local short_new_commit2=`trim_obj_id 28 $new_commit2`
1712 
1713 	echo "G  gamma/delta" >> $testroot/stdout.expected
1714 	echo -n "$short_orig_commit1 -> $short_new_commit1" \
1715 		>> $testroot/stdout.expected
1716 	echo ": committing to delta on newbranch" >> $testroot/stdout.expected
1717 	echo "G  alpha" >> $testroot/stdout.expected
1718 	echo -n "$short_orig_commit2 -> $short_new_commit2" \
1719 		>> $testroot/stdout.expected
1720 	echo ": committing more changes on newbranch" \
1721 		>> $testroot/stdout.expected
1722 	echo "Switching work tree to refs/heads/newbranch" \
1723 		>> $testroot/stdout.expected
1724 
1725 	cmp -s $testroot/stdout.expected $testroot/stdout
1726 	ret=$?
1727 	if [ $ret -ne 0 ]; then
1728 		diff -u $testroot/stdout.expected $testroot/stdout
1729 		test_done "$testroot" "$ret"
1730 		return 1
1731 	fi
1732 
1733 	# Original commit only had one author
1734 	(cd $testroot/repo && got log -l1 -c $orig_commit2 | \
1735 		egrep '^(from|via):' > $testroot/stdout)
1736 	echo "from: $GOT_AUTHOR" > $testroot/stdout.expected
1737 	cmp -s $testroot/stdout.expected $testroot/stdout
1738 	ret=$?
1739 	if [ $ret -ne 0 ]; then
1740 		diff -u $testroot/stdout.expected $testroot/stdout
1741 		test_done "$testroot" "$ret"
1742 		return 1
1743 	fi
1744 
1745 	# Rebased commit should have new committer name added
1746 	(cd $testroot/repo && got log -l1 -c $new_commit2 | \
1747 		egrep '^(from|via):' > $testroot/stdout)
1748 	echo "from: $GOT_AUTHOR" > $testroot/stdout.expected
1749 	echo "via: $committer" >> $testroot/stdout.expected
1750 
1751 	cmp -s $testroot/stdout.expected $testroot/stdout
1752 	ret=$?
1753 	if [ $ret -ne 0 ]; then
1754 		diff -u $testroot/stdout.expected $testroot/stdout
1755 	fi
1756 	test_done "$testroot" "$ret"
1757 }
1758 
1759 test_rebase_no_author_info() {
1760 	local testroot=`test_init rebase_no_author_info`
1761 	local commit0=`git_show_head $testroot/repo`
1762 	local commit0_author_time=`git_show_author_time $testroot/repo`
1763 	local committer="$GOT_AUTHOR"
1764 
1765 	(cd $testroot/repo && git checkout -q -b newbranch)
1766 	echo "modified delta on branch" > $testroot/repo/gamma/delta
1767 	git_commit $testroot/repo -m "committing to delta on newbranch"
1768 
1769 	echo "modified alpha on branch" > $testroot/repo/alpha
1770 	git_commit $testroot/repo -m "committing more changes on newbranch"
1771 
1772 	local orig_commit1=`git_show_parent_commit $testroot/repo`
1773 	local orig_commit2=`git_show_head $testroot/repo`
1774 	local orig_author_time2=`git_show_author_time $testroot/repo`
1775 
1776 	(cd $testroot/repo && git checkout -q master)
1777 	echo "modified zeta on master" > $testroot/repo/epsilon/zeta
1778 	git_commit $testroot/repo -m "committing to zeta on master"
1779 	local master_commit=`git_show_head $testroot/repo`
1780 
1781 	got checkout $testroot/repo $testroot/wt > /dev/null
1782 	ret=$?
1783 	if [ $ret -ne 0 ]; then
1784 		test_done "$testroot" "$ret"
1785 		return 1
1786 	fi
1787 
1788 	# unset in a subshell to avoid affecting our environment
1789 	(unset GOT_AUTHOR && cd $testroot/wt && \
1790 		got rebase newbranch > $testroot/stdout)
1791 
1792 	(cd $testroot/repo && git checkout -q newbranch)
1793 	local new_commit1=`git_show_parent_commit $testroot/repo`
1794 	local new_commit2=`git_show_head $testroot/repo`
1795 	local new_author_time2=`git_show_author_time $testroot/repo`
1796 
1797 	local short_orig_commit1=`trim_obj_id 28 $orig_commit1`
1798 	local short_orig_commit2=`trim_obj_id 28 $orig_commit2`
1799 	local short_new_commit1=`trim_obj_id 28 $new_commit1`
1800 	local short_new_commit2=`trim_obj_id 28 $new_commit2`
1801 
1802 	echo "G  gamma/delta" >> $testroot/stdout.expected
1803 	echo -n "$short_orig_commit1 -> $short_new_commit1" \
1804 		>> $testroot/stdout.expected
1805 	echo ": committing to delta on newbranch" >> $testroot/stdout.expected
1806 	echo "G  alpha" >> $testroot/stdout.expected
1807 	echo -n "$short_orig_commit2 -> $short_new_commit2" \
1808 		>> $testroot/stdout.expected
1809 	echo ": committing more changes on newbranch" \
1810 		>> $testroot/stdout.expected
1811 	echo "Switching work tree to refs/heads/newbranch" \
1812 		>> $testroot/stdout.expected
1813 
1814 	cmp -s $testroot/stdout.expected $testroot/stdout
1815 	ret=$?
1816 	if [ $ret -ne 0 ]; then
1817 		diff -u $testroot/stdout.expected $testroot/stdout
1818 		test_done "$testroot" "$ret"
1819 		return 1
1820 	fi
1821 
1822 	# Original commit only had one author
1823 	(cd $testroot/repo && got log -l1 -c $orig_commit2 | \
1824 		egrep '^(from|via):' > $testroot/stdout)
1825 	echo "from: $committer" > $testroot/stdout.expected
1826 	cmp -s $testroot/stdout.expected $testroot/stdout
1827 	ret=$?
1828 	if [ $ret -ne 0 ]; then
1829 		diff -u $testroot/stdout.expected $testroot/stdout
1830 		test_done "$testroot" "$ret"
1831 		return 1
1832 	fi
1833 
1834 	# Author info of rebased commit should match the original
1835 	(cd $testroot/repo && got log -l1 -c $new_commit2 | \
1836 		egrep '^(from|via):' > $testroot/stdout)
1837 	echo "from: $committer" > $testroot/stdout.expected
1838 
1839 	cmp -s $testroot/stdout.expected $testroot/stdout
1840 	ret=$?
1841 	if [ $ret -ne 0 ]; then
1842 		diff -u $testroot/stdout.expected $testroot/stdout
1843 	fi
1844 	test_done "$testroot" "$ret"
1845 }
1846 
1847 test_rebase_nonbranch() {
1848 	local testroot=`test_init rebase_nonbranch`
1849 
1850 	got ref -r $testroot/repo -c refs/heads/master \
1851 		refs/remotes/origin/master >/dev/null
1852 	
1853 	got checkout -b master $testroot/repo $testroot/wt >/dev/null
1854 
1855 	(cd $testroot/wt && got rebase origin/master > $testroot/stdout \
1856 		2> $testroot/stderr)
1857 	ret=$?
1858 	if [ $ret -eq 0 ]; then
1859 		echo "rebase succeeded unexpectedly" >&2
1860 		test_done "$testroot" "1"
1861 		return 1
1862 	fi
1863 	echo -n "got: will not rebase a branch which lives outside the " \
1864 		> $testroot/stderr.expected
1865 	echo '"refs/heads/" reference namespace' >> $testroot/stderr.expected
1866 	cmp -s $testroot/stderr.expected $testroot/stderr
1867 	ret=$?
1868 	if [ $ret -ne 0 ]; then
1869 		diff -u $testroot/stderr.expected $testroot/stderr
1870 	fi
1871 	test_done "$testroot" "$ret"
1872 }
1873 
1874 test_rebase_umask() {
1875 	local testroot=`test_init rebase_umask`
1876 	local commit0=`git_show_head "$testroot/repo"`
1877 
1878 	got checkout "$testroot/repo" "$testroot/wt" >/dev/null
1879 	(cd "$testroot/wt" && got branch newbranch) >/dev/null
1880 
1881 	echo "modified alpha on branch" >$testroot/wt/alpha
1882 	(cd "$testroot/wt" && got commit -m 'modified alpha on newbranch') \
1883 		>/dev/null
1884 
1885 	(cd "$testroot/wt" && got update -b master) >/dev/null
1886 	ret=$?
1887 	if [ $ret -ne 0 ]; then
1888 		echo "got update failed!" >&2
1889 		test_done "$testroot" $ret
1890 		return 1
1891 	fi
1892 
1893 	echo "modified beta on master" >$testroot/wt/beta
1894 	(cd "$testroot/wt" && got commit -m 'modified beta on master') \
1895 		>/dev/null
1896 	(cd "$testroot/wt" && got update) >/dev/null
1897 
1898 	# using a subshell to avoid clobbering global umask
1899 	(umask 077 && cd "$testroot/wt" && got rebase newbranch) >/dev/null
1900 	ret=$?
1901 	if [ $ret -ne 0 ]; then
1902 		echo "got rebase failed" >&2
1903 		test_done "$testroot" $ret
1904 		return 1
1905 	fi
1906 
1907 	ls -l "$testroot/wt/alpha" | grep -q ^-rw-------
1908 	if [ $? -ne 0 ]; then
1909 		echo "alpha is not 0600 after rebase" >&2
1910 		ls -l "$testroot/wt/alpha" >&2
1911 		test_done "$testroot" 1
1912 		return 1
1913 	fi
1914 
1915 	test_done "$testroot" 0
1916 }
1917 
1918 test_rebase_out_of_date2() {
1919 	local testroot=`test_init rebase_out_of_date2`
1920 	local commit0=`git_show_head $testroot/repo`
1921 	local commit0_author_time=`git_show_author_time $testroot/repo`
1922 
1923 	(cd $testroot/repo && git checkout -q -b newbranch)
1924 	echo "modified delta on branch" > $testroot/repo/gamma/delta
1925 	git_commit $testroot/repo -m "committing to delta on newbranch"
1926 
1927 	local orig_commit1=`git_show_parent_commit $testroot/repo`
1928 	local orig_commit2=`git_show_head $testroot/repo`
1929 	local orig_author_time2=`git_show_author_time $testroot/repo`
1930 
1931 	(cd $testroot/repo && git checkout -q master)
1932 	echo "modified zeta on master" > $testroot/repo/epsilon/zeta
1933 	git_commit $testroot/repo -m "committing to zeta on master"
1934 	local master_commit=`git_show_head $testroot/repo`
1935 
1936 	got checkout $testroot/repo $testroot/wt > /dev/null
1937 	ret=$?
1938 	if [ $ret -ne 0 ]; then
1939 		test_done "$testroot" "$ret"
1940 		return 1
1941 	fi
1942 
1943 	# Backdate the file alpha to an earlier version.
1944 	# This sets the work tree's base commit ID back to $commit0,
1945 	# which is out-of-date with respect to the master branch.
1946 	(cd $testroot/wt && got update -c $commit0 alpha > /dev/null)
1947 
1948 	# Rebase into an out-of-date work tree should be refused.
1949 	(cd $testroot/wt && got rebase newbranch > $testroot/stdout \
1950 		2> $testroot/stderr)
1951 	ret=$?
1952 	if [ $ret -eq 0 ]; then
1953 		echo "rebase succeeded unexpectedly" >&2
1954 		test_done "$testroot" "1"
1955 		return 1
1956 	fi
1957 	echo -n > $testroot/stdout.expected
1958 	echo -n "got: work tree must be updated before it can be used to " \
1959 		> $testroot/stderr.expected
1960 	echo "rebase a branch" >> $testroot/stderr.expected
1961 	cmp -s $testroot/stderr.expected $testroot/stderr
1962 	ret=$?
1963 	if [ $ret -ne 0 ]; then
1964 		diff -u $testroot/stderr.expected $testroot/stderr
1965 	fi
1966 	test_done "$testroot" "$ret"
1967 }
1968 
1969 test_rebase_one_commit() {
1970 	local testroot=`test_init rebase_one_commit`
1971 
1972 	if ! got checkout $testroot/repo $testroot/wt >/dev/null; then
1973 		test_done "$testroot" 1
1974 		return 1
1975 	fi
1976 
1977 	(cd $testroot/wt && got branch newbranch) >/dev/null
1978 
1979 	echo "modified alpha on newbranch" >$testroot/wt/alpha
1980 	(cd $testroot/wt && got commit -m 'edit alpha') >/dev/null
1981 	(cd $testroot/wt && got update) >/dev/null
1982 	local commit=`git_show_branch_head $testroot/repo newbranch`
1983 
1984 	echo -n '' > $testroot/stderr.expected
1985 
1986 	(cd $testroot/wt && got rebase master >$testroot/stdout \
1987 		2> $testroot/stderr)
1988 	ret=$?
1989 	if [ $ret -ne 0 ]; then
1990 		echo "rebase comand failed unexpectedly" >&2
1991 		diff -u $testroot/stderr.expected $testroot/stderr
1992 		test_done "$testroot" "1"
1993 		return 1
1994 	fi
1995 
1996 	echo "Forwarding refs/heads/master to commit $commit" \
1997 		>$testroot/stdout.expected
1998 	echo "Switching work tree to refs/heads/master" \
1999 		>> $testroot/stdout.expected
2000 
2001 	if ! cmp -s $testroot/stdout.expected $testroot/stdout; then
2002 		diff -u $testroot/stdout.expected $testroot/stdout
2003 		test_done "$testroot" 1
2004 		return 1
2005 	fi
2006 
2007 	test_done "$testroot" 0
2008 }
2009 
2010 test_parseargs "$@"
2011 run_test test_rebase_basic
2012 run_test test_rebase_ancestry_check
2013 run_test test_rebase_continue
2014 run_test test_rebase_abort
2015 run_test test_rebase_no_op_change
2016 run_test test_rebase_in_progress
2017 run_test test_rebase_path_prefix
2018 run_test test_rebase_preserves_logmsg
2019 run_test test_rebase_no_commits_to_rebase
2020 run_test test_rebase_forward
2021 run_test test_rebase_forward_path_prefix
2022 run_test test_rebase_out_of_date
2023 run_test test_rebase_trims_empty_dir
2024 run_test test_rebase_delete_missing_file
2025 run_test test_rebase_rm_add_rm_file
2026 run_test test_rebase_resets_committer
2027 run_test test_rebase_no_author_info
2028 run_test test_rebase_nonbranch
2029 run_test test_rebase_umask
2030 run_test test_rebase_out_of_date2
2031 run_test test_rebase_one_commit