[thirdparty/git.git] / t / t6050-replace.sh

#!/bin/sh
#
# Copyright (c) 2008 Christian Couder
#
test_description='Tests replace refs functionality'

exec </dev/null

. ./test-lib.sh

add_and_commit_file ()
{
    _file="$1"
    _msg="$2"

    git add $_file || return $?
    test_tick || return $?
    git commit --quiet -m "$_file: $_msg"
}

commit_buffer_contains_parents ()
{
    git cat-file commit "$1" >payload &&
    sed -n -e '/^$/q' -e '/^parent /p' <payload >actual &&
    shift &&
    for _parent
    do
	echo "parent $_parent"
    done >expected &&
    test_cmp expected actual
}

commit_peeling_shows_parents ()
{
    _parent_number=1
    _commit="$1"
    shift &&
    for _parent
    do
	_found=$(git rev-parse --verify $_commit^$_parent_number) || return 1
	test "$_found" = "$_parent" || return 1
	_parent_number=$(( $_parent_number + 1 ))
    done &&
    test_must_fail git rev-parse --verify $_commit^$_parent_number
}

commit_has_parents ()
{
    commit_buffer_contains_parents "$@" &&
    commit_peeling_shows_parents "$@"
}

HASH1=
HASH2=
HASH3=
HASH4=
HASH5=
HASH6=
HASH7=

test_expect_success 'set up buggy branch' '
     echo "line 1" >>hello &&
     echo "line 2" >>hello &&
     echo "line 3" >>hello &&
     echo "line 4" >>hello &&
     add_and_commit_file hello "4 lines" &&
     HASH1=$(git rev-parse --verify HEAD) &&
     echo "line BUG" >>hello &&
     echo "line 6" >>hello &&
     echo "line 7" >>hello &&
     echo "line 8" >>hello &&
     add_and_commit_file hello "4 more lines with a BUG" &&
     HASH2=$(git rev-parse --verify HEAD) &&
     echo "line 9" >>hello &&
     echo "line 10" >>hello &&
     add_and_commit_file hello "2 more lines" &&
     HASH3=$(git rev-parse --verify HEAD) &&
     echo "line 11" >>hello &&
     add_and_commit_file hello "1 more line" &&
     HASH4=$(git rev-parse --verify HEAD) &&
     sed -e "s/BUG/5/" hello >hello.new &&
     mv hello.new hello &&
     add_and_commit_file hello "BUG fixed" &&
     HASH5=$(git rev-parse --verify HEAD) &&
     echo "line 12" >>hello &&
     echo "line 13" >>hello &&
     add_and_commit_file hello "2 more lines" &&
     HASH6=$(git rev-parse --verify HEAD) &&
     echo "line 14" >>hello &&
     echo "line 15" >>hello &&
     echo "line 16" >>hello &&
     add_and_commit_file hello "again 3 more lines" &&
     HASH7=$(git rev-parse --verify HEAD)
'

test_expect_success 'replace the author' '
     git cat-file commit $HASH2 | grep "author A U Thor" &&
     R=$(git cat-file commit $HASH2 | sed -e "s/A U/O/" | git hash-object -t commit --stdin -w) &&
     git cat-file commit $R | grep "author O Thor" &&
     git update-ref refs/replace/$HASH2 $R &&
     git show HEAD~5 | grep "O Thor" &&
     git show $HASH2 | grep "O Thor"
'

test_expect_success 'test --no-replace-objects option' '
     git cat-file commit $HASH2 | grep "author O Thor" &&
     git --no-replace-objects cat-file commit $HASH2 | grep "author A U Thor" &&
     git show $HASH2 | grep "O Thor" &&
     git --no-replace-objects show $HASH2 | grep "A U Thor"
'

test_expect_success 'test GIT_NO_REPLACE_OBJECTS env variable' '
     GIT_NO_REPLACE_OBJECTS=1 git cat-file commit $HASH2 | grep "author A U Thor" &&
     GIT_NO_REPLACE_OBJECTS=1 git show $HASH2 | grep "A U Thor"
'

cat >tag.sig <<EOF
object $HASH2
type commit
tag mytag
tagger T A Gger <> 0 +0000

EOF

test_expect_success 'tag replaced commit' '
     git mktag <tag.sig >.git/refs/tags/mytag 2>message
'

test_expect_success '"git fsck" works' '
     git fsck master >fsck_master.out &&
     grep "dangling commit $R" fsck_master.out &&
     grep "dangling tag $(cat .git/refs/tags/mytag)" fsck_master.out &&
     test -z "$(git fsck)"
'

test_expect_success 'repack, clone and fetch work' '
     git repack -a -d &&
     git clone --no-hardlinks . clone_dir &&
     (
	  cd clone_dir &&
	  git show HEAD~5 | grep "A U Thor" &&
	  git show $HASH2 | grep "A U Thor" &&
	  git cat-file commit $R &&
	  git repack -a -d &&
	  test_must_fail git cat-file commit $R &&
	  git fetch ../ "refs/replace/*:refs/replace/*" &&
	  git show HEAD~5 | grep "O Thor" &&
	  git show $HASH2 | grep "O Thor" &&
	  git cat-file commit $R
     )
'

test_expect_success '"git replace" listing and deleting' '
     test "$HASH2" = "$(git replace -l)" &&
     test "$HASH2" = "$(git replace)" &&
     aa=${HASH2%??????????????????????????????????????} &&
     test "$HASH2" = "$(git replace --list "$aa*")" &&
     test_must_fail git replace -d $R &&
     test_must_fail git replace --delete &&
     test_must_fail git replace -l -d $HASH2 &&
     git replace -d $HASH2 &&
     git show $HASH2 | grep "A U Thor" &&
     test -z "$(git replace -l)"
'

test_expect_success '"git replace" replacing' '
     git replace $HASH2 $R &&
     git show $HASH2 | grep "O Thor" &&
     test_must_fail git replace $HASH2 $R &&
     git replace -f $HASH2 $R &&
     test_must_fail git replace -f &&
     test "$HASH2" = "$(git replace)"
'

test_expect_success '"git replace" resolves sha1' '
     SHORTHASH2=$(git rev-parse --short=8 $HASH2) &&
     git replace -d $SHORTHASH2 &&
     git replace $SHORTHASH2 $R &&
     git show $HASH2 | grep "O Thor" &&
     test_must_fail git replace $HASH2 $R &&
     git replace -f $HASH2 $R &&
     test_must_fail git replace --force &&
     test "$HASH2" = "$(git replace)"
'

# This creates a side branch where the bug in H2
# does not appear because P2 is created by applying
# H2 and squashing H5 into it.
# P3, P4 and P6 are created by cherry-picking H3, H4
# and H6 respectively.
#
# At this point, we should have the following:
#
#    P2--P3--P4--P6
#   /
# H1-H2-H3-H4-H5-H6-H7
#
# Then we replace H6 with P6.
#
test_expect_success 'create parallel branch without the bug' '
     git replace -d $HASH2 &&
     git show $HASH2 | grep "A U Thor" &&
     git checkout $HASH1 &&
     git cherry-pick $HASH2 &&
     git show $HASH5 | git apply &&
     git commit --amend -m "hello: 4 more lines WITHOUT the bug" hello &&
     PARA2=$(git rev-parse --verify HEAD) &&
     git cherry-pick $HASH3 &&
     PARA3=$(git rev-parse --verify HEAD) &&
     git cherry-pick $HASH4 &&
     PARA4=$(git rev-parse --verify HEAD) &&
     git cherry-pick $HASH6 &&
     PARA6=$(git rev-parse --verify HEAD) &&
     git replace $HASH6 $PARA6 &&
     git checkout master &&
     cur=$(git rev-parse --verify HEAD) &&
     test "$cur" = "$HASH7" &&
     git log --pretty=oneline | grep $PARA2 &&
     git remote add cloned ./clone_dir
'

test_expect_success 'push to cloned repo' '
     git push cloned $HASH6^:refs/heads/parallel &&
     (
	  cd clone_dir &&
	  git checkout parallel &&
	  git log --pretty=oneline | grep $PARA2
     )
'

test_expect_success 'push branch with replacement' '
     git cat-file commit $PARA3 | grep "author A U Thor" &&
     S=$(git cat-file commit $PARA3 | sed -e "s/A U/O/" | git hash-object -t commit --stdin -w) &&
     git cat-file commit $S | grep "author O Thor" &&
     git replace $PARA3 $S &&
     git show $HASH6~2 | grep "O Thor" &&
     git show $PARA3 | grep "O Thor" &&
     git push cloned $HASH6^:refs/heads/parallel2 &&
     (
	  cd clone_dir &&
	  git checkout parallel2 &&
	  git log --pretty=oneline | grep $PARA3 &&
	  git show $PARA3 | grep "A U Thor"
     )
'

test_expect_success 'fetch branch with replacement' '
     git branch tofetch $HASH6 &&
     (
	  cd clone_dir &&
	  git fetch origin refs/heads/tofetch:refs/heads/parallel3 &&
	  git log --pretty=oneline parallel3 >output.txt &&
	  ! grep $PARA3 output.txt &&
	  git show $PARA3 >para3.txt &&
	  grep "A U Thor" para3.txt &&
	  git fetch origin "refs/replace/*:refs/replace/*" &&
	  git log --pretty=oneline parallel3 >output.txt &&
	  grep $PARA3 output.txt &&
	  git show $PARA3 >para3.txt &&
	  grep "O Thor" para3.txt
     )
'

test_expect_success 'bisect and replacements' '
     git bisect start $HASH7 $HASH1 &&
     test "$PARA3" = "$(git rev-parse --verify HEAD)" &&
     git bisect reset &&
     GIT_NO_REPLACE_OBJECTS=1 git bisect start $HASH7 $HASH1 &&
     test "$HASH4" = "$(git rev-parse --verify HEAD)" &&
     git bisect reset &&
     git --no-replace-objects bisect start $HASH7 $HASH1 &&
     test "$HASH4" = "$(git rev-parse --verify HEAD)" &&
     git bisect reset
'

test_expect_success 'index-pack and replacements' '
	git --no-replace-objects rev-list --objects HEAD |
	git --no-replace-objects pack-objects test- &&
	git index-pack test-*.pack
'

test_expect_success 'not just commits' '
	echo replaced >file &&
	git add file &&
	REPLACED=$(git rev-parse :file) &&
	mv file file.replaced &&

	echo original >file &&
	git add file &&
	ORIGINAL=$(git rev-parse :file) &&
	git update-ref refs/replace/$ORIGINAL $REPLACED &&
	mv file file.original &&

	git checkout file &&
	test_cmp file.replaced file
'

test_expect_success 'replaced and replacement objects must be of the same type' '
	test_must_fail git replace mytag $HASH1 &&
	test_must_fail git replace HEAD^{tree} HEAD~1 &&
	BLOB=$(git rev-parse :file) &&
	test_must_fail git replace HEAD^ $BLOB
'

test_expect_success '-f option bypasses the type check' '
	git replace -f mytag $HASH1 &&
	git replace --force HEAD^{tree} HEAD~1 &&
	git replace -f HEAD^ $BLOB
'

test_expect_success 'git cat-file --batch works on replace objects' '
	git replace | grep $PARA3 &&
	echo $PARA3 | git cat-file --batch
'

test_expect_success 'test --format bogus' '
	test_must_fail git replace --format bogus >/dev/null 2>&1
'

test_expect_success 'test --format short' '
	git replace --format=short >actual &&
	git replace >expected &&
	test_cmp expected actual
'

test_expect_success 'test --format medium' '
	H1=$(git --no-replace-objects rev-parse HEAD~1) &&
	HT=$(git --no-replace-objects rev-parse HEAD^{tree}) &&
	MYTAG=$(git --no-replace-objects rev-parse mytag) &&
	{
		echo "$H1 -> $BLOB" &&
		echo "$BLOB -> $REPLACED" &&
		echo "$HT -> $H1" &&
		echo "$PARA3 -> $S" &&
		echo "$MYTAG -> $HASH1"
	} | sort >expected &&
	git replace -l --format medium | sort >actual &&
	test_cmp expected actual
'

test_expect_success 'test --format long' '
	{
		echo "$H1 (commit) -> $BLOB (blob)" &&
		echo "$BLOB (blob) -> $REPLACED (blob)" &&
		echo "$HT (tree) -> $H1 (commit)" &&
		echo "$PARA3 (commit) -> $S (commit)" &&
		echo "$MYTAG (tag) -> $HASH1 (commit)"
	} | sort >expected &&
	git replace --format=long | sort >actual &&
	test_cmp expected actual
'

test_expect_success 'setup a fake editor' '
	write_script fakeeditor <<-\EOF
		sed -e "s/A U Thor/A fake Thor/" "$1" >"$1.new"
		mv "$1.new" "$1"
	EOF
'

test_expect_success '--edit with and without already replaced object' '
	test_must_fail env GIT_EDITOR=./fakeeditor git replace --edit "$PARA3" &&
	GIT_EDITOR=./fakeeditor git replace --force --edit "$PARA3" &&
	git replace -l | grep "$PARA3" &&
	git cat-file commit "$PARA3" | grep "A fake Thor" &&
	git replace -d "$PARA3" &&
	GIT_EDITOR=./fakeeditor git replace --edit "$PARA3" &&
	git replace -l | grep "$PARA3" &&
	git cat-file commit "$PARA3" | grep "A fake Thor"
'

test_expect_success '--edit and change nothing or command failed' '
	git replace -d "$PARA3" &&
	test_must_fail env GIT_EDITOR=true git replace --edit "$PARA3" &&
	test_must_fail env GIT_EDITOR="./fakeeditor;false" git replace --edit "$PARA3" &&
	GIT_EDITOR=./fakeeditor git replace --edit "$PARA3" &&
	git replace -l | grep "$PARA3" &&
	git cat-file commit "$PARA3" | grep "A fake Thor"
'

test_expect_success 'replace ref cleanup' '
	test -n "$(git replace)" &&
	git replace -d $(git replace) &&
	test -z "$(git replace)"
'

test_expect_success '--graft with and without already replaced object' '
	test $(git log --oneline | wc -l) = 7 &&
	git replace --graft $HASH5 &&
	test $(git log --oneline | wc -l) = 3 &&
	commit_has_parents $HASH5 &&
	test_must_fail git replace --graft $HASH5 $HASH4 $HASH3 &&
	git replace --force -g $HASH5 $HASH4 $HASH3 &&
	commit_has_parents $HASH5 $HASH4 $HASH3 &&
	git replace -d $HASH5
'

test_done
Commit	Line	Data
a3e82672 CC	1	#!/bin/sh
	2	#
	3	# Copyright (c) 2008 Christian Couder
	4	#
	5	test_description='Tests replace refs functionality'
	6
	7	exec </dev/null
	8
	9	. ./test-lib.sh
	10
adf8e542	11	add_and_commit_file ()
a3e82672 CC	12	{
	13	_file="$1"
	14	_msg="$2"
	15
	16	git add $_file \|\| return $?
	17	test_tick \|\| return $?
	18	git commit --quiet -m "$_file: $_msg"
	19	}
	20
adf8e542 CC	21	commit_buffer_contains_parents ()
	22	{
	23	git cat-file commit "$1" >payload &&
	24	sed -n -e '/^$/q' -e '/^parent /p' <payload >actual &&
	25	shift &&
	26	for _parent
	27	do
	28	echo "parent $_parent"
	29	done >expected &&
	30	test_cmp expected actual
	31	}
	32
	33	commit_peeling_shows_parents ()
	34	{
	35	_parent_number=1
	36	_commit="$1"
	37	shift &&
	38	for _parent
	39	do
	40	_found=$(git rev-parse --verify $_commit^$_parent_number) \|\| return 1
	41	test "$_found" = "$_parent" \|\| return 1
	42	_parent_number=$(( $_parent_number + 1 ))
	43	done &&
	44	test_must_fail git rev-parse --verify $_commit^$_parent_number
	45	}
	46
	47	commit_has_parents ()
	48	{
	49	commit_buffer_contains_parents "$@" &&
	50	commit_peeling_shows_parents "$@"
	51	}
	52
a3e82672 CC	53	HASH1=
	54	HASH2=
	55	HASH3=
	56	HASH4=
	57	HASH5=
	58	HASH6=
	59	HASH7=
	60
	61	test_expect_success 'set up buggy branch' '
1c2828c1 CC	62	echo "line 1" >>hello &&
	63	echo "line 2" >>hello &&
	64	echo "line 3" >>hello &&
	65	echo "line 4" >>hello &&
a3e82672 CC	66	add_and_commit_file hello "4 lines" &&
a3e82672 CC	67	HASH1=$(git rev-parse --verify HEAD) &&
1c2828c1 CC	68	echo "line BUG" >>hello &&
	69	echo "line 6" >>hello &&
	70	echo "line 7" >>hello &&
	71	echo "line 8" >>hello &&
a3e82672 CC	72	add_and_commit_file hello "4 more lines with a BUG" &&
a3e82672 CC	73	HASH2=$(git rev-parse --verify HEAD) &&
1c2828c1 CC	74	echo "line 9" >>hello &&
1c2828c1 CC	75	echo "line 10" >>hello &&
a3e82672 CC	76	add_and_commit_file hello "2 more lines" &&
a3e82672 CC	77	HASH3=$(git rev-parse --verify HEAD) &&
1c2828c1	78	echo "line 11" >>hello &&
a3e82672 CC	79	add_and_commit_file hello "1 more line" &&
a3e82672 CC	80	HASH4=$(git rev-parse --verify HEAD) &&
1c2828c1	81	sed -e "s/BUG/5/" hello >hello.new &&
a3e82672 CC	82	mv hello.new hello &&
	83	add_and_commit_file hello "BUG fixed" &&
	84	HASH5=$(git rev-parse --verify HEAD) &&
1c2828c1 CC	85	echo "line 12" >>hello &&
1c2828c1 CC	86	echo "line 13" >>hello &&
a3e82672	87	add_and_commit_file hello "2 more lines" &&
a48fcd83	88	HASH6=$(git rev-parse --verify HEAD) &&
1c2828c1 CC	89	echo "line 14" >>hello &&
	90	echo "line 15" >>hello &&
	91	echo "line 16" >>hello &&
a3e82672 CC	92	add_and_commit_file hello "again 3 more lines" &&
	93	HASH7=$(git rev-parse --verify HEAD)
	94	'
	95
	96	test_expect_success 'replace the author' '
	97	git cat-file commit $HASH2 \| grep "author A U Thor" &&
	98	R=$(git cat-file commit $HASH2 \| sed -e "s/A U/O/" \| git hash-object -t commit --stdin -w) &&
	99	git cat-file commit $R \| grep "author O Thor" &&
	100	git update-ref refs/replace/$HASH2 $R &&
	101	git show HEAD~5 \| grep "O Thor" &&
	102	git show $HASH2 \| grep "O Thor"
	103	'
	104
b0fa7ab5 CC	105	test_expect_success 'test --no-replace-objects option' '
	106	git cat-file commit $HASH2 \| grep "author O Thor" &&
	107	git --no-replace-objects cat-file commit $HASH2 \| grep "author A U Thor" &&
	108	git show $HASH2 \| grep "O Thor" &&
	109	git --no-replace-objects show $HASH2 \| grep "A U Thor"
	110	'
	111
6476b38b CC	112	test_expect_success 'test GIT_NO_REPLACE_OBJECTS env variable' '
	113	GIT_NO_REPLACE_OBJECTS=1 git cat-file commit $HASH2 \| grep "author A U Thor" &&
	114	GIT_NO_REPLACE_OBJECTS=1 git show $HASH2 \| grep "A U Thor"
	115	'
	116
cc400f50 CC	117	cat >tag.sig <<EOF
	118	object $HASH2
	119	type commit
	120	tag mytag
	121	tagger T A Gger <> 0 +0000
	122
	123	EOF
	124
	125	test_expect_success 'tag replaced commit' '
	126	git mktag <tag.sig >.git/refs/tags/mytag 2>message
	127	'
	128
dae556bd	129	test_expect_success '"git fsck" works' '
1c2828c1	130	git fsck master >fsck_master.out &&
dae556bd CC	131	grep "dangling commit $R" fsck_master.out &&
	132	grep "dangling tag $(cat .git/refs/tags/mytag)" fsck_master.out &&
	133	test -z "$(git fsck)"
	134	'
	135
	136	test_expect_success 'repack, clone and fetch work' '
	137	git repack -a -d &&
	138	git clone --no-hardlinks . clone_dir &&
18a82692 JN	139	(
	140	cd clone_dir &&
	141	git show HEAD~5 \| grep "A U Thor" &&
	142	git show $HASH2 \| grep "A U Thor" &&
	143	git cat-file commit $R &&
	144	git repack -a -d &&
	145	test_must_fail git cat-file commit $R &&
	146	git fetch ../ "refs/replace/:refs/replace/" &&
	147	git show HEAD~5 \| grep "O Thor" &&
	148	git show $HASH2 \| grep "O Thor" &&
	149	git cat-file commit $R
fd4ec4f2	150	)
dae556bd CC	151	'
dae556bd CC	152
54b0c1e0 CC	153	test_expect_success '"git replace" listing and deleting' '
	154	test "$HASH2" = "$(git replace -l)" &&
	155	test "$HASH2" = "$(git replace)" &&
	156	aa=${HASH2%??????????????????????????????????????} &&
b1ecd8cf	157	test "$HASH2" = "$(git replace --list "$aa*")" &&
54b0c1e0	158	test_must_fail git replace -d $R &&
b1ecd8cf	159	test_must_fail git replace --delete &&
54b0c1e0 CC	160	test_must_fail git replace -l -d $HASH2 &&
54b0c1e0 CC	161	git replace -d $HASH2 &&
bebdd271	162	git show $HASH2 \| grep "A U Thor" &&
54b0c1e0 CC	163	test -z "$(git replace -l)"
	164	'
	165
bebdd271 CC	166	test_expect_success '"git replace" replacing' '
	167	git replace $HASH2 $R &&
	168	git show $HASH2 \| grep "O Thor" &&
	169	test_must_fail git replace $HASH2 $R &&
	170	git replace -f $HASH2 $R &&
	171	test_must_fail git replace -f &&
	172	test "$HASH2" = "$(git replace)"
	173	'
	174
9dfc3684 MG	175	test_expect_success '"git replace" resolves sha1' '
	176	SHORTHASH2=$(git rev-parse --short=8 $HASH2) &&
	177	git replace -d $SHORTHASH2 &&
	178	git replace $SHORTHASH2 $R &&
	179	git show $HASH2 \| grep "O Thor" &&
	180	test_must_fail git replace $HASH2 $R &&
	181	git replace -f $HASH2 $R &&
b1ecd8cf	182	test_must_fail git replace --force &&
9dfc3684 MG	183	test "$HASH2" = "$(git replace)"
	184	'
	185
4e65b538 CC	186	# This creates a side branch where the bug in H2
	187	# does not appear because P2 is created by applying
	188	# H2 and squashing H5 into it.
	189	# P3, P4 and P6 are created by cherry-picking H3, H4
	190	# and H6 respectively.
	191	#
	192	# At this point, we should have the following:
	193	#
	194	# P2--P3--P4--P6
	195	# /
	196	# H1-H2-H3-H4-H5-H6-H7
	197	#
	198	# Then we replace H6 with P6.
	199	#
	200	test_expect_success 'create parallel branch without the bug' '
	201	git replace -d $HASH2 &&
	202	git show $HASH2 \| grep "A U Thor" &&
	203	git checkout $HASH1 &&
	204	git cherry-pick $HASH2 &&
	205	git show $HASH5 \| git apply &&
	206	git commit --amend -m "hello: 4 more lines WITHOUT the bug" hello &&
	207	PARA2=$(git rev-parse --verify HEAD) &&
	208	git cherry-pick $HASH3 &&
	209	PARA3=$(git rev-parse --verify HEAD) &&
	210	git cherry-pick $HASH4 &&
	211	PARA4=$(git rev-parse --verify HEAD) &&
	212	git cherry-pick $HASH6 &&
	213	PARA6=$(git rev-parse --verify HEAD) &&
	214	git replace $HASH6 $PARA6 &&
	215	git checkout master &&
	216	cur=$(git rev-parse --verify HEAD) &&
	217	test "$cur" = "$HASH7" &&
	218	git log --pretty=oneline \| grep $PARA2 &&
	219	git remote add cloned ./clone_dir
	220	'
	221
	222	test_expect_success 'push to cloned repo' '
	223	git push cloned $HASH6^:refs/heads/parallel &&
18a82692 JN	224	(
	225	cd clone_dir &&
	226	git checkout parallel &&
	227	git log --pretty=oneline \| grep $PARA2
fd4ec4f2	228	)
4e65b538 CC	229	'
	230
	231	test_expect_success 'push branch with replacement' '
	232	git cat-file commit $PARA3 \| grep "author A U Thor" &&
	233	S=$(git cat-file commit $PARA3 \| sed -e "s/A U/O/" \| git hash-object -t commit --stdin -w) &&
	234	git cat-file commit $S \| grep "author O Thor" &&
	235	git replace $PARA3 $S &&
	236	git show $HASH6~2 \| grep "O Thor" &&
	237	git show $PARA3 \| grep "O Thor" &&
	238	git push cloned $HASH6^:refs/heads/parallel2 &&
18a82692 JN	239	(
	240	cd clone_dir &&
	241	git checkout parallel2 &&
	242	git log --pretty=oneline \| grep $PARA3 &&
	243	git show $PARA3 \| grep "A U Thor"
fd4ec4f2	244	)
4e65b538 CC	245	'
	246
	247	test_expect_success 'fetch branch with replacement' '
	248	git branch tofetch $HASH6 &&
18a82692 JN	249	(
18a82692 JN	250	cd clone_dir &&
d212cef9	251	git fetch origin refs/heads/tofetch:refs/heads/parallel3 &&
1c2828c1	252	git log --pretty=oneline parallel3 >output.txt &&
d212cef9	253	! grep $PARA3 output.txt &&
1c2828c1	254	git show $PARA3 >para3.txt &&
d212cef9 CC	255	grep "A U Thor" para3.txt &&
d212cef9 CC	256	git fetch origin "refs/replace/:refs/replace/" &&
1c2828c1	257	git log --pretty=oneline parallel3 >output.txt &&
d212cef9	258	grep $PARA3 output.txt &&
1c2828c1	259	git show $PARA3 >para3.txt &&
d212cef9	260	grep "O Thor" para3.txt
fd4ec4f2	261	)
4e65b538 CC	262	'
4e65b538 CC	263
6476b38b CC	264	test_expect_success 'bisect and replacements' '
6476b38b CC	265	git bisect start $HASH7 $HASH1 &&
2e3400c0	266	test "$PARA3" = "$(git rev-parse --verify HEAD)" &&
6476b38b CC	267	git bisect reset &&
	268	GIT_NO_REPLACE_OBJECTS=1 git bisect start $HASH7 $HASH1 &&
	269	test "$HASH4" = "$(git rev-parse --verify HEAD)" &&
	270	git bisect reset &&
	271	git --no-replace-objects bisect start $HASH7 $HASH1 &&
	272	test "$HASH4" = "$(git rev-parse --verify HEAD)" &&
	273	git bisect reset
	274	'
	275
6e2a09d2 NE	276	test_expect_success 'index-pack and replacements' '
	277	git --no-replace-objects rev-list --objects HEAD \|
	278	git --no-replace-objects pack-objects test- &&
	279	git index-pack test-*.pack
	280	'
	281
abb25ac3 JH	282	test_expect_success 'not just commits' '
	283	echo replaced >file &&
	284	git add file &&
	285	REPLACED=$(git rev-parse :file) &&
	286	mv file file.replaced &&
	287
	288	echo original >file &&
	289	git add file &&
	290	ORIGINAL=$(git rev-parse :file) &&
	291	git update-ref refs/replace/$ORIGINAL $REPLACED &&
	292	mv file file.original &&
	293
	294	git checkout file &&
	295	test_cmp file.replaced file
	296	'
	297
3e625c8f CC	298	test_expect_success 'replaced and replacement objects must be of the same type' '
	299	test_must_fail git replace mytag $HASH1 &&
	300	test_must_fail git replace HEAD^{tree} HEAD~1 &&
	301	BLOB=$(git rev-parse :file) &&
	302	test_must_fail git replace HEAD^ $BLOB
	303	'
	304
	305	test_expect_success '-f option bypasses the type check' '
	306	git replace -f mytag $HASH1 &&
b1ecd8cf	307	git replace --force HEAD^{tree} HEAD~1 &&
3e625c8f CC	308	git replace -f HEAD^ $BLOB
	309	'
	310
1f7117ef	311	test_expect_success 'git cat-file --batch works on replace objects' '
303c5d65 CC	312	git replace \| grep $PARA3 &&
	313	echo $PARA3 \| git cat-file --batch
	314	'
	315
bbbb4afc CC	316	test_expect_success 'test --format bogus' '
	317	test_must_fail git replace --format bogus >/dev/null 2>&1
	318	'
	319
	320	test_expect_success 'test --format short' '
	321	git replace --format=short >actual &&
	322	git replace >expected &&
	323	test_cmp expected actual
	324	'
	325
	326	test_expect_success 'test --format medium' '
	327	H1=$(git --no-replace-objects rev-parse HEAD~1) &&
	328	HT=$(git --no-replace-objects rev-parse HEAD^{tree}) &&
	329	MYTAG=$(git --no-replace-objects rev-parse mytag) &&
	330	{
	331	echo "$H1 -> $BLOB" &&
	332	echo "$BLOB -> $REPLACED" &&
	333	echo "$HT -> $H1" &&
	334	echo "$PARA3 -> $S" &&
	335	echo "$MYTAG -> $HASH1"
	336	} \| sort >expected &&
1c2828c1	337	git replace -l --format medium \| sort >actual &&
bbbb4afc CC	338	test_cmp expected actual
	339	'
	340
663a8566	341	test_expect_success 'test --format long' '
bbbb4afc CC	342	{
	343	echo "$H1 (commit) -> $BLOB (blob)" &&
	344	echo "$BLOB (blob) -> $REPLACED (blob)" &&
	345	echo "$HT (tree) -> $H1 (commit)" &&
	346	echo "$PARA3 (commit) -> $S (commit)" &&
	347	echo "$MYTAG (tag) -> $HASH1 (commit)"
	348	} \| sort >expected &&
1c2828c1	349	git replace --format=long \| sort >actual &&
bbbb4afc CC	350	test_cmp expected actual
	351	'
	352
85f98fc0 CC	353	test_expect_success 'setup a fake editor' '
	354	write_script fakeeditor <<-\EOF
	355	sed -e "s/A U Thor/A fake Thor/" "$1" >"$1.new"
	356	mv "$1.new" "$1"
	357	EOF
	358	'
	359
	360	test_expect_success '--edit with and without already replaced object' '
	361	test_must_fail env GIT_EDITOR=./fakeeditor git replace --edit "$PARA3" &&
	362	GIT_EDITOR=./fakeeditor git replace --force --edit "$PARA3" &&
	363	git replace -l \| grep "$PARA3" &&
	364	git cat-file commit "$PARA3" \| grep "A fake Thor" &&
	365	git replace -d "$PARA3" &&
	366	GIT_EDITOR=./fakeeditor git replace --edit "$PARA3" &&
	367	git replace -l \| grep "$PARA3" &&
	368	git cat-file commit "$PARA3" \| grep "A fake Thor"
	369	'
	370
	371	test_expect_success '--edit and change nothing or command failed' '
	372	git replace -d "$PARA3" &&
	373	test_must_fail env GIT_EDITOR=true git replace --edit "$PARA3" &&
	374	test_must_fail env GIT_EDITOR="./fakeeditor;false" git replace --edit "$PARA3" &&
	375	GIT_EDITOR=./fakeeditor git replace --edit "$PARA3" &&
	376	git replace -l \| grep "$PARA3" &&
	377	git cat-file commit "$PARA3" \| grep "A fake Thor"
	378	'
	379
11aec955 CC	380	test_expect_success 'replace ref cleanup' '
	381	test -n "$(git replace)" &&
	382	git replace -d $(git replace) &&
	383	test -z "$(git replace)"
	384	'
	385
adf8e542 CC	386	test_expect_success '--graft with and without already replaced object' '
	387	test $(git log --oneline \| wc -l) = 7 &&
	388	git replace --graft $HASH5 &&
	389	test $(git log --oneline \| wc -l) = 3 &&
	390	commit_has_parents $HASH5 &&
	391	test_must_fail git replace --graft $HASH5 $HASH4 $HASH3 &&
	392	git replace --force -g $HASH5 $HASH4 $HASH3 &&
	393	commit_has_parents $HASH5 $HASH4 $HASH3 &&
	394	git replace -d $HASH5
	395	'
	396
a3e82672	397	test_done