1 #!/bin/sh
2 #
3 # Copyright (c) 2019 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_histedit_no_op() {
20 	local testroot=`test_init histedit_no_op`
21 
22 	local orig_commit=`git_show_head $testroot/repo`
23 	local orig_author_time=`git_show_author_time $testroot/repo`
24 
25 	echo "modified alpha on master" > $testroot/repo/alpha
26 	(cd $testroot/repo && git rm -q beta)
27 	echo "new file on master" > $testroot/repo/epsilon/new
28 	(cd $testroot/repo && git add epsilon/new)
29 	git_commit $testroot/repo -m "committing changes"
30 	local old_commit1=`git_show_head $testroot/repo`
31 	local old_author_time1=`git_show_author_time $testroot/repo`
32 
33 	echo "modified zeta on master" > $testroot/repo/epsilon/zeta
34 	git_commit $testroot/repo -m "committing to zeta on master"
35 	local old_commit2=`git_show_head $testroot/repo`
36 	local old_author_time2=`git_show_author_time $testroot/repo`
37 
38 	got diff -r $testroot/repo $orig_commit $old_commit2 \
39 		> $testroot/diff.expected
40 
41 	got checkout -c $orig_commit $testroot/repo $testroot/wt > /dev/null
42 	ret=$?
43 	if [ $ret -ne 0 ]; then
44 		test_done "$testroot" "$ret"
45 		return 1
46 	fi
47 
48 	echo "pick $old_commit1" > $testroot/histedit-script
49 	echo "pick $old_commit2" >> $testroot/histedit-script
50 
51 	(cd $testroot/wt && got histedit -F $testroot/histedit-script \
52 		> $testroot/stdout)
53 
54 	local new_commit1=`git_show_parent_commit $testroot/repo`
55 	local new_commit2=`git_show_head $testroot/repo`
56 	local new_author_time2=`git_show_author_time $testroot/repo`
57 
58 	local short_old_commit1=`trim_obj_id 28 $old_commit1`
59 	local short_old_commit2=`trim_obj_id 28 $old_commit2`
60 	local short_new_commit1=`trim_obj_id 28 $new_commit1`
61 	local short_new_commit2=`trim_obj_id 28 $new_commit2`
62 
63 	echo "G  alpha" > $testroot/stdout.expected
64 	echo "D  beta" >> $testroot/stdout.expected
65 	echo "A  epsilon/new" >> $testroot/stdout.expected
66 	echo "$short_old_commit1 -> $short_new_commit1: committing changes" \
67 		>> $testroot/stdout.expected
68 	echo "G  epsilon/zeta" >> $testroot/stdout.expected
69 	echo -n "$short_old_commit2 -> $short_new_commit2: " \
70 		>> $testroot/stdout.expected
71 	echo "committing to zeta on master" >> $testroot/stdout.expected
72 	echo "Switching work tree to refs/heads/master" \
73 		>> $testroot/stdout.expected
74 
75 	cmp -s $testroot/stdout.expected $testroot/stdout
76 	ret=$?
77 	if [ $ret -ne 0 ]; then
78 		diff -u $testroot/stdout.expected $testroot/stdout
79 		test_done "$testroot" "$ret"
80 		return 1
81 	fi
82 
83 	echo "modified alpha on master" > $testroot/content.expected
84 	cat $testroot/wt/alpha > $testroot/content
85 	cmp -s $testroot/content.expected $testroot/content
86 	ret=$?
87 	if [ $ret -ne 0 ]; then
88 		diff -u $testroot/content.expected $testroot/content
89 		test_done "$testroot" "$ret"
90 		return 1
91 	fi
92 
93 	if [ -e $testroot/wt/beta ]; then
94 		echo "removed file beta still exists on disk" >&2
95 		test_done "$testroot" "1"
96 		return 1
97 	fi
98 
99 	echo "new file on master" > $testroot/content.expected
100 	cat $testroot/wt/epsilon/new > $testroot/content
101 	cmp -s $testroot/content.expected $testroot/content
102 	ret=$?
103 	if [ $ret -ne 0 ]; then
104 		diff -u $testroot/content.expected $testroot/content
105 		test_done "$testroot" "$ret"
106 		return 1
107 	fi
108 
109 	(cd $testroot/wt && got status > $testroot/stdout)
110 
111 	echo -n > $testroot/stdout.expected
112 	cmp -s $testroot/stdout.expected $testroot/stdout
113 	ret=$?
114 	if [ $ret -ne 0 ]; then
115 		diff -u $testroot/stdout.expected $testroot/stdout
116 		test_done "$testroot" "$ret"
117 		return 1
118 	fi
119 
120 	(cd $testroot/wt && got log -l3 | grep ^commit > $testroot/stdout)
121 	echo "commit $new_commit2 (master)" > $testroot/stdout.expected
122 	echo "commit $new_commit1" >> $testroot/stdout.expected
123 	echo "commit $orig_commit" >> $testroot/stdout.expected
124 	cmp -s $testroot/stdout.expected $testroot/stdout
125 	ret=$?
126 	if [ $ret -ne 0 ]; then
127 		diff -u $testroot/stdout.expected $testroot/stdout
128 		test_done "$testroot" "$ret"
129 		return 1
130 	fi
131 
132 	got diff -r $testroot/repo $orig_commit $new_commit2 \
133 		> $testroot/diff
134 	ed -s $testroot/diff.expected <<-EOF
135 	,s/$old_commit2/$new_commit2/
136 	w
137 	EOF
138 	cmp -s $testroot/diff.expected $testroot/diff
139 	ret=$?
140 	if [ $ret -ne 0 ]; then
141 		diff -u $testroot/diff.expected $testroot/diff
142 		test_done "$testroot" "$ret"
143 		return 1
144 	fi
145 
146 	(cd $testroot/wt && got update > $testroot/stdout)
147 
148 	echo 'Already up-to-date' > $testroot/stdout.expected
149 	cmp -s $testroot/stdout.expected $testroot/stdout
150 	ret=$?
151 	if [ $ret -ne 0 ]; then
152 		diff -u $testroot/stdout.expected $testroot/stdout
153 		test_done "$testroot" "$ret"
154 		return 1
155 	fi
156 
157 	# We should have a backup of old commits
158 	(cd $testroot/repo && got histedit -l > $testroot/stdout)
159 	d_orig1=`date -u -r $old_author_time1 +"%G-%m-%d"`
160 	d_orig2=`date -u -r $old_author_time2 +"%a %b %e %X %Y UTC"`
161 	d_new2=`date -u -r $new_author_time2 +"%G-%m-%d"`
162 	d_orig=`date -u -r $orig_author_time +"%G-%m-%d"`
163 	cat > $testroot/stdout.expected <<EOF
164 -----------------------------------------------
165 commit $old_commit2 (formerly master)
166 from: $GOT_AUTHOR
167 date: $d_orig2
168  
169  committing to zeta on master
170  
171 has become commit $new_commit2 (master)
172  $d_new2 $GOT_AUTHOR_11  committing to zeta on master
173 EOF
174 
175 	local is_forked=true d_fork fork_commit fork_commit_msg
176 
177 	if [ "$old_commit1" = "$new_commit1" ]; then
178 		if [ "$old_commit2" = "$new_commit2" ]; then
179 			is_forked=false
180 		else
181 			d_fork=$d_orig1
182 			fork_commit=$new_commit1
183 			fork_commit_msg="committing changes"
184 		fi
185 	else
186 		d_fork=$d_orig
187 		fork_commit=$orig_commit
188 		fork_commit_msg="adding the test tree"
189 	fi
190 
191 	$is_forked && cat >> $testroot/stdout.expected <<EOF
192 history forked at $fork_commit
193  $d_fork $GOT_AUTHOR_11  $fork_commit_msg
194 EOF
195 
196 	cmp -s $testroot/stdout.expected $testroot/stdout
197 	ret=$?
198 	if [ $ret -ne 0 ]; then
199 		diff -u $testroot/stdout.expected $testroot/stdout
200 		test_done "$testroot" "$ret"
201 		return 1
202 	fi
203 
204 	(cd $testroot/repo && got histedit -X master \
205 		> $testroot/stdout 2> $testroot/stderr)
206 	echo -n "Deleted refs/got/backup/histedit/master/$new_commit2: " \
207 		> $testroot/stdout.expected
208 	echo "$old_commit2" >> $testroot/stdout.expected
209 	echo -n > $testroot/stderr.expected
210 	cmp -s $testroot/stdout.expected $testroot/stdout
211 	ret=$?
212 	if [ $ret -ne 0 ]; then
213 		diff -u $testroot/stdout.expected $testroot/stdout
214 		test_done "$testroot" "$ret"
215 		return 1
216 	fi
217 	cmp -s $testroot/stderr.expected $testroot/stderr
218 	ret=$?
219 	if [ $ret -ne 0 ]; then
220 		diff -u $testroot/stderr.expected $testroot/stderr
221 		test_done "$testroot" "$ret"
222 		return 1
223 	fi
224 
225 	(cd $testroot/repo && got histedit -l > $testroot/stdout)
226 	echo -n > $testroot/stdout.expected
227 	cmp -s $testroot/stdout.expected $testroot/stdout
228 	ret=$?
229 	if [ $ret -ne 0 ]; then
230 		diff -u $testroot/stdout.expected $testroot/stdout
231 	fi
232 	test_done "$testroot" "$ret"
233 }
234 
235 test_histedit_swap() {
236 	local testroot=`test_init histedit_swap`
237 
238 	local orig_commit=`git_show_head $testroot/repo`
239 
240 	echo "modified alpha on master" > $testroot/repo/alpha
241 	(cd $testroot/repo && git rm -q beta)
242 	echo "new file on master" > $testroot/repo/epsilon/new
243 	(cd $testroot/repo && git add epsilon/new)
244 	git_commit $testroot/repo -m "committing changes"
245 	local old_commit1=`git_show_head $testroot/repo`
246 
247 	echo "modified zeta on master" > $testroot/repo/epsilon/zeta
248 	git_commit $testroot/repo -m "committing to zeta on master"
249 	local old_commit2=`git_show_head $testroot/repo`
250 
251 	got diff -r $testroot/repo $orig_commit $old_commit2 \
252 		> $testroot/diff.expected
253 
254 	got checkout -c $orig_commit $testroot/repo $testroot/wt > /dev/null
255 	ret=$?
256 	if [ $ret -ne 0 ]; then
257 		test_done "$testroot" "$ret"
258 		return 1
259 	fi
260 
261 	echo "pick $old_commit2" > $testroot/histedit-script
262 	echo "pick $old_commit1" >> $testroot/histedit-script
263 
264 	(cd $testroot/wt && got histedit -F $testroot/histedit-script \
265 		> $testroot/stdout)
266 
267 	local new_commit2=`git_show_parent_commit $testroot/repo`
268 	local new_commit1=`git_show_head $testroot/repo`
269 
270 	local short_old_commit1=`trim_obj_id 28 $old_commit1`
271 	local short_old_commit2=`trim_obj_id 28 $old_commit2`
272 	local short_new_commit1=`trim_obj_id 28 $new_commit1`
273 	local short_new_commit2=`trim_obj_id 28 $new_commit2`
274 
275 	echo "G  epsilon/zeta" > $testroot/stdout.expected
276 	echo -n "$short_old_commit2 -> $short_new_commit2: " \
277 		>> $testroot/stdout.expected
278 	echo "committing to zeta on master" >> $testroot/stdout.expected
279 	echo "G  alpha" >> $testroot/stdout.expected
280 	echo "D  beta" >> $testroot/stdout.expected
281 	echo "A  epsilon/new" >> $testroot/stdout.expected
282 	echo "$short_old_commit1 -> $short_new_commit1: committing changes" \
283 		>> $testroot/stdout.expected
284 	echo "Switching work tree to refs/heads/master" \
285 		>> $testroot/stdout.expected
286 
287 	cmp -s $testroot/stdout.expected $testroot/stdout
288 	ret=$?
289 	if [ $ret -ne 0 ]; then
290 		diff -u $testroot/stdout.expected $testroot/stdout
291 		test_done "$testroot" "$ret"
292 		return 1
293 	fi
294 
295 	echo "modified alpha on master" > $testroot/content.expected
296 	cat $testroot/wt/alpha > $testroot/content
297 	cmp -s $testroot/content.expected $testroot/content
298 	ret=$?
299 	if [ $ret -ne 0 ]; then
300 		diff -u $testroot/content.expected $testroot/content
301 		test_done "$testroot" "$ret"
302 		return 1
303 	fi
304 
305 	if [ -e $testroot/wt/beta ]; then
306 		echo "removed file beta still exists on disk" >&2
307 		test_done "$testroot" "1"
308 		return 1
309 	fi
310 
311 	echo "new file on master" > $testroot/content.expected
312 	cat $testroot/wt/epsilon/new > $testroot/content
313 	cmp -s $testroot/content.expected $testroot/content
314 	ret=$?
315 	if [ $ret -ne 0 ]; then
316 		diff -u $testroot/content.expected $testroot/content
317 		test_done "$testroot" "$ret"
318 		return 1
319 	fi
320 
321 	(cd $testroot/wt && got status > $testroot/stdout)
322 
323 	echo -n > $testroot/stdout.expected
324 	cmp -s $testroot/stdout.expected $testroot/stdout
325 	ret=$?
326 	if [ $ret -ne 0 ]; then
327 		diff -u $testroot/stdout.expected $testroot/stdout
328 		test_done "$testroot" "$ret"
329 		return 1
330 	fi
331 
332 	(cd $testroot/wt && got log -l3 | grep ^commit > $testroot/stdout)
333 	echo "commit $new_commit1 (master)" > $testroot/stdout.expected
334 	echo "commit $new_commit2" >> $testroot/stdout.expected
335 	echo "commit $orig_commit" >> $testroot/stdout.expected
336 	cmp -s $testroot/stdout.expected $testroot/stdout
337 	ret=$?
338 	if [ $ret -ne 0 ]; then
339 		diff -u $testroot/stdout.expected $testroot/stdout
340 		test_done "$testroot" "$ret"
341 		return 1
342 	fi
343 
344 	got diff -r $testroot/repo $orig_commit $new_commit1 \
345 		> $testroot/diff
346 	ed -s $testroot/diff.expected <<-EOF
347 	,s/$old_commit2/$new_commit1/
348 	w
349 	EOF
350 	cmp -s $testroot/diff.expected $testroot/diff
351 	ret=$?
352 	if [ $ret -ne 0 ]; then
353 		diff -u $testroot/diff.expected $testroot/diff
354 	fi
355 	test_done "$testroot" "$ret"
356 }
357 
358 test_histedit_drop() {
359 	local testroot=`test_init histedit_drop`
360 	local orig_commit=`git_show_head $testroot/repo`
361 
362 	echo "modified alpha on master" > $testroot/repo/alpha
363 	(cd $testroot/repo && git rm -q beta)
364 	echo "new file on master" > $testroot/repo/epsilon/new
365 	(cd $testroot/repo && git add epsilon/new)
366 	git_commit $testroot/repo -m "committing changes"
367 	local old_commit1=`git_show_head $testroot/repo`
368 
369 	echo "modified zeta on master" > $testroot/repo/epsilon/zeta
370 	git_commit $testroot/repo -m "committing to zeta on master"
371 	local old_commit2=`git_show_head $testroot/repo`
372 
373 	got diff -r $testroot/repo $old_commit1 $old_commit2 \
374 		> $testroot/diff.expected
375 
376 	got checkout -c $orig_commit $testroot/repo $testroot/wt > /dev/null
377 	ret=$?
378 	if [ $ret -ne 0 ]; then
379 		test_done "$testroot" "$ret"
380 		return 1
381 	fi
382 
383 	echo "drop $old_commit1" > $testroot/histedit-script
384 	echo "pick $old_commit2" >> $testroot/histedit-script
385 
386 	(cd $testroot/wt && got histedit -F $testroot/histedit-script \
387 		> $testroot/stdout)
388 
389 	local new_commit2=`git_show_head $testroot/repo`
390 
391 	local short_old_commit1=`trim_obj_id 28 $old_commit1`
392 	local short_old_commit2=`trim_obj_id 28 $old_commit2`
393 	local short_new_commit2=`trim_obj_id 28 $new_commit2`
394 
395 	echo "$short_old_commit1 ->  drop commit: committing changes" \
396 		> $testroot/stdout.expected
397 	echo "G  epsilon/zeta" >> $testroot/stdout.expected
398 	echo -n "$short_old_commit2 -> $short_new_commit2: " \
399 		>> $testroot/stdout.expected
400 	echo "committing to zeta on master" >> $testroot/stdout.expected
401 	echo "Switching work tree to refs/heads/master" \
402 		>> $testroot/stdout.expected
403 
404 	cmp -s $testroot/stdout.expected $testroot/stdout
405 	ret=$?
406 	if [ $ret -ne 0 ]; then
407 		diff -u $testroot/stdout.expected $testroot/stdout
408 		test_done "$testroot" "$ret"
409 		return 1
410 	fi
411 
412 	for f in alpha beta; do
413 		echo "$f" > $testroot/content.expected
414 		cat $testroot/wt/$f > $testroot/content
415 		cmp -s $testroot/content.expected $testroot/content
416 		ret=$?
417 		if [ $ret -ne 0 ]; then
418 			diff -u $testroot/content.expected $testroot/content
419 			test_done "$testroot" "$ret"
420 			return 1
421 		fi
422 	done
423 
424 	if [ -e $testroot/wt/new ]; then
425 		echo "file new exists on disk but should not" >&2
426 		test_done "$testroot" "1"
427 		return 1
428 	fi
429 
430 	(cd $testroot/wt && got status > $testroot/stdout)
431 
432 	echo -n > $testroot/stdout.expected
433 	cmp -s $testroot/stdout.expected $testroot/stdout
434 	ret=$?
435 	if [ $ret -ne 0 ]; then
436 		diff -u $testroot/stdout.expected $testroot/stdout
437 		test_done "$testroot" "$ret"
438 		return 1
439 	fi
440 
441 	(cd $testroot/wt && got log -l3 | grep ^commit > $testroot/stdout)
442 	echo "commit $new_commit2 (master)" > $testroot/stdout.expected
443 	echo "commit $orig_commit" >> $testroot/stdout.expected
444 	cmp -s $testroot/stdout.expected $testroot/stdout
445 	ret=$?
446 	if [ $ret -ne 0 ]; then
447 		diff -u $testroot/stdout.expected $testroot/stdout
448 		test_done "$testroot" "$ret"
449 		return 1
450 	fi
451 
452 	got diff -r $testroot/repo $orig_commit $new_commit2 \
453 		> $testroot/diff
454 	ed -s $testroot/diff.expected <<-EOF
455 	,s/$old_commit1/$orig_commit/
456 	,s/$old_commit2/$new_commit2/
457 	w
458 	EOF
459 	cmp -s $testroot/diff.expected $testroot/diff
460 	ret=$?
461 	if [ $ret -ne 0 ]; then
462 		diff -u $testroot/diff.expected $testroot/diff
463 	fi
464 	test_done "$testroot" "$ret"
465 }
466 
467 test_histedit_fold() {
468 	local testroot=`test_init histedit_fold`
469 
470 	local orig_commit=`git_show_head $testroot/repo`
471 
472 	echo "modified alpha on master" > $testroot/repo/alpha
473 	(cd $testroot/repo && git rm -q beta)
474 	echo "new file on master" > $testroot/repo/epsilon/new
475 	(cd $testroot/repo && git add epsilon/new)
476 	git_commit $testroot/repo -m "committing changes"
477 	local old_commit1=`git_show_head $testroot/repo`
478 
479 	echo "modified zeta on master" > $testroot/repo/epsilon/zeta
480 	git_commit $testroot/repo -m "committing to zeta on master"
481 	local old_commit2=`git_show_head $testroot/repo`
482 
483 	echo "modified delta on master" > $testroot/repo/gamma/delta
484 	git_commit $testroot/repo -m "committing to delta on master"
485 	local old_commit3=`git_show_head $testroot/repo`
486 
487 	got checkout -c $orig_commit $testroot/repo $testroot/wt > /dev/null
488 	ret=$?
489 	if [ $ret -ne 0 ]; then
490 		test_done "$testroot" "$ret"
491 		return 1
492 	fi
493 
494 	echo "fold $old_commit1" > $testroot/histedit-script
495 	echo "drop $old_commit2" >> $testroot/histedit-script
496 	echo "pick $old_commit3" >> $testroot/histedit-script
497 	echo "mesg committing folded changes" >> $testroot/histedit-script
498 
499 	(cd $testroot/wt && got histedit -F $testroot/histedit-script \
500 		> $testroot/stdout)
501 
502 	local new_commit1=`git_show_parent_commit $testroot/repo`
503 	local new_commit2=`git_show_head $testroot/repo`
504 
505 	local short_old_commit1=`trim_obj_id 28 $old_commit1`
506 	local short_old_commit2=`trim_obj_id 28 $old_commit2`
507 	local short_old_commit3=`trim_obj_id 28 $old_commit3`
508 	local short_new_commit1=`trim_obj_id 28 $new_commit1`
509 	local short_new_commit2=`trim_obj_id 28 $new_commit2`
510 
511 	echo "G  alpha" > $testroot/stdout.expected
512 	echo "D  beta" >> $testroot/stdout.expected
513 	echo "A  epsilon/new" >> $testroot/stdout.expected
514 	echo "$short_old_commit1 ->  fold commit: committing changes" \
515 		>> $testroot/stdout.expected
516 	echo -n "$short_old_commit2 ->  " >> $testroot/stdout.expected
517 	echo "drop commit: committing to zeta on master" \
518 		>> $testroot/stdout.expected
519 	echo "G  gamma/delta" >> $testroot/stdout.expected
520 	echo -n "$short_old_commit3 -> $short_new_commit2: " \
521 		>> $testroot/stdout.expected
522 	echo "committing folded changes" >> $testroot/stdout.expected
523 	echo "Switching work tree to refs/heads/master" \
524 		>> $testroot/stdout.expected
525 
526 	cmp -s $testroot/stdout.expected $testroot/stdout
527 	ret=$?
528 	if [ $ret -ne 0 ]; then
529 		diff -u $testroot/stdout.expected $testroot/stdout
530 		test_done "$testroot" "$ret"
531 		return 1
532 	fi
533 
534 	echo "modified alpha on master" > $testroot/content.expected
535 	cat $testroot/wt/alpha > $testroot/content
536 	cmp -s $testroot/content.expected $testroot/content
537 	ret=$?
538 	if [ $ret -ne 0 ]; then
539 		diff -u $testroot/content.expected $testroot/content
540 		test_done "$testroot" "$ret"
541 		return 1
542 	fi
543 
544 	if [ -e $testroot/wt/beta ]; then
545 		echo "removed file beta still exists on disk" >&2
546 		test_done "$testroot" "1"
547 		return 1
548 	fi
549 
550 	echo "new file on master" > $testroot/content.expected
551 	cat $testroot/wt/epsilon/new > $testroot/content
552 	cmp -s $testroot/content.expected $testroot/content
553 	ret=$?
554 	if [ $ret -ne 0 ]; then
555 		diff -u $testroot/content.expected $testroot/content
556 		test_done "$testroot" "$ret"
557 		return 1
558 	fi
559 
560 	(cd $testroot/wt && got status > $testroot/stdout)
561 
562 	echo -n > $testroot/stdout.expected
563 	cmp -s $testroot/stdout.expected $testroot/stdout
564 	ret=$?
565 	if [ $ret -ne 0 ]; then
566 		diff -u $testroot/stdout.expected $testroot/stdout
567 		test_done "$testroot" "$ret"
568 		return 1
569 	fi
570 
571 	(cd $testroot/wt && got log -l3 | grep ^commit > $testroot/stdout)
572 	echo "commit $new_commit2 (master)" > $testroot/stdout.expected
573 	echo "commit $orig_commit" >> $testroot/stdout.expected
574 	cmp -s $testroot/stdout.expected $testroot/stdout
575 	ret=$?
576 	if [ $ret -ne 0 ]; then
577 		diff -u $testroot/stdout.expected $testroot/stdout
578 	fi
579 	test_done "$testroot" "$ret"
580 }
581 
582 test_histedit_edit() {
583 	local testroot=`test_init histedit_edit`
584 
585 	local orig_commit=`git_show_head $testroot/repo`
586 
587 	echo "modified alpha on master" > $testroot/repo/alpha
588 	(cd $testroot/repo && git rm -q beta)
589 	echo "new file on master" > $testroot/repo/epsilon/new
590 	(cd $testroot/repo && git add epsilon/new)
591 	git_commit $testroot/repo -m "committing changes"
592 	local old_commit1=`git_show_head $testroot/repo`
593 
594 	echo "modified zeta on master" > $testroot/repo/epsilon/zeta
595 	git_commit $testroot/repo -m "committing to zeta on master"
596 	local old_commit2=`git_show_head $testroot/repo`
597 
598 	got checkout -c $orig_commit $testroot/repo $testroot/wt > /dev/null
599 	ret=$?
600 	if [ $ret -ne 0 ]; then
601 		test_done "$testroot" "$ret"
602 		return 1
603 	fi
604 
605 	echo "edit $old_commit1" > $testroot/histedit-script
606 	echo "mesg committing changes" >> $testroot/histedit-script
607 	echo "pick $old_commit2" >> $testroot/histedit-script
608 
609 	(cd $testroot/wt && got histedit -F $testroot/histedit-script \
610 		> $testroot/stdout)
611 
612 	local short_old_commit1=`trim_obj_id 28 $old_commit1`
613 	local short_old_commit2=`trim_obj_id 28 $old_commit2`
614 
615 	echo "G  alpha" > $testroot/stdout.expected
616 	echo "D  beta" >> $testroot/stdout.expected
617 	echo "A  epsilon/new" >> $testroot/stdout.expected
618 	echo "Stopping histedit for amending commit $old_commit1" \
619 		>> $testroot/stdout.expected
620 	cmp -s $testroot/stdout.expected $testroot/stdout
621 	ret=$?
622 	if [ $ret -ne 0 ]; then
623 		diff -u $testroot/stdout.expected $testroot/stdout
624 		test_done "$testroot" "$ret"
625 		return 1
626 	fi
627 
628 	echo "edited modified alpha on master" > $testroot/wt/alpha
629 
630 	# test interaction of 'got stage' and histedit -c
631 	(cd $testroot/wt && got stage alpha > /dev/null)
632 	(cd $testroot/wt && got histedit -c > $testroot/stdout \
633 		2> $testroot/stderr)
634 	ret=$?
635 	if [ $ret -eq 0 ]; then
636 		echo "histedit succeeded unexpectedly" >&2
637 		test_done "$testroot" "1"
638 		return 1
639 	fi
640 	echo -n "got: work tree contains files with staged changes; " \
641 		> $testroot/stderr.expected
642 	echo "these changes must be committed or unstaged first" \
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 	(cd $testroot/wt && got unstage alpha > /dev/null)
653 	(cd $testroot/wt && got histedit -c > $testroot/stdout)
654 
655 	local new_commit1=`git_show_parent_commit $testroot/repo`
656 	local new_commit2=`git_show_head $testroot/repo`
657 
658 	local short_new_commit1=`trim_obj_id 28 $new_commit1`
659 	local short_new_commit2=`trim_obj_id 28 $new_commit2`
660 
661 	echo "$short_old_commit1 -> $short_new_commit1: committing changes" \
662 		> $testroot/stdout.expected
663 	echo "G  epsilon/zeta" >> $testroot/stdout.expected
664 	echo -n "$short_old_commit2 -> $short_new_commit2: " \
665 		>> $testroot/stdout.expected
666 	echo "committing to zeta on master" >> $testroot/stdout.expected
667 	echo "Switching work tree to refs/heads/master" \
668 		>> $testroot/stdout.expected
669 
670 	cmp -s $testroot/stdout.expected $testroot/stdout
671 	ret=$?
672 	if [ $ret -ne 0 ]; then
673 		diff -u $testroot/stdout.expected $testroot/stdout
674 		test_done "$testroot" "$ret"
675 		return 1
676 	fi
677 
678 	echo "edited modified alpha on master" > $testroot/content.expected
679 	cat $testroot/wt/alpha > $testroot/content
680 	cmp -s $testroot/content.expected $testroot/content
681 	ret=$?
682 	if [ $ret -ne 0 ]; then
683 		diff -u $testroot/content.expected $testroot/content
684 		test_done "$testroot" "$ret"
685 		return 1
686 	fi
687 
688 	if [ -e $testroot/wt/beta ]; then
689 		echo "removed file beta still exists on disk" >&2
690 		test_done "$testroot" "1"
691 		return 1
692 	fi
693 
694 	echo "new file on master" > $testroot/content.expected
695 	cat $testroot/wt/epsilon/new > $testroot/content
696 	cmp -s $testroot/content.expected $testroot/content
697 	ret=$?
698 	if [ $ret -ne 0 ]; then
699 		diff -u $testroot/content.expected $testroot/content
700 		test_done "$testroot" "$ret"
701 		return 1
702 	fi
703 
704 	(cd $testroot/wt && got status > $testroot/stdout)
705 
706 	echo -n > $testroot/stdout.expected
707 	cmp -s $testroot/stdout.expected $testroot/stdout
708 	ret=$?
709 	if [ $ret -ne 0 ]; then
710 		diff -u $testroot/stdout.expected $testroot/stdout
711 		test_done "$testroot" "$ret"
712 		return 1
713 	fi
714 
715 	(cd $testroot/wt && got log -l3 | grep ^commit > $testroot/stdout)
716 	echo "commit $new_commit2 (master)" > $testroot/stdout.expected
717 	echo "commit $new_commit1" >> $testroot/stdout.expected
718 	echo "commit $orig_commit" >> $testroot/stdout.expected
719 	cmp -s $testroot/stdout.expected $testroot/stdout
720 	ret=$?
721 	if [ $ret -ne 0 ]; then
722 		diff -u $testroot/stdout.expected $testroot/stdout
723 	fi
724 	test_done "$testroot" "$ret"
725 }
726 
727 test_histedit_fold_last_commit() {
728 	local testroot=`test_init histedit_fold_last_commit`
729 
730 	local orig_commit=`git_show_head $testroot/repo`
731 
732 	echo "modified alpha on master" > $testroot/repo/alpha
733 	(cd $testroot/repo && git rm -q beta)
734 	echo "new file on master" > $testroot/repo/epsilon/new
735 	(cd $testroot/repo && git add epsilon/new)
736 	git_commit $testroot/repo -m "committing changes"
737 	local old_commit1=`git_show_head $testroot/repo`
738 
739 	echo "modified zeta on master" > $testroot/repo/epsilon/zeta
740 	git_commit $testroot/repo -m "committing to zeta on master"
741 	local old_commit2=`git_show_head $testroot/repo`
742 
743 	got checkout -c $orig_commit $testroot/repo $testroot/wt > /dev/null
744 	ret=$?
745 	if [ $ret -ne 0 ]; then
746 		test_done "$testroot" "$ret"
747 		return 1
748 	fi
749 
750 	echo "pick $old_commit1" > $testroot/histedit-script
751 	echo "fold $old_commit2" >> $testroot/histedit-script
752 
753 	(cd $testroot/wt && got histedit -F $testroot/histedit-script \
754 		> $testroot/stdout 2> $testroot/stderr)
755 
756 	ret=$?
757 	if [ $ret -eq 0 ]; then
758 		echo "histedit succeeded unexpectedly" >&2
759 		test_done "$testroot" "1"
760 		return 1
761 	fi
762 
763 	echo "got: last commit in histedit script cannot be folded" \
764 		> $testroot/stderr.expected
765 
766 	cmp -s $testroot/stderr.expected $testroot/stderr
767 	ret=$?
768 	if [ $ret -ne 0 ]; then
769 		diff -u $testroot/stderr.expected $testroot/stderr
770 	fi
771 	test_done "$testroot" "$ret"
772 }
773 
774 test_histedit_missing_commit() {
775 	local testroot=`test_init histedit_missing_commit`
776 
777 	local orig_commit=`git_show_head $testroot/repo`
778 
779 	echo "modified alpha on master" > $testroot/repo/alpha
780 	(cd $testroot/repo && git rm -q beta)
781 	echo "new file on master" > $testroot/repo/epsilon/new
782 	(cd $testroot/repo && git add epsilon/new)
783 	git_commit $testroot/repo -m "committing changes"
784 	local old_commit1=`git_show_head $testroot/repo`
785 
786 	echo "modified zeta on master" > $testroot/repo/epsilon/zeta
787 	git_commit $testroot/repo -m "committing to zeta on master"
788 	local old_commit2=`git_show_head $testroot/repo`
789 
790 	got checkout -c $orig_commit $testroot/repo $testroot/wt > /dev/null
791 	ret=$?
792 	if [ $ret -ne 0 ]; then
793 		test_done "$testroot" "$ret"
794 		return 1
795 	fi
796 
797 	echo "pick $old_commit1" > $testroot/histedit-script
798 	echo "mesg committing changes" >> $testroot/histedit-script
799 
800 	(cd $testroot/wt && got histedit -F $testroot/histedit-script \
801 		> $testroot/stdout 2> $testroot/stderr)
802 
803 	ret=$?
804 	if [ $ret -eq 0 ]; then
805 		echo "histedit succeeded unexpectedly" >&2
806 		test_done "$testroot" "1"
807 		return 1
808 	fi
809 
810 	echo "got: commit $old_commit2 missing from histedit script" \
811 		> $testroot/stderr.expected
812 
813 	cmp -s $testroot/stderr.expected $testroot/stderr
814 	ret=$?
815 	if [ $ret -ne 0 ]; then
816 		diff -u $testroot/stderr.expected $testroot/stderr
817 	fi
818 	test_done "$testroot" "$ret"
819 }
820 
821 test_histedit_abort() {
822 	local testroot=`test_init histedit_abort`
823 
824 	local orig_commit=`git_show_head $testroot/repo`
825 
826 	echo "modified alpha on master" > $testroot/repo/alpha
827 	(cd $testroot/repo && git rm -q beta)
828 	echo "new file on master" > $testroot/repo/epsilon/new
829 	(cd $testroot/repo && git add epsilon/new)
830 	git_commit $testroot/repo -m "committing changes"
831 	local old_commit1=`git_show_head $testroot/repo`
832 
833 	echo "modified zeta on master" > $testroot/repo/epsilon/zeta
834 	git_commit $testroot/repo -m "committing to zeta on master"
835 	local old_commit2=`git_show_head $testroot/repo`
836 
837 	got checkout -c $orig_commit $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 	# unrelated unversioned file in work tree
845 	touch $testroot/wt/unversioned-file
846 
847 	echo "edit $old_commit1" > $testroot/histedit-script
848 	echo "mesg committing changes" >> $testroot/histedit-script
849 	echo "pick $old_commit2" >> $testroot/histedit-script
850 
851 	(cd $testroot/wt && got histedit -F $testroot/histedit-script \
852 		> $testroot/stdout)
853 
854 	local short_old_commit1=`trim_obj_id 28 $old_commit1`
855 	local short_old_commit2=`trim_obj_id 28 $old_commit2`
856 
857 	echo "G  alpha" > $testroot/stdout.expected
858 	echo "D  beta" >> $testroot/stdout.expected
859 	echo "A  epsilon/new" >> $testroot/stdout.expected
860 	echo "Stopping histedit for amending commit $old_commit1" \
861 		>> $testroot/stdout.expected
862 	cmp -s $testroot/stdout.expected $testroot/stdout
863 	ret=$?
864 	if [ $ret -ne 0 ]; then
865 		diff -u $testroot/stdout.expected $testroot/stdout
866 		test_done "$testroot" "$ret"
867 		return 1
868 	fi
869 
870 	echo "edited modified alpha on master" > $testroot/wt/alpha
871 
872 	(cd $testroot/wt && got histedit -a > $testroot/stdout)
873 
874 	local new_commit1=`git_show_parent_commit $testroot/repo`
875 	local new_commit2=`git_show_head $testroot/repo`
876 
877 	echo "Switching work tree to refs/heads/master" \
878 		> $testroot/stdout.expected
879 	echo "R  alpha" >> $testroot/stdout.expected
880 	echo "R  beta" >> $testroot/stdout.expected
881 	echo "R  epsilon/new" >> $testroot/stdout.expected
882 	echo "Histedit of refs/heads/master aborted" \
883 		>> $testroot/stdout.expected
884 
885 	cmp -s $testroot/stdout.expected $testroot/stdout
886 	ret=$?
887 	if [ $ret -ne 0 ]; then
888 		diff -u $testroot/stdout.expected $testroot/stdout
889 		test_done "$testroot" "$ret"
890 		return 1
891 	fi
892 
893 	for f in alpha beta; do
894 		echo "$f" > $testroot/content.expected
895 		cat $testroot/wt/$f > $testroot/content
896 		cmp -s $testroot/content.expected $testroot/content
897 		ret=$?
898 		if [ $ret -ne 0 ]; then
899 			diff -u $testroot/content.expected $testroot/content
900 			test_done "$testroot" "$ret"
901 			return 1
902 		fi
903 	done
904 
905 	if [ -e $testroot/wt/epsilon/new ]; then
906 		echo "removed file new still exists on disk" >&2
907 		test_done "$testroot" "1"
908 		return 1
909 	fi
910 
911 	(cd $testroot/wt && got status > $testroot/stdout)
912 
913 	echo "?  unversioned-file" > $testroot/stdout.expected
914 	cmp -s $testroot/stdout.expected $testroot/stdout
915 	ret=$?
916 	if [ $ret -ne 0 ]; then
917 		diff -u $testroot/stdout.expected $testroot/stdout
918 		test_done "$testroot" "$ret"
919 		return 1
920 	fi
921 
922 	(cd $testroot/wt && got log -l3 | grep ^commit > $testroot/stdout)
923 	echo "commit $new_commit2 (master)" > $testroot/stdout.expected
924 	echo "commit $new_commit1" >> $testroot/stdout.expected
925 	echo "commit $orig_commit" >> $testroot/stdout.expected
926 	cmp -s $testroot/stdout.expected $testroot/stdout
927 	ret=$?
928 	if [ $ret -ne 0 ]; then
929 		diff -u $testroot/stdout.expected $testroot/stdout
930 	fi
931 	test_done "$testroot" "$ret"
932 }
933 
934 test_histedit_path_prefix_drop() {
935 	local testroot=`test_init histedit_path_prefix_drop`
936 	local orig_commit=`git_show_head $testroot/repo`
937 
938 	echo "modified zeta" > $testroot/repo/epsilon/zeta
939 	git_commit $testroot/repo -m "changing zeta"
940 	local old_commit1=`git_show_head $testroot/repo`
941 
942 	got checkout -c $orig_commit -p gamma $testroot/repo \
943 		$testroot/wt > /dev/null
944 	ret=$?
945 	if [ $ret -ne 0 ]; then
946 		test_done "$testroot" "$ret"
947 		return 1
948 	fi
949 
950 	echo "drop $old_commit1" > $testroot/histedit-script
951 
952 	(cd $testroot/wt && got histedit -F $testroot/histedit-script \
953 		> $testroot/stdout 2> $testroot/stderr)
954 
955 	ret=$?
956 	if [ $ret -eq 0 ]; then
957 		echo "histedit succeeded unexpectedly" >&2
958 		test_done "$testroot" "1"
959 		return 1
960 	fi
961 
962 	echo -n "got: cannot edit branch history which contains changes " \
963 		> $testroot/stderr.expected
964 	echo "outside of this work tree's path prefix" \
965 		>> $testroot/stderr.expected
966 
967 	cmp -s $testroot/stderr.expected $testroot/stderr
968 	ret=$?
969 	if [ $ret -ne 0 ]; then
970 		diff -u $testroot/stderr.expected $testroot/stderr
971 		test_done "$testroot" "$ret"
972 		return 1
973 	fi
974 
975 	rm -rf $testroot/wt
976 	got checkout -c $orig_commit -p epsilon $testroot/repo \
977 		$testroot/wt > /dev/null
978 	ret=$?
979 	if [ $ret -ne 0 ]; then
980 		test_done "$testroot" "$ret"
981 		return 1
982 	fi
983 	(cd $testroot/wt && got histedit -F $testroot/histedit-script \
984 		> $testroot/stdout)
985 
986 	local short_old_commit1=`trim_obj_id 28 $old_commit1`
987 	local short_old_commit2=`trim_obj_id 28 $old_commit2`
988 
989 	echo "$short_old_commit1 ->  drop commit: changing zeta" \
990 		> $testroot/stdout.expected
991 	echo "Switching work tree to refs/heads/master" \
992 		>> $testroot/stdout.expected
993 
994 	cmp -s $testroot/stdout.expected $testroot/stdout
995 	ret=$?
996 	if [ $ret -ne 0 ]; then
997 		diff -u $testroot/stdout.expected $testroot/stdout
998 		test_done "$testroot" "$ret"
999 		return 1
1000 	fi
1001 
1002 	echo "zeta" > $testroot/content.expected
1003 	cat $testroot/wt/zeta > $testroot/content
1004 	cmp -s $testroot/content.expected $testroot/content
1005 	ret=$?
1006 	if [ $ret -ne 0 ]; then
1007 		diff -u $testroot/content.expected $testroot/content
1008 		test_done "$testroot" "$ret"
1009 		return 1
1010 	fi
1011 
1012 
1013 	(cd $testroot/wt && got status > $testroot/stdout)
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 log -l3 | grep ^commit > $testroot/stdout)
1025 	echo "commit $orig_commit (master)" > $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_histedit_path_prefix_edit() {
1035 	local testroot=`test_init histedit_path_prefix_edit`
1036 	local orig_commit=`git_show_head $testroot/repo`
1037 
1038 	echo "modified zeta" > $testroot/repo/epsilon/zeta
1039 	git_commit $testroot/repo -m "changing zeta"
1040 	local old_commit1=`git_show_head $testroot/repo`
1041 
1042 	got diff -r $testroot/repo $orig_commit $old_commit1 \
1043 		> $testroot/diff.expected
1044 
1045 	got checkout -c $orig_commit -p gamma $testroot/repo \
1046 		$testroot/wt > /dev/null
1047 	ret=$?
1048 	if [ $ret -ne 0 ]; then
1049 		test_done "$testroot" "$ret"
1050 		return 1
1051 	fi
1052 
1053 	echo "edit $old_commit1" > $testroot/histedit-script
1054 	echo "mesg modified zeta" >> $testroot/histedit-script
1055 
1056 	(cd $testroot/wt && got histedit -F $testroot/histedit-script \
1057 		> $testroot/stdout 2> $testroot/stderr)
1058 
1059 	ret=$?
1060 	if [ $ret -eq 0 ]; then
1061 		echo "histedit succeeded unexpectedly" >&2
1062 		test_done "$testroot" "1"
1063 		return 1
1064 	fi
1065 
1066 	echo -n "got: cannot edit branch history which contains changes " \
1067 		> $testroot/stderr.expected
1068 	echo "outside of this work tree's path prefix" \
1069 		>> $testroot/stderr.expected
1070 
1071 	cmp -s $testroot/stderr.expected $testroot/stderr
1072 	ret=$?
1073 	if [ $ret -ne 0 ]; then
1074 		diff -u $testroot/stderr.expected $testroot/stderr
1075 		test_done "$testroot" "$ret"
1076 		return 1
1077 	fi
1078 
1079 	rm -rf $testroot/wt
1080 	got checkout -c $orig_commit -p epsilon $testroot/repo \
1081 		$testroot/wt > /dev/null
1082 	ret=$?
1083 	if [ $ret -ne 0 ]; then
1084 		test_done "$testroot" "$ret"
1085 		return 1
1086 	fi
1087 	(cd $testroot/wt && got histedit -F $testroot/histedit-script \
1088 		> $testroot/stdout)
1089 
1090 	local short_old_commit1=`trim_obj_id 28 $old_commit1`
1091 
1092 	echo "G  zeta" > $testroot/stdout.expected
1093 	echo "Stopping histedit for amending commit $old_commit1" \
1094 		>> $testroot/stdout.expected
1095 	cmp -s $testroot/stdout.expected $testroot/stdout
1096 	ret=$?
1097 	if [ $ret -ne 0 ]; then
1098 		diff -u $testroot/stdout.expected $testroot/stdout
1099 		test_done "$testroot" "$ret"
1100 		return 1
1101 	fi
1102 
1103 	echo "modified zeta" > $testroot/content.expected
1104 	cat $testroot/wt/zeta > $testroot/content
1105 	cmp -s $testroot/content.expected $testroot/content
1106 	ret=$?
1107 	if [ $ret -ne 0 ]; then
1108 		diff -u $testroot/content.expected $testroot/content
1109 		test_done "$testroot" "$ret"
1110 		return 1
1111 	fi
1112 
1113 	(cd $testroot/wt && got status > $testroot/stdout)
1114 
1115 	echo "M  zeta"> $testroot/stdout.expected
1116 	cmp -s $testroot/stdout.expected $testroot/stdout
1117 	ret=$?
1118 	if [ $ret -ne 0 ]; then
1119 		diff -u $testroot/stdout.expected $testroot/stdout
1120 		test_done "$testroot" "$ret"
1121 		return 1
1122 	fi
1123 
1124 	(cd $testroot/wt && got histedit -c > $testroot/stdout)
1125 
1126 	local new_commit1=`git_show_head $testroot/repo`
1127 	local short_new_commit1=`trim_obj_id 28 $new_commit1`
1128 
1129 	echo -n "$short_old_commit1 -> $short_new_commit1: " \
1130 		> $testroot/stdout.expected
1131 	echo "modified zeta" >> $testroot/stdout.expected
1132 	echo "Switching work tree to refs/heads/master" \
1133 		>> $testroot/stdout.expected
1134 
1135 	cmp -s $testroot/stdout.expected $testroot/stdout
1136 	ret=$?
1137 	if [ $ret -ne 0 ]; then
1138 		diff -u $testroot/stdout.expected $testroot/stdout
1139 		test_done "$testroot" "$ret"
1140 		return 1
1141 	fi
1142 
1143 	(cd $testroot/wt && got log -l3 | grep ^commit > $testroot/stdout)
1144 	echo "commit $new_commit1 (master)" > $testroot/stdout.expected
1145 	echo "commit $orig_commit" >> $testroot/stdout.expected
1146 	cmp -s $testroot/stdout.expected $testroot/stdout
1147 	ret=$?
1148 	if [ $ret -ne 0 ]; then
1149 		diff -u $testroot/stdout.expected $testroot/stdout
1150 		test_done "$testroot" "$ret"
1151 		return 1
1152 	fi
1153 
1154 	got diff -r $testroot/repo $orig_commit $new_commit1 \
1155 		> $testroot/diff
1156 	ed -s $testroot/diff.expected <<-EOF
1157 	,s/$old_commit1/$new_commit1/
1158 	w
1159 	EOF
1160 	cmp -s $testroot/diff.expected $testroot/diff
1161 	ret=$?
1162 	if [ $ret -ne 0 ]; then
1163 		diff -u $testroot/diff.expected $testroot/diff
1164 	fi
1165 	test_done "$testroot" "$ret"
1166 }
1167 
1168 test_histedit_outside_refs_heads() {
1169 	local testroot=`test_init histedit_outside_refs_heads`
1170 	local commit1=`git_show_head $testroot/repo`
1171 
1172 	got checkout $testroot/repo $testroot/wt > /dev/null
1173 	ret=$?
1174 	if [ $ret -ne 0 ]; then
1175 		echo "got checkout failed unexpectedly"
1176 		test_done "$testroot" "$ret"
1177 		return 1
1178 	fi
1179 
1180 	echo "modified alpha" > $testroot/wt/alpha
1181 
1182 	(cd $testroot/wt && got commit -m 'change alpha' \
1183 		> $testroot/stdout 2> $testroot/stderr)
1184 	ret=$?
1185 	if [ $ret -ne 0 ]; then
1186 		echo "got commit failed unexpectedly" >&2
1187 		test_done "$testroot" "1"
1188 		return 1
1189 	fi
1190 	local commit2=`git_show_head $testroot/repo`
1191 
1192 	got ref -r $testroot/repo -c master refs/remotes/origin/master
1193 	ret=$?
1194 	if [ $ret -ne 0 ]; then
1195 		echo "got ref failed unexpectedly" >&2
1196 		test_done "$testroot" "1"
1197 		return 1
1198 	fi
1199 
1200 	(cd $testroot/wt && got update -b origin/master -c $commit1 >/dev/null)
1201 	ret=$?
1202 	if [ $ret -ne 0 ]; then
1203 		echo "got update failed unexpectedly"
1204 		test_done "$testroot" "$ret"
1205 		return 1
1206 	fi
1207 
1208 	echo "edit $commit2" > $testroot/histedit-script
1209 	(cd $testroot/wt && got histedit -F $testroot/histedit-script \
1210 		2> $testroot/stderr)
1211 
1212 	echo -n "got: will not edit commit history of a branch outside the " \
1213 		> $testroot/stderr.expected
1214 	echo '"refs/heads/" reference namespace' \
1215 		>> $testroot/stderr.expected
1216 	cmp -s $testroot/stderr.expected $testroot/stderr
1217 	ret=$?
1218 	if [ $ret -ne 0 ]; then
1219 		diff -u $testroot/stderr.expected $testroot/stderr
1220 	fi
1221 	test_done "$testroot" "$ret"
1222 }
1223 
1224 test_histedit_fold_last_commit_swap() {
1225 	local testroot=`test_init histedit_fold_last_commit_swap`
1226 
1227 	local orig_commit=`git_show_head $testroot/repo`
1228 
1229 	echo "modified alpha on master" > $testroot/repo/alpha
1230 	(cd $testroot/repo && git rm -q beta)
1231 	echo "new file on master" > $testroot/repo/epsilon/new
1232 	(cd $testroot/repo && git add epsilon/new)
1233 	git_commit $testroot/repo -m "committing changes"
1234 	local old_commit1=`git_show_head $testroot/repo`
1235 
1236 	echo "modified zeta on master" > $testroot/repo/epsilon/zeta
1237 	git_commit $testroot/repo -m "committing to zeta on master"
1238 	local old_commit2=`git_show_head $testroot/repo`
1239 
1240 	got checkout -c $orig_commit $testroot/repo $testroot/wt > /dev/null
1241 	ret=$?
1242 	if [ $ret -ne 0 ]; then
1243 		test_done "$testroot" "$ret"
1244 		return 1
1245 	fi
1246 
1247 	# fold commit2 into commit1 (requires swapping commits)
1248 	echo "fold $old_commit2" > $testroot/histedit-script
1249 	echo "pick $old_commit1" >> $testroot/histedit-script
1250 	echo "mesg committing folded changes" >> $testroot/histedit-script
1251 
1252 	(cd $testroot/wt && got histedit -F $testroot/histedit-script \
1253 		> $testroot/stdout 2> $testroot/stderr)
1254 
1255 	ret=$?
1256 	if [ $ret -ne 0 ]; then
1257 		echo "histedit failed unexpectedly" >&2
1258 		test_done "$testroot" "$ret"
1259 		return 1
1260 	fi
1261 
1262 	local new_commit=`git_show_head $testroot/repo`
1263 
1264 	local short_old_commit1=`trim_obj_id 28 $old_commit1`
1265 	local short_old_commit2=`trim_obj_id 28 $old_commit2`
1266 	local short_new_commit=`trim_obj_id 28 $new_commit`
1267 
1268 	echo "G  epsilon/zeta" >> $testroot/stdout.expected
1269 	echo -n "$short_old_commit2 ->  fold commit: committing to zeta " \
1270 		>> $testroot/stdout.expected
1271 	echo "on master" >> $testroot/stdout.expected
1272 	echo "G  alpha" >> $testroot/stdout.expected
1273 	echo "D  beta" >> $testroot/stdout.expected
1274 	echo "A  epsilon/new" >> $testroot/stdout.expected
1275 	echo -n "$short_old_commit1 -> $short_new_commit: " \
1276 		>> $testroot/stdout.expected
1277 	echo "committing folded changes" >> $testroot/stdout.expected
1278 	echo "Switching work tree to refs/heads/master" \
1279 		>> $testroot/stdout.expected
1280 
1281 	cmp -s $testroot/stdout.expected $testroot/stdout
1282 	ret=$?
1283 	if [ $ret -ne 0 ]; then
1284 		diff -u $testroot/stdout.expected $testroot/stdout
1285 	fi
1286 	test_done "$testroot" "$ret"
1287 }
1288 
1289 test_histedit_split_commit() {
1290 	local testroot=`test_init histedit_split_commit`
1291 
1292 	local orig_commit=`git_show_head $testroot/repo`
1293 
1294 	echo "modified alpha on master" > $testroot/repo/alpha
1295 	(cd $testroot/repo && git rm -q beta)
1296 	echo "new file on master" > $testroot/repo/epsilon/new
1297 	(cd $testroot/repo && git add epsilon/new)
1298 	git_commit $testroot/repo -m "committing changes 1"
1299 	local old_commit1=`git_show_head $testroot/repo`
1300 	local short_old_commit1=`trim_obj_id 28 $old_commit1`
1301 
1302 	echo "modified zeta on master" > $testroot/repo/epsilon/zeta
1303 	git_commit $testroot/repo -m "committing changes 2"
1304 	local old_commit2=`git_show_head $testroot/repo`
1305 	local short_old_commit2=`trim_obj_id 28 $old_commit2`
1306 
1307 	got checkout -c $orig_commit $testroot/repo $testroot/wt > /dev/null
1308 	ret=$?
1309 	if [ $ret -ne 0 ]; then
1310 		test_done "$testroot" "$ret"
1311 		return 1
1312 	fi
1313 
1314 	# split commit1 into commitA and commitB and commitC
1315 	echo "e $old_commit1" > $testroot/histedit-script
1316 	echo "p $old_commit2" >> $testroot/histedit-script
1317 
1318 	(cd $testroot/wt && got histedit -F $testroot/histedit-script \
1319 		> $testroot/stdout 2> $testroot/stderr)
1320 	ret=$?
1321 	if [ $ret -ne 0 ]; then
1322 		echo "histedit failed unexpectedly:" >&2
1323 		cat $testroot/stderr >&2
1324 		test_done "$testroot" "$ret"
1325 		return 1
1326 	fi
1327 
1328 	echo "G  alpha" > $testroot/stdout.expected
1329 	echo "D  beta" >> $testroot/stdout.expected
1330 	echo "A  epsilon/new" >> $testroot/stdout.expected
1331 	echo "Stopping histedit for amending commit $old_commit1" \
1332 		>> $testroot/stdout.expected
1333 
1334 	cmp -s $testroot/stdout.expected $testroot/stdout
1335 	ret=$?
1336 	if [ $ret -ne 0 ]; then
1337 		diff -u $testroot/stdout.expected $testroot/stdout
1338 		test_done "$testroot" "$ret"
1339 		return 1
1340 	fi
1341 
1342 	(cd $testroot/wt && got ci -m "commitA" alpha >/dev/null)
1343 	ret=$?
1344 	if [ $ret -ne 0 ]; then
1345 		echo "commit failed unexpectedly" >&2
1346 		test_done "$testroot" "$ret"
1347 		return 1
1348 	fi
1349 
1350 	(cd $testroot/wt && got ci -m "commitB" beta >/dev/null)
1351 	ret=$?
1352 	if [ $ret -ne 0 ]; then
1353 		echo "commit failed unexpectedly" >&2
1354 		test_done "$testroot" "$ret"
1355 		return 1
1356 	fi
1357 
1358 	(cd $testroot/wt && got ci -m "commitC" epsilon/new >/dev/null)
1359 	ret=$?
1360 	if [ $ret -ne 0 ]; then
1361 		echo "commit failed unexpectedly" >&2
1362 		test_done "$testroot" "$ret"
1363 		return 1
1364 	fi
1365 
1366 	(cd $testroot/wt && got histedit -c \
1367 		> $testroot/stdout 2> $testroot/stderr)
1368 	ret=$?
1369 	if [ $ret -ne 0 ]; then
1370 		echo "histedit failed unexpectedly:" >&2
1371 		cat $testroot/stderr >&2
1372 		test_done "$testroot" "$ret"
1373 		return 1
1374 	fi
1375 	local new_commit2=`git_show_head $testroot/repo`
1376 	local short_new_commit2=`trim_obj_id 28 $new_commit2`
1377 
1378 	echo "$short_old_commit1 -> no-op change: committing changes 1" \
1379 		> $testroot/stdout.expected
1380 	echo "G  epsilon/zeta" >> $testroot/stdout.expected
1381 	echo "$short_old_commit2 -> $short_new_commit2: committing changes 2" \
1382 		>> $testroot/stdout.expected
1383 	echo "Switching work tree to refs/heads/master" \
1384 		>> $testroot/stdout.expected
1385 
1386 	cmp -s $testroot/stdout.expected $testroot/stdout
1387 	ret=$?
1388 	if [ $ret -ne 0 ]; then
1389 		diff -u $testroot/stdout.expected $testroot/stdout
1390 	fi
1391 	test_done "$testroot" "$ret"
1392 
1393 }
1394 
1395 test_histedit_duplicate_commit_in_script() {
1396 	local testroot=`test_init histedit_duplicate_commit_in_script`
1397 
1398 	local orig_commit=`git_show_head $testroot/repo`
1399 
1400 	echo "modified alpha on master" > $testroot/repo/alpha
1401 	(cd $testroot/repo && git rm -q beta)
1402 	echo "new file on master" > $testroot/repo/epsilon/new
1403 	(cd $testroot/repo && git add epsilon/new)
1404 	git_commit $testroot/repo -m "committing changes 1"
1405 	local old_commit1=`git_show_head $testroot/repo`
1406 
1407 	echo "modified zeta on master" > $testroot/repo/epsilon/zeta
1408 	git_commit $testroot/repo -m "committing changes 2"
1409 	local old_commit2=`git_show_head $testroot/repo`
1410 
1411 	got checkout -c $orig_commit $testroot/repo $testroot/wt > /dev/null
1412 	ret=$?
1413 	if [ $ret -ne 0 ]; then
1414 		test_done "$testroot" "$ret"
1415 		return 1
1416 	fi
1417 
1418 	# This histedit script lists commit1 more than once
1419 	echo "p $old_commit1" > $testroot/histedit-script
1420 	echo "p $old_commit1" >> $testroot/histedit-script
1421 	echo "p $old_commit2" >> $testroot/histedit-script
1422 
1423 	(cd $testroot/wt && got histedit -F $testroot/histedit-script \
1424 		> $testroot/stdout 2> $testroot/stderr)
1425 	ret=$?
1426 	if [ $ret -eq 0 ]; then
1427 		echo "histedit succeeded unexpectedly:" >&2
1428 		cat $testroot/stdout >&2
1429 		test_done "$testroot" "$ret"
1430 		return 1
1431 	fi
1432 
1433 	echo -n "got: commit $old_commit1 is listed more than once " \
1434 		> $testroot/stderr.expected
1435 	echo "in histedit script" >> $testroot/stderr.expected
1436 
1437 	cmp -s $testroot/stderr.expected $testroot/stderr
1438 	ret=$?
1439 	if [ $ret -ne 0 ]; then
1440 		diff -u $testroot/stderr.expected $testroot/stderr
1441 	fi
1442 	test_done "$testroot" "$ret"
1443 
1444 }
1445 
1446 # if a previous commit introduces a new file, and it is folded into a commit
1447 # that deletes the same file, the file still exists after the histedit
1448 test_histedit_fold_add_delete() {
1449 	local testroot=`test_init histedit_fold_add_delete`
1450 
1451 	local orig_commit=`git_show_head $testroot/repo`
1452 
1453 	echo "added new file epsilon/psi" > $testroot/repo/epsilon/psi
1454 	(cd $testroot/repo && git add epsilon/psi)
1455 	git_commit $testroot/repo -m "committing changes"
1456 	local old_commit1=`git_show_head $testroot/repo`
1457 
1458 	echo "modified epsilon/psi" > $testroot/repo/epsilon/psi
1459 	git_commit $testroot/repo -m "editing psi"
1460 	local old_commit2=`git_show_head $testroot/repo`
1461 
1462 	(cd $testroot/repo && git rm -q epsilon/psi)
1463 	git_commit $testroot/repo -m "removing psi"
1464 	local old_commit3=`git_show_head $testroot/repo`
1465 
1466 	got checkout -c $orig_commit $testroot/repo $testroot/wt > /dev/null
1467 	ret=$?
1468 	if [ $ret -ne 0 ]; then
1469 		test_done "$testroot" "$ret"
1470 		return 1
1471 	fi
1472 
1473 	echo "fold $old_commit1" > $testroot/histedit-script
1474 	echo "fold $old_commit2" >> $testroot/histedit-script
1475 	echo "pick $old_commit3" >> $testroot/histedit-script
1476 	echo "mesg folded changes" >> $testroot/histedit-script
1477 
1478 	(cd $testroot/wt && got histedit -F $testroot/histedit-script \
1479 		> $testroot/stdout)
1480 
1481 	local new_commit1=`git_show_head $testroot/repo`
1482 
1483 	local short_old_commit1=`trim_obj_id 28 $old_commit1`
1484 	local short_old_commit2=`trim_obj_id 28 $old_commit2`
1485 	local short_old_commit3=`trim_obj_id 28 $old_commit3`
1486 	local short_new_commit1=`trim_obj_id 28 $new_commit1`
1487 
1488 	echo "A  epsilon/psi" >> $testroot/stdout.expected
1489 	echo "$short_old_commit1 ->  fold commit: committing changes" \
1490 		>> $testroot/stdout.expected
1491 	echo "G  epsilon/psi" >> $testroot/stdout.expected
1492 	echo "$short_old_commit2 ->  fold commit: editing psi" \
1493 		>> $testroot/stdout.expected
1494 	echo "D  epsilon/psi" >> $testroot/stdout.expected
1495 	echo "$short_old_commit3 -> no-op change: folded changes" \
1496 		>> $testroot/stdout.expected
1497 	echo "Switching work tree to refs/heads/master" \
1498 		>> $testroot/stdout.expected
1499 
1500 	cmp -s $testroot/stdout.expected $testroot/stdout
1501 	ret=$?
1502 	if [ $ret -ne 0 ]; then
1503 		diff -u $testroot/stdout.expected $testroot/stdout
1504 		test_done "$testroot" "$ret"
1505 		return 1
1506 	fi
1507 
1508 	if [ -e $testroot/wt/epsilon/psi ]; then
1509 		echo "removed file psi still exists on disk" >&2
1510 		test_done "$testroot" "1"
1511 		return 1
1512 	fi
1513 
1514 	(cd $testroot/wt && got status > $testroot/stdout)
1515 
1516 	echo -n > $testroot/stdout.expected
1517 	cmp -s $testroot/stdout.expected $testroot/stdout
1518 	ret=$?
1519 	if [ $ret -ne 0 ]; then
1520 		diff -u $testroot/stdout.expected $testroot/stdout
1521 		test_done "$testroot" "$ret"
1522 		return 1
1523 	fi
1524 
1525 	(cd $testroot/wt && got log -l3 | grep ^commit > $testroot/stdout)
1526 	echo "commit $new_commit1 (master)" > $testroot/stdout.expected
1527 	cmp -s $testroot/stdout.expected $testroot/stdout
1528 	ret=$?
1529 	if [ $ret -ne 0 ]; then
1530 		diff -u $testroot/stdout.expected $testroot/stdout
1531 		test_done "$testroot" "$ret"
1532 		return 1
1533 	fi
1534 
1535 	got tree -r $testroot/repo epsilon > $testroot/stdout
1536 	echo "zeta" > $testroot/stdout.expected
1537 	cmp -s $testroot/stdout.expected $testroot/stdout
1538 	ret=$?
1539 	if [ $ret -ne 0 ]; then
1540 		diff -u $testroot/stdout.expected $testroot/stdout
1541 	fi
1542 	test_done "$testroot" "$ret"
1543 }
1544 
1545 test_histedit_fold_delete_add() {
1546 	local testroot=`test_init histedit_fold_delete_add`
1547 
1548 	local orig_commit=`git_show_head $testroot/repo`
1549 
1550 	(cd $testroot/repo && git rm -q alpha)
1551 	git_commit $testroot/repo -m "removing alpha"
1552 	local old_commit1=`git_show_head $testroot/repo`
1553 
1554 	echo "modified alpha" >$testroot/repo/alpha
1555 	(cd $testroot/repo && git add alpha)
1556 	git_commit $testroot/repo -m "add back modified alpha"
1557 	local old_commit2=`git_show_head $testroot/repo`
1558 
1559 	got checkout -c $orig_commit $testroot/repo $testroot/wt > /dev/null
1560 	ret=$?
1561 	if [ $ret -ne 0 ]; then
1562 		test_done "$testroot" "$ret"
1563 		return 1
1564 	fi
1565 
1566 	echo "fold $old_commit1" > $testroot/histedit-script
1567 	echo "pick $old_commit2" >> $testroot/histedit-script
1568 	echo "mesg folded changes" >> $testroot/histedit-script
1569 
1570 	(cd $testroot/wt && got histedit -F $testroot/histedit-script \
1571 		> $testroot/stdout)
1572 
1573 	local new_commit1=`git_show_head $testroot/repo`
1574 	
1575 	local short_old_commit1=`trim_obj_id 28 $old_commit1`
1576 	local short_old_commit2=`trim_obj_id 28 $old_commit2`
1577 	local short_new_commit1=`trim_obj_id 28 $new_commit1`
1578 
1579 	echo "D  alpha" > $testroot/stdout.expected
1580 	echo "$short_old_commit1 ->  fold commit: removing alpha" \
1581 		>> $testroot/stdout.expected
1582 	echo "A  alpha" >> $testroot/stdout.expected
1583 	echo "$short_old_commit2 -> $short_new_commit1: folded changes" \
1584 		>> $testroot/stdout.expected
1585 	echo "Switching work tree to refs/heads/master" \
1586 		>> $testroot/stdout.expected
1587 
1588 	cmp -s $testroot/stdout.expected $testroot/stdout
1589 	ret=$?
1590 	if [ $ret -ne 0 ]; then
1591 		diff -u $testroot/stdout.expected $testroot/stdout
1592 		test_done "$testroot" "$ret"
1593 		return 1
1594 	fi
1595 
1596 	if [ ! -e $testroot/wt/alpha ]; then
1597 		echo "file alpha is missing on disk" >&2
1598 		test_done "$testroot" "1"
1599 		return 1
1600 	fi
1601 
1602 	echo "modified alpha" > $testroot/content.expected
1603 	cat $testroot/wt/alpha > $testroot/content
1604 	cmp -s $testroot/content.expected $testroot/content
1605 	ret=$?
1606 	if [ $ret -ne 0 ]; then
1607 		diff -u $testroot/content.expected $testroot/content
1608 		test_done "$testroot" "$ret"
1609 		return 1
1610 	fi
1611 	test_done "$testroot" "0"
1612 }
1613 
1614 test_histedit_fold_only() {
1615 	local testroot=`test_init histedit_fold_only`
1616 
1617 	local orig_commit=`git_show_head $testroot/repo`
1618 
1619 	echo "modified alpha on master" > $testroot/repo/alpha
1620 	(cd $testroot/repo && git rm -q beta)
1621 	echo "new file on master" > $testroot/repo/epsilon/new
1622 	(cd $testroot/repo && git add epsilon/new)
1623 	git_commit $testroot/repo -m "committing changes"
1624 	local old_commit1=`git_show_head $testroot/repo`
1625 
1626 	echo "modified zeta on master" > $testroot/repo/epsilon/zeta
1627 	git_commit $testroot/repo -m "committing to zeta on master"
1628 	local old_commit2=`git_show_head $testroot/repo`
1629 
1630 	echo "modified delta on master" > $testroot/repo/gamma/delta
1631 	git_commit $testroot/repo -m "committing to delta on master"
1632 	local old_commit3=`git_show_head $testroot/repo`
1633 
1634 	got checkout -c $orig_commit $testroot/repo $testroot/wt > /dev/null
1635 	ret=$?
1636 	if [ $ret -ne 0 ]; then
1637 		test_done "$testroot" "$ret"
1638 		return 1
1639 	fi
1640 
1641 	cat > $testroot/editor.sh <<EOF
1642 #!/bin/sh
1643 ed -s "\$1" <<-EOF
1644 	,s/.*/committing folded changes/
1645 	w
1646 	EOF
1647 EOF
1648 	chmod +x $testroot/editor.sh
1649 
1650 	(cd $testroot/wt && env EDITOR="$testroot/editor.sh" \
1651 		VISUAL="$testroot/editor.sh" got histedit -f > $testroot/stdout)
1652 
1653 	local new_commit1=`git_show_head $testroot/repo`
1654 
1655 	local short_old_commit1=`trim_obj_id 28 $old_commit1`
1656 	local short_old_commit2=`trim_obj_id 28 $old_commit2`
1657 	local short_old_commit3=`trim_obj_id 28 $old_commit3`
1658 	local short_new_commit1=`trim_obj_id 28 $new_commit1`
1659 	local short_new_commit2=`trim_obj_id 28 $new_commit2`
1660 
1661 	echo "G  alpha" > $testroot/stdout.expected
1662 	echo "D  beta" >> $testroot/stdout.expected
1663 	echo "A  epsilon/new" >> $testroot/stdout.expected
1664 	echo "$short_old_commit1 ->  fold commit: committing changes" \
1665 		>> $testroot/stdout.expected
1666 	echo "G  epsilon/zeta" >> $testroot/stdout.expected
1667 	echo -n "$short_old_commit2 ->  " >> $testroot/stdout.expected
1668 	echo "fold commit: committing to zeta on master" \
1669 		>> $testroot/stdout.expected
1670 	echo "G  gamma/delta" >> $testroot/stdout.expected
1671 	echo -n "$short_old_commit3 -> $short_new_commit1: " \
1672 		>> $testroot/stdout.expected
1673 	echo "committing folded changes" >> $testroot/stdout.expected
1674 	echo "Switching work tree to refs/heads/master" \
1675 		>> $testroot/stdout.expected
1676 
1677 	cmp -s $testroot/stdout.expected $testroot/stdout
1678 	ret=$?
1679 	if [ $ret -ne 0 ]; then
1680 		diff -u $testroot/stdout.expected $testroot/stdout
1681 		test_done "$testroot" "$ret"
1682 		return 1
1683 	fi
1684 
1685 	echo "modified alpha on master" > $testroot/content.expected
1686 	cat $testroot/wt/alpha > $testroot/content
1687 	cmp -s $testroot/content.expected $testroot/content
1688 	ret=$?
1689 	if [ $ret -ne 0 ]; then
1690 		diff -u $testroot/content.expected $testroot/content
1691 		test_done "$testroot" "$ret"
1692 		return 1
1693 	fi
1694 
1695 	if [ -e $testroot/wt/beta ]; then
1696 		echo "removed file beta still exists on disk" >&2
1697 		test_done "$testroot" "1"
1698 		return 1
1699 	fi
1700 
1701 	echo "new file on master" > $testroot/content.expected
1702 	cat $testroot/wt/epsilon/new > $testroot/content
1703 	cmp -s $testroot/content.expected $testroot/content
1704 	ret=$?
1705 	if [ $ret -ne 0 ]; then
1706 		diff -u $testroot/content.expected $testroot/content
1707 		test_done "$testroot" "$ret"
1708 		return 1
1709 	fi
1710 
1711 	(cd $testroot/wt && got status > $testroot/stdout)
1712 
1713 	echo -n > $testroot/stdout.expected
1714 	cmp -s $testroot/stdout.expected $testroot/stdout
1715 	ret=$?
1716 	if [ $ret -ne 0 ]; then
1717 		diff -u $testroot/stdout.expected $testroot/stdout
1718 		test_done "$testroot" "$ret"
1719 		return 1
1720 	fi
1721 
1722 	(cd $testroot/wt && got log | grep ^commit > $testroot/stdout)
1723 	echo "commit $new_commit1 (master)" > $testroot/stdout.expected
1724 	echo "commit $orig_commit" >> $testroot/stdout.expected
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 	fi
1730 	test_done "$testroot" "$ret"
1731 }
1732 
1733 test_histedit_fold_only_empty_logmsg() {
1734 	local testroot=`test_init histedit_fold_only_empty_logmsg`
1735 
1736 	local orig_commit=`git_show_head $testroot/repo`
1737 
1738 	echo "modified alpha on master" > $testroot/repo/alpha
1739 	(cd $testroot/repo && git rm -q beta)
1740 	echo "new file on master" > $testroot/repo/epsilon/new
1741 	(cd $testroot/repo && git add epsilon/new)
1742 	git_commit $testroot/repo -m "committing changes"
1743 	local old_commit1=`git_show_head $testroot/repo`
1744 
1745 	echo "modified zeta on master" > $testroot/repo/epsilon/zeta
1746 	git_commit $testroot/repo -m "committing to zeta on master"
1747 	local old_commit2=`git_show_head $testroot/repo`
1748 
1749 	echo "modified delta on master" > $testroot/repo/gamma/delta
1750 	git_commit $testroot/repo -m "committing to delta on master"
1751 	local old_commit3=`git_show_head $testroot/repo`
1752 
1753 	got checkout -c $orig_commit $testroot/repo $testroot/wt > /dev/null
1754 	ret=$?
1755 	if [ $ret -ne 0 ]; then
1756 		test_done "$testroot" "$ret"
1757 		return 1
1758 	fi
1759 
1760 	cat > $testroot/editor.sh <<EOF
1761 #!/bin/sh
1762 ed -s "\$1" <<-EOF
1763 	,d
1764 	w
1765 	EOF
1766 EOF
1767 	chmod +x $testroot/editor.sh
1768 
1769 	(cd $testroot/wt && env EDITOR="$testroot/editor.sh" \
1770 		VISUAL="$testroot/editor.sh" got histedit -f > $testroot/stdout)
1771 
1772 	local new_commit1=`git_show_head $testroot/repo`
1773 
1774 	local short_old_commit1=`trim_obj_id 28 $old_commit1`
1775 	local very_short_old_commit1=`trim_obj_id 29 $old_commit1`
1776 	local short_old_commit2=`trim_obj_id 28 $old_commit2`
1777 	local short_old_commit3=`trim_obj_id 28 $old_commit3`
1778 	local short_new_commit1=`trim_obj_id 28 $new_commit1`
1779 	local short_new_commit2=`trim_obj_id 28 $new_commit2`
1780 
1781 	echo "G  alpha" > $testroot/stdout.expected
1782 	echo "D  beta" >> $testroot/stdout.expected
1783 	echo "A  epsilon/new" >> $testroot/stdout.expected
1784 	echo "$short_old_commit1 ->  fold commit: committing changes" \
1785 		>> $testroot/stdout.expected
1786 	echo "G  epsilon/zeta" >> $testroot/stdout.expected
1787 	echo -n "$short_old_commit2 ->  " >> $testroot/stdout.expected
1788 	echo "fold commit: committing to zeta on master" \
1789 		>> $testroot/stdout.expected
1790 	echo "G  gamma/delta" >> $testroot/stdout.expected
1791 	echo -n "$short_old_commit3 -> $short_new_commit1: " \
1792 		>> $testroot/stdout.expected
1793 	echo "# log message of folded commit $very_short_old_commit1" \
1794 		>> $testroot/stdout.expected
1795 	echo "Switching work tree to refs/heads/master" \
1796 		>> $testroot/stdout.expected
1797 
1798 	cmp -s $testroot/stdout.expected $testroot/stdout
1799 	ret=$?
1800 	if [ $ret -ne 0 ]; then
1801 		diff -u $testroot/stdout.expected $testroot/stdout
1802 		test_done "$testroot" "$ret"
1803 		return 1
1804 	fi
1805 
1806 	echo "modified alpha on master" > $testroot/content.expected
1807 	cat $testroot/wt/alpha > $testroot/content
1808 	cmp -s $testroot/content.expected $testroot/content
1809 	ret=$?
1810 	if [ $ret -ne 0 ]; then
1811 		diff -u $testroot/content.expected $testroot/content
1812 		test_done "$testroot" "$ret"
1813 		return 1
1814 	fi
1815 
1816 	if [ -e $testroot/wt/beta ]; then
1817 		echo "removed file beta still exists on disk" >&2
1818 		test_done "$testroot" "1"
1819 		return 1
1820 	fi
1821 
1822 	echo "new file on master" > $testroot/content.expected
1823 	cat $testroot/wt/epsilon/new > $testroot/content
1824 	cmp -s $testroot/content.expected $testroot/content
1825 	ret=$?
1826 	if [ $ret -ne 0 ]; then
1827 		diff -u $testroot/content.expected $testroot/content
1828 		test_done "$testroot" "$ret"
1829 		return 1
1830 	fi
1831 
1832 	(cd $testroot/wt && got status > $testroot/stdout)
1833 
1834 	echo -n > $testroot/stdout.expected
1835 	cmp -s $testroot/stdout.expected $testroot/stdout
1836 	ret=$?
1837 	if [ $ret -ne 0 ]; then
1838 		diff -u $testroot/stdout.expected $testroot/stdout
1839 		test_done "$testroot" "$ret"
1840 		return 1
1841 	fi
1842 
1843 	(cd $testroot/wt && got log | grep ^commit > $testroot/stdout)
1844 	echo "commit $new_commit1 (master)" > $testroot/stdout.expected
1845 	echo "commit $orig_commit" >> $testroot/stdout.expected
1846 	cmp -s $testroot/stdout.expected $testroot/stdout
1847 	ret=$?
1848 	if [ $ret -ne 0 ]; then
1849 		diff -u $testroot/stdout.expected $testroot/stdout
1850 	fi
1851 	test_done "$testroot" "$ret"
1852 }
1853 
1854 test_histedit_edit_only() {
1855 	local testroot=`test_init histedit_edit_only`
1856 
1857 	local orig_commit=`git_show_head $testroot/repo`
1858 
1859 	echo "modified alpha on master" > $testroot/repo/alpha
1860 	(cd $testroot/repo && git rm -q beta)
1861 	echo "new file on master" > $testroot/repo/epsilon/new
1862 	(cd $testroot/repo && git add epsilon/new)
1863 	git_commit $testroot/repo -m "committing changes"
1864 	local old_commit1=`git_show_head $testroot/repo`
1865 
1866 	echo "modified zeta on master" > $testroot/repo/epsilon/zeta
1867 	git_commit $testroot/repo -m "committing to zeta on master"
1868 	local old_commit2=`git_show_head $testroot/repo`
1869 
1870 	got checkout -c $orig_commit $testroot/repo $testroot/wt > /dev/null
1871 	ret=$?
1872 	if [ $ret -ne 0 ]; then
1873 		test_done "$testroot" "$ret"
1874 		return 1
1875 	fi
1876 
1877 	(cd $testroot/wt && got histedit -e > $testroot/stdout)
1878 
1879 	local short_old_commit1=`trim_obj_id 28 $old_commit1`
1880 	local short_old_commit2=`trim_obj_id 28 $old_commit2`
1881 
1882 	echo "G  alpha" > $testroot/stdout.expected
1883 	echo "D  beta" >> $testroot/stdout.expected
1884 	echo "A  epsilon/new" >> $testroot/stdout.expected
1885 	echo "Stopping histedit for amending commit $old_commit1" \
1886 		>> $testroot/stdout.expected
1887 	cmp -s $testroot/stdout.expected $testroot/stdout
1888 	ret=$?
1889 	if [ $ret -ne 0 ]; then
1890 		diff -u $testroot/stdout.expected $testroot/stdout
1891 		test_done "$testroot" "$ret"
1892 		return 1
1893 	fi
1894 
1895 	echo "edited modified alpha on master" > $testroot/wt/alpha
1896 
1897 	cat > $testroot/editor.sh <<EOF
1898 #!/bin/sh
1899 ed -s "\$1" <<-EOF
1900 	,s/.*/committing edited changes 1/
1901 	w
1902 	EOF
1903 EOF
1904 	chmod +x $testroot/editor.sh
1905 
1906 	(cd $testroot/wt && env EDITOR="$testroot/editor.sh" \
1907 		VISUAL="$testroot/editor.sh" got histedit -c > $testroot/stdout)
1908 
1909 	local new_commit1=$(cd $testroot/wt && got info | \
1910 		grep '^work tree base commit: ' | cut -d: -f2 | tr -d ' ')
1911 	local short_new_commit1=`trim_obj_id 28 $new_commit1`
1912 
1913 	echo -n "$short_old_commit1 -> $short_new_commit1: " \
1914 		> $testroot/stdout.expected
1915 	echo "committing edited changes 1" >> $testroot/stdout.expected
1916 	echo "G  epsilon/zeta" >> $testroot/stdout.expected
1917 	echo "Stopping histedit for amending commit $old_commit2" \
1918 		>> $testroot/stdout.expected
1919 	cmp -s $testroot/stdout.expected $testroot/stdout
1920 	ret=$?
1921 	if [ $ret -ne 0 ]; then
1922 		diff -u $testroot/stdout.expected $testroot/stdout
1923 		test_done "$testroot" "$ret"
1924 		return 1
1925 	fi
1926 
1927 	echo "edited zeta on master" > $testroot/wt/epsilon/zeta
1928 
1929 	cat > $testroot/editor.sh <<EOF
1930 #!/bin/sh
1931 ed -s "\$1" <<-EOF
1932 	,s/.*/committing edited changes 2/
1933 	w
1934 	EOF
1935 EOF
1936 	chmod +x $testroot/editor.sh
1937 
1938 	(cd $testroot/wt && env EDITOR="$testroot/editor.sh" \
1939 		VISUAL="$testroot/editor.sh" got histedit -c > $testroot/stdout)
1940 
1941 	local new_commit2=`git_show_head $testroot/repo`
1942 	local short_new_commit2=`trim_obj_id 28 $new_commit2`
1943 
1944 	echo -n "$short_old_commit2 -> $short_new_commit2: " \
1945 		> $testroot/stdout.expected
1946 	echo "committing edited changes 2" >> $testroot/stdout.expected
1947 	echo "Switching work tree to refs/heads/master" \
1948 		>> $testroot/stdout.expected
1949 
1950 	cmp -s $testroot/stdout.expected $testroot/stdout
1951 	ret=$?
1952 	if [ $ret -ne 0 ]; then
1953 		diff -u $testroot/stdout.expected $testroot/stdout
1954 		test_done "$testroot" "$ret"
1955 		return 1
1956 	fi
1957 
1958 	echo "edited modified alpha on master" > $testroot/content.expected
1959 	cat $testroot/wt/alpha > $testroot/content
1960 	cmp -s $testroot/content.expected $testroot/content
1961 	ret=$?
1962 	if [ $ret -ne 0 ]; then
1963 		diff -u $testroot/content.expected $testroot/content
1964 		test_done "$testroot" "$ret"
1965 		return 1
1966 	fi
1967 
1968 	if [ -e $testroot/wt/beta ]; then
1969 		echo "removed file beta still exists on disk" >&2
1970 		test_done "$testroot" "1"
1971 		return 1
1972 	fi
1973 
1974 	echo "new file on master" > $testroot/content.expected
1975 	cat $testroot/wt/epsilon/new > $testroot/content
1976 	cmp -s $testroot/content.expected $testroot/content
1977 	ret=$?
1978 	if [ $ret -ne 0 ]; then
1979 		diff -u $testroot/content.expected $testroot/content
1980 		test_done "$testroot" "$ret"
1981 		return 1
1982 	fi
1983 
1984 	(cd $testroot/wt && got status > $testroot/stdout)
1985 
1986 	echo -n > $testroot/stdout.expected
1987 	cmp -s $testroot/stdout.expected $testroot/stdout
1988 	ret=$?
1989 	if [ $ret -ne 0 ]; then
1990 		diff -u $testroot/stdout.expected $testroot/stdout
1991 		test_done "$testroot" "$ret"
1992 		return 1
1993 	fi
1994 
1995 	(cd $testroot/wt && got log -l3 | grep ^commit > $testroot/stdout)
1996 	echo "commit $new_commit2 (master)" > $testroot/stdout.expected
1997 	echo "commit $new_commit1" >> $testroot/stdout.expected
1998 	echo "commit $orig_commit" >> $testroot/stdout.expected
1999 	cmp -s $testroot/stdout.expected $testroot/stdout
2000 	ret=$?
2001 	if [ $ret -ne 0 ]; then
2002 		diff -u $testroot/stdout.expected $testroot/stdout
2003 	fi
2004 	test_done "$testroot" "$ret"
2005 }
2006 
2007 test_histedit_prepend_line() {
2008 	local testroot=`test_init histedit_prepend_line`
2009 	local orig_commit=`git_show_head $testroot/repo`
2010 
2011 	got checkout $testroot/repo $testroot/wt > /dev/null
2012 
2013 	ed -s "$testroot/wt/alpha" <<EOF
2014 1i
2015 first line
2016 .
2017 wq
2018 EOF
2019 
2020 	cp $testroot/wt/alpha $testroot/content.expected
2021 
2022 	(cd $testroot/wt/ && got commit -m 'modified alpha on master' \
2023 		alpha > /dev/null)
2024 	ret=$?
2025 	if [ "$?" != 0 ]; then
2026 		echo "got commit failed unexpectedly" >&2
2027 		test_done "$testroot" "$ret"
2028 		return 1
2029 	fi
2030 
2031 	local top_commit=`git_show_head $testroot/repo`
2032 	echo "pick $top_commit" > "$testroot/histedit-script"
2033 
2034 	(cd $testroot/wt/ && got update -c $orig_commit > /dev/null)
2035 	ret=$?
2036 	if [ "$?" != 0 ]; then
2037 		echo "got update failed unexpectedly" >&2
2038 		test_done "$testroot" "$ret"
2039 		return 1
2040 	fi
2041 
2042 	(cd $testroot/wt && got histedit -F "$testroot/histedit-script" \
2043 		> /dev/null)
2044 	ret=$?
2045 	if [ "$?" != 0 ]; then
2046 		echo "got histedit failed unexpectedly" >&2
2047 		test_done "$testroot" "$ret"
2048 		return 1
2049 	fi
2050 
2051 	cp $testroot/wt/alpha $testroot/content
2052 	cmp -s $testroot/content.expected $testroot/content
2053 	ret=$?
2054 	if [ $ret -ne 0 ]; then
2055 		diff -u $testroot/content.expected $testroot/content
2056 		test_done "$testroot" "$ret"
2057 		return 1
2058 	fi
2059 
2060 	test_done "$testroot" $ret
2061 }
2062 
2063 test_histedit_mesg_invalid() {
2064 	local testroot=`test_init mesg_invalid`
2065 
2066 	local orig_commit=`git_show_head $testroot/repo`
2067 
2068 	echo "modified alpha on master" > $testroot/repo/alpha
2069 	(cd $testroot/repo && git rm -q beta)
2070 	echo "new file on master" > $testroot/repo/epsilon/new
2071 	(cd $testroot/repo && git add epsilon/new)
2072 	git_commit $testroot/repo -m 'committing changes'
2073 	local old_commit1=`git_show_head $testroot/repo`
2074 
2075 	echo "modified zeta on master" > $testroot/repo/epsilon/zeta
2076 	git_commit $testroot/repo -m 'committing to zeto on master'
2077 	local old_commit2=`git_show_head $testroot/repo`
2078 
2079 	got checkout -c $orig_commit $testroot/repo $testroot/wt > /dev/null
2080 	ret=$?
2081 	if [ $ret -ne 0 ]; then
2082 		test_done "$testroot" $ret
2083 		return 1
2084 	fi
2085 
2086 	# try with a leading mesg
2087 
2088 	echo "mesg something something" > $testroot/histedit-script
2089 	echo "pick $old_commit1" >> $testroot/histedit-script
2090 	echo "pick $old_commit2" >> $testroot/histedit-script
2091 
2092 	(cd $testroot/wt && got histedit -F $testroot/histedit-script \
2093 		> $testroot/stdout 2> $testroot/stderr)
2094 	ret=$?
2095 	if [ $ret -eq 0 ]; then
2096 		echo "histedit succeeded unexpectedly" >&2
2097 		test_done "$testroot" 1
2098 		return 1
2099 	fi
2100 
2101 	echo "got: bad histedit command" > $testroot/stderr.expected
2102 	cmp -s $testroot/stderr.expected $testroot/stderr
2103 	ret=$?
2104 	if [ $ret -ne 0 ]; then
2105 		diff -u $testroot/stderr.expected $testroot/stderr
2106 		test_done "$testroot" $ret
2107 		return 1
2108 	fi
2109 
2110 	# try again with mesg -> mesg
2111 
2112 	echo "pick $old_commit1" > $testroot/histedit-script
2113 	echo "mesg something something" >> $testroot/histedit-script
2114 	echo "mesg something something else" >> $testroot/histedit-script
2115 	echo "pick $old_commit2" >> $testroot/histedit-script
2116 
2117 	(cd $testroot/wt && got histedit -F $testroot/histedit-script \
2118 		> $testroot/stdout 2> $testroot/stderr)
2119 	ret=$?
2120 	if [ $ret -eq 0 ]; then
2121 		echo "histedit succeeded unexpectedly" >&2
2122 		test_done "$testroot" 1
2123 		return 1
2124 	fi
2125 
2126 	echo "got: bad histedit command" > $testroot/stderr.expected
2127 	cmp -s $testroot/stderr.expected $testroot/stderr
2128 	ret=$?
2129 	if [ $ret -ne 0 ]; then
2130 		diff -u $testroot/stderr.expected $testroot/stderr
2131 		test_done "$testroot" $ret
2132 		return 1
2133 	fi
2134 
2135 	# try again with drop -> mesg
2136 
2137 	echo "drop $old_commit1" > $testroot/histedit-script
2138 	echo "mesg something something" >> $testroot/histedit-script
2139 	echo "pick $old_commit2" >> $testroot/histedit-script
2140 
2141 	(cd $testroot/wt && got histedit -F $testroot/histedit-script \
2142 		> $testroot/stdout 2> $testroot/stderr)
2143 	ret=$?
2144 	if [ $ret -eq 0 ]; then
2145 		echo "histedit succeeded unexpectedly" >&2
2146 		test_done "$testroot" 1
2147 		return 1
2148 	fi
2149 
2150 	echo "got: bad histedit command" > $testroot/stderr.expected
2151 	cmp -s $testroot/stderr.expected $testroot/stderr
2152 	ret=$?
2153 	if [ $ret -ne 0 ]; then
2154 		diff -u $testroot/stderr.expected $testroot/stderr
2155 		test_done "$testroot" $ret
2156 		return 1
2157 	fi
2158 
2159 	# try again with fold -> mesg
2160 
2161 	echo "fold $old_commit1" > $testroot/histedit-script
2162 	echo "mesg something something" >> $testroot/histedit-script
2163 	echo "pick $old_commit2" >> $testroot/histedit-script
2164 
2165 	(cd $testroot/wt && got histedit -F $testroot/histedit-script \
2166 		> $testroot/stdout 2> $testroot/stderr)
2167 	ret=$?
2168 	if [ $ret -eq 0 ]; then
2169 		echo "histedit succeeded unexpectedly" >&2
2170 		test_done "$testroot" 1
2171 		return 1
2172 	fi
2173 
2174 	echo "got: bad histedit command" > $testroot/stderr.expected
2175 	cmp -s $testroot/stderr.expected $testroot/stderr
2176 	ret=$?
2177 	if [ $ret -ne 0 ]; then
2178 		diff -u $testroot/stderr.expected $testroot/stderr
2179 	fi
2180 	test_done "$testroot" $ret
2181 }
2182 
2183 test_histedit_resets_committer() {
2184 	local testroot=`test_init histedit_resets_committer`
2185 	local orig_commit=`git_show_head $testroot/repo`
2186 	local committer="Flan Luck <flan_luck@openbsd.org>"
2187 
2188 	got checkout $testroot/repo $testroot/wt > /dev/null
2189 
2190 	echo "modified alpha" > $testroot/wt/alpha
2191 
2192 	(cd $testroot/wt/ && got commit -m 'modified alpha on master' \
2193 		alpha > /dev/null)
2194 	ret=$?
2195 	if [ "$?" != 0 ]; then
2196 		echo "got commit failed unexpectedly" >&2
2197 		test_done "$testroot" "$ret"
2198 		return 1
2199 	fi
2200 
2201 	local top_commit=`git_show_head $testroot/repo`
2202 	echo "pick $top_commit" > "$testroot/histedit-script"
2203 
2204 	(cd $testroot/wt/ && got update -c $orig_commit > /dev/null)
2205 	ret=$?
2206 	if [ "$?" != 0 ]; then
2207 		echo "got update failed unexpectedly" >&2
2208 		test_done "$testroot" "$ret"
2209 		return 1
2210 	fi
2211 
2212 	(cd $testroot/wt && env GOT_AUTHOR="$committer" \
2213 		got histedit -F "$testroot/histedit-script" > /dev/null)
2214 	ret=$?
2215 	if [ "$?" != 0 ]; then
2216 		echo "got histedit failed unexpectedly" >&2
2217 		test_done "$testroot" "$ret"
2218 		return 1
2219 	fi
2220 	local edited_commit=`git_show_head $testroot/repo`
2221 
2222 	# Original commit only had one author
2223 	(cd $testroot/repo && got log -l1 -c $top_commit | \
2224 		egrep '^(from|via):' > $testroot/stdout)
2225 	echo "from: $GOT_AUTHOR" > $testroot/stdout.expected
2226 	cmp -s $testroot/stdout.expected $testroot/stdout
2227 	ret=$?
2228 	if [ $ret -ne 0 ]; then
2229 		diff -u $testroot/stdout.expected $testroot/stdout
2230 		test_done "$testroot" "$ret"
2231 		return 1
2232 	fi
2233 
2234 	# Edited commit should have new committer name added
2235 	(cd $testroot/repo && got log -l1 -c $edited_commit | \
2236 		egrep '^(from|via):' > $testroot/stdout)
2237 	echo "from: $GOT_AUTHOR" > $testroot/stdout.expected
2238 	echo "via: $committer" >> $testroot/stdout.expected
2239 
2240 	cmp -s $testroot/stdout.expected $testroot/stdout
2241 	ret=$?
2242 	if [ $ret -ne 0 ]; then
2243 		diff -u $testroot/stdout.expected $testroot/stdout
2244 	fi
2245 	test_done "$testroot" "$ret"
2246 }
2247 
2248 test_histedit_umask() {
2249 	local testroot=`test_init histedit_umask`
2250 	local orig_commit=`git_show_head "$testroot/repo"`
2251 
2252 	got checkout "$testroot/repo" "$testroot/wt" >/dev/null
2253 
2254 	echo "modified alpha" > $testroot/wt/alpha
2255 	(cd "$testroot/wt" && got commit -m 'edit #1') >/dev/null
2256 	local commit1=`git_show_head "$testroot/repo"`
2257 
2258 	echo "modified again" > $testroot/wt/alpha
2259 	(cd "$testroot/wt" && got commit -m 'edit #2') >/dev/null
2260 	local commit2=`git_show_head "$testroot/repo"`
2261 
2262 	echo "modified again!" > $testroot/wt/alpha
2263 	echo "modify beta too!" > $testroot/wt/beta
2264 	(cd "$testroot/wt" && got commit -m 'edit #3') >/dev/null
2265 	local commit3=`git_show_head "$testroot/repo"`
2266 
2267 	(cd "$testroot/wt" && got update -c "$orig_commit") >/dev/null
2268 	ret=$?
2269 	if [ $ret -ne 0 ]; then
2270 		echo "update to $orig_commit failed!" >&2
2271 		test_done "$testroot" 1
2272 		return 1
2273 	fi
2274 
2275 	echo fold $commit1 >$testroot/histedit-script
2276 	echo fold $commit2 >>$testroot/histedit-script
2277 	echo pick $commit3 >>$testroot/histedit-script
2278 	echo mesg folding changes >>$testroot/histedit-script
2279 
2280 	# using a subshell to avoid clobbering global umask
2281 	(umask 077 && cd "$testroot/wt" && \
2282 		got histedit -F "$testroot/histedit-script") >/dev/null
2283 	ret=$?
2284 
2285 	if [ $ret -ne 0 ]; then
2286 		echo "histedit operation failed" >&2
2287 		test_done "$testroot" $ret
2288 		return 1
2289 	fi
2290 
2291 	for f in alpha beta; do
2292 		ls -l "$testroot/wt/$f" | grep -q ^-rw-------
2293 		if [ $? -ne 0 ]; then
2294 			echo "$f is not 0600 after histedi" >&2
2295 			ls -l "$testroot/wt/$f" >&2
2296 			test_done "$testroot" 1
2297 			return 1
2298 		fi
2299 	done
2300 
2301 	test_done "$testroot" 0
2302 }
2303 
2304 test_histedit_mesg_filemode_change() {
2305 	local testroot=`test_init histedit_mode_change`
2306 
2307 	local orig_commit=`git_show_head $testroot/repo`
2308 	local orig_author_time=`git_show_author_time $testroot/repo`
2309 
2310 	chmod +x $testroot/repo/alpha
2311 	git_commit $testroot/repo -m "set x bit on alpha"
2312 	local old_commit1=`git_show_head $testroot/repo`
2313 	local old_author_time1=`git_show_author_time $testroot/repo`
2314 
2315 	got checkout -c $orig_commit $testroot/repo $testroot/wt > /dev/null
2316 	ret=$?
2317 	if [ $ret -ne 0 ]; then
2318 		test_done "$testroot" "$ret"
2319 		return 1
2320 	fi
2321 
2322 	if [ -x $testroot/wt/alpha ]; then
2323 		echo "file alpha has unexpected executable bit" >&2
2324 		test_done "$testroot" "1"
2325 		return 1
2326 	fi
2327 
2328 	cat > $testroot/editor.sh <<EOF
2329 #!/bin/sh
2330 ed -s "\$1" <<-EOF
2331 	,s/ x bit / executable bit /
2332 	w
2333 	EOF
2334 EOF
2335 
2336 	chmod +x $testroot/editor.sh
2337 
2338 	(cd $testroot/wt && env VISUAL="$testroot/editor.sh" \
2339 		got histedit -m > $testroot/stdout)
2340 
2341 	local new_commit1=`git_show_head $testroot/repo`
2342 	local new_author_time1=`git_show_author_time $testroot/repo`
2343 
2344 	local short_old_commit1=`trim_obj_id 28 $old_commit1`
2345 	local short_new_commit1=`trim_obj_id 28 $new_commit1`
2346 
2347 	echo "G  alpha" > $testroot/stdout.expected
2348 	echo "$short_old_commit1 -> $short_new_commit1: set executable bit on alpha" \
2349 		>> $testroot/stdout.expected
2350 	echo "Switching work tree to refs/heads/master" \
2351 		>> $testroot/stdout.expected
2352 
2353 	cmp -s $testroot/stdout.expected $testroot/stdout
2354 	ret=$?
2355 	if [ $ret -ne 0 ]; then
2356 		diff -u $testroot/stdout.expected $testroot/stdout
2357 		test_done "$testroot" "$ret"
2358 		return 1
2359 	fi
2360 
2361 	echo "alpha" > $testroot/content.expected
2362 	cmp -s $testroot/content.expected $testroot/wt/alpha
2363 	ret=$?
2364 	if [ $ret -ne 0 ]; then
2365 		diff -u $testroot/content.expected $testroot/wt/alpha
2366 		test_done "$testroot" "$ret"
2367 		return 1
2368 	fi
2369 
2370 	if [ ! -x $testroot/wt/alpha ]; then
2371 		echo "file alpha lost its executable bit" >&2
2372 		test_done "$testroot" "1"
2373 		return 1
2374 	fi
2375 
2376 	(cd $testroot/wt && got status > $testroot/stdout)
2377 
2378 	echo -n > $testroot/stdout.expected
2379 	cmp -s $testroot/stdout.expected $testroot/stdout
2380 	ret=$?
2381 	if [ $ret -ne 0 ]; then
2382 		diff -u $testroot/stdout.expected $testroot/stdout
2383 		test_done "$testroot" "$ret"
2384 		return 1
2385 	fi
2386 
2387 	(cd $testroot/wt && got log -l1 | grep ' set executable bit on alpha' \
2388 		> $testroot/stdout)
2389 
2390 	echo ' set executable bit on alpha' > $testroot/stdout.expected
2391 	cmp -s $testroot/stdout.expected $testroot/stdout
2392 	ret=$?
2393 	if [ $ret -ne 0 ]; then
2394 		diff -u $testroot/stdout.expected $testroot/stdout
2395 		test_done "$testroot" "$ret"
2396 		return 1
2397 	fi
2398 
2399 	test_done "$testroot" "$ret"
2400 }
2401 
2402 test_histedit_drop_only() {
2403 	local testroot=`test_init histedit_drop_only`
2404 
2405 	local orig_commit=`git_show_head $testroot/repo`
2406 	local drop="->  drop commit:"
2407 	local dropmsg="commit changes to drop"
2408 
2409 	echo "modified alpha on master" > $testroot/repo/alpha
2410 	(cd $testroot/repo && git rm -q beta)
2411 	echo "new file on master" > $testroot/repo/epsilon/new
2412 	(cd $testroot/repo && git add epsilon/new)
2413 
2414 	git_commit $testroot/repo -m "$dropmsg 1"
2415 	local drop_commit1=`git_show_head $testroot/repo`
2416 
2417 	echo "modified zeta on master" > $testroot/repo/epsilon/zeta
2418 
2419 	git_commit $testroot/repo -m "$dropmsg 2"
2420 	local drop_commit2=`git_show_head $testroot/repo`
2421 
2422 	echo "modified delta on master" > $testroot/repo/gamma/delta
2423 
2424 	git_commit $testroot/repo -m "$dropmsg 3"
2425 	local drop_commit3=`git_show_head $testroot/repo`
2426 
2427 	got checkout -c $orig_commit $testroot/repo $testroot/wt > /dev/null
2428 	ret=$?
2429 	if [ $ret -ne 0 ]; then
2430 		test_done "$testroot" "$ret"
2431 		return 1
2432 	fi
2433 
2434 	(cd $testroot/wt && got histedit -d > $testroot/stdout)
2435 	local new_commit1=`git_show_head $testroot/repo`
2436 
2437 	local short_commit1=`trim_obj_id 28 $drop_commit1`
2438 	local short_commit2=`trim_obj_id 28 $drop_commit2`
2439 	local short_commit3=`trim_obj_id 28 $drop_commit3`
2440 
2441 	echo "$short_commit1 $drop $dropmsg 1" > $testroot/stdout.expected
2442 	echo "$short_commit2 $drop $dropmsg 2" >> $testroot/stdout.expected
2443 	echo "$short_commit3 $drop $dropmsg 3" >> $testroot/stdout.expected
2444 	echo "Switching work tree to refs/heads/master" \
2445 		>> $testroot/stdout.expected
2446 
2447 	cmp -s $testroot/stdout.expected $testroot/stdout
2448 	ret=$?
2449 	if [ $ret -ne 0 ]; then
2450 		diff -u $testroot/stdout.expected $testroot/stdout
2451 		test_done "$testroot" "$ret"
2452 		return 1
2453 	fi
2454 
2455 	echo "alpha" > $testroot/content.expected
2456 	cat $testroot/wt/alpha > $testroot/content
2457 	cmp -s $testroot/content.expected $testroot/content
2458 	ret=$?
2459 	if [ $ret -ne 0 ]; then
2460 		diff -u $testroot/content.expected $testroot/content
2461 		test_done "$testroot" "$ret"
2462 		return 1
2463 	fi
2464 
2465 	echo "zeta" > $testroot/content.expected
2466 	cat $testroot/wt/epsilon/zeta > $testroot/content
2467 	cmp -s $testroot/content.expected $testroot/content
2468 	ret=$?
2469 	if [ $ret -ne 0 ]; then
2470 		diff -u $testroot/content.expected $testroot/content
2471 		test_done "$testroot" "$ret"
2472 		return 1
2473 	fi
2474 
2475 	echo "delta" > $testroot/content.expected
2476 	cat $testroot/wt/gamma/delta > $testroot/content
2477 	cmp -s $testroot/content.expected $testroot/content
2478 	ret=$?
2479 	if [ $ret -ne 0 ]; then
2480 		diff -u $testroot/content.expected $testroot/content
2481 		test_done "$testroot" "$ret"
2482 		return 1
2483 	fi
2484 
2485 	if [ ! -e $testroot/wt/beta ]; then
2486 		echo "removed file beta should be restored" >&2
2487 		test_done "$testroot" "1"
2488 		return 1
2489 	fi
2490 
2491 	if [ -e $testroot/wt/new ]; then
2492 		echo "new file should no longer exist" >&2
2493 		test_done "$testroot" "$ret"
2494 		return 1
2495 	fi
2496 
2497 	(cd $testroot/wt && got status > $testroot/stdout)
2498 
2499 	echo -n > $testroot/stdout.expected
2500 	cmp -s $testroot/stdout.expected $testroot/stdout
2501 	ret=$?
2502 	if [ $ret -ne 0 ]; then
2503 		diff -u $testroot/stdout.expected $testroot/stdout
2504 		test_done "$testroot" "$ret"
2505 		return 1
2506 	fi
2507 
2508 	(cd $testroot/wt && got log | grep ^commit > $testroot/stdout)
2509 	echo "commit $orig_commit (master)" > $testroot/stdout.expected
2510 	cmp -s $testroot/stdout.expected $testroot/stdout
2511 	ret=$?
2512 	if [ $ret -ne 0 ]; then
2513 		diff -u $testroot/stdout.expected $testroot/stdout
2514 	fi
2515 	test_done "$testroot" "$ret"
2516 }
2517 
2518 test_parseargs "$@"
2519 run_test test_histedit_no_op
2520 run_test test_histedit_swap
2521 run_test test_histedit_drop
2522 run_test test_histedit_fold
2523 run_test test_histedit_edit
2524 run_test test_histedit_fold_last_commit
2525 run_test test_histedit_missing_commit
2526 run_test test_histedit_abort
2527 run_test test_histedit_path_prefix_drop
2528 run_test test_histedit_path_prefix_edit
2529 run_test test_histedit_outside_refs_heads
2530 run_test test_histedit_fold_last_commit_swap
2531 run_test test_histedit_split_commit
2532 run_test test_histedit_duplicate_commit_in_script
2533 run_test test_histedit_fold_add_delete
2534 run_test test_histedit_fold_delete_add
2535 run_test test_histedit_fold_only
2536 run_test test_histedit_fold_only_empty_logmsg
2537 run_test test_histedit_edit_only
2538 run_test test_histedit_prepend_line
2539 run_test test_histedit_mesg_invalid
2540 run_test test_histedit_resets_committer
2541 run_test test_histedit_umask
2542 run_test test_histedit_mesg_filemode_change
2543 run_test test_histedit_drop_only