#!/bin/sh
#
# Copyright (c) 2006 Junio C Hamano
#

global test_description := ''git rebase --merge test''

source ./test-lib.sh

global T := '"A quick brown fox
jumps over the lazy dog.'"
for i in [1 2 3 4 5 6 7 8 9 10]
{
	echo "$i $T"
} >original

test_expect_success setup '
	git add original &&
	git commit -m"initial" &&
	git branch side &&
	echo "11 $T" >>original &&
	git commit -a -m"master updates a bit." &&

	echo "12 $T" >>original &&
	git commit -a -m"master updates a bit more." &&

	git checkout side &&
	(echo "0 $T" ; cat original) >renamed &&
	git add renamed &&
	git update-index --force-remove original &&
	git commit -a -m"side renames and edits." &&

	tr "[a-z]" "[A-Z]" <original >newfile &&
	git add newfile &&
	git commit -a -m"side edits further." &&
	git branch second-side &&

	tr "[a-m]" "[A-M]" <original >newfile &&
	rm -f original &&
	git commit -a -m"side edits once again." &&

	git branch test-rebase side &&
	git branch test-rebase-pick side &&
	git branch test-reference-pick side &&
	git branch test-conflicts side &&
	git checkout -b test-merge side
'

test_expect_success 'reference merge' '
	git merge -s recursive -m "reference merge" master
'

global PRE_REBASE := $[git rev-parse test-rebase]
test_expect_success rebase '
	git checkout test-rebase &&
	GIT_TRACE=1 git rebase --merge master
'

test_expect_success 'test-rebase@{1} is pre rebase' '
	test $PRE_REBASE = $(git rev-parse test-rebase@{1})
'

test_expect_success 'merge and rebase should match' '
	git diff-tree -r test-rebase test-merge >difference &&
	if test -s difference
	then
		cat difference
		(exit 1)
	else
		echo happy
	fi
'

test_expect_success 'rebase the other way' '
	git reset --hard master &&
	git rebase --merge side
'

test_expect_success 'rebase -Xtheirs' '
	git checkout -b conflicting master~2 &&
	echo "AB $T" >> original &&
	git commit -mconflicting original &&
	git rebase -Xtheirs master &&
	grep AB original &&
	! grep 11 original
'

test_expect_success 'rebase -Xtheirs from orphan' '
	git checkout --orphan orphan-conflicting master~2 &&
	echo "AB $T" >> original &&
	git commit -morphan-conflicting original &&
	git rebase -Xtheirs master &&
	grep AB original &&
	! grep 11 original
'

test_expect_success 'merge and rebase should match' '
	git diff-tree -r test-rebase test-merge >difference &&
	if test -s difference
	then
		cat difference
		(exit 1)
	else
		echo happy
	fi
'

test_expect_success 'picking rebase' '
	git reset --hard side &&
	git rebase --merge --onto master side^^ &&
	mb=$(git merge-base master HEAD) &&
	if test "$mb" = "$(git rev-parse master)"
	then
		echo happy
	else
		git show-branch
		(exit 1)
	fi &&
	f=$(git diff-tree --name-only HEAD^ HEAD) &&
	g=$(git diff-tree --name-only HEAD^^ HEAD^) &&
	case "$f,$g" in
	newfile,newfile)
		echo happy ;;
	*)
		echo "$f"
		echo "$g"
		(exit 1)
	esac
'

test_expect_success 'rebase -s funny -Xopt' '
	test_when_finished "rm -fr test-bin funny.was.run" &&
	mkdir test-bin &&
	cat >test-bin/git-merge-funny <<-EOF &&
	#!$SHELL_PATH
	case "\$1" in --opt) ;; *) exit 2 ;; esac
	shift &&
	>funny.was.run &&
	exec git merge-recursive "\$@"
	EOF
	chmod +x test-bin/git-merge-funny &&
	git reset --hard &&
	git checkout -b test-funny master^ &&
	test_commit funny &&
	(
		PATH=./test-bin:$PATH
		git rebase -s funny -Xopt master
	) &&
	test -f funny.was.run
'

test_expect_success 'rebase --skip works with two conflicts in a row' '
	git checkout second-side  &&
	tr "[A-Z]" "[a-z]" <newfile >tmp &&
	mv tmp newfile &&
	git commit -a -m"edit conflicting with side" &&
	tr "[d-f]" "[D-F]" <newfile >tmp &&
	mv tmp newfile &&
	git commit -a -m"another edit conflicting with side" &&
	test_must_fail git rebase --merge test-conflicts &&
	test_must_fail git rebase --skip &&
	git rebase --skip
'

test_done
(CommandList
  children: [
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:test_description)
          op: Equal
          rhs: {(SQ <"git rebase --merge test">)}
          spids: [13]
        )
      ]
      spids: [13]
    )
    (C {(.)} {(./test-lib.sh)})
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:T)
          op: Equal
          rhs: {(DQ ("A quick brown fox\n") ("jumps over the lazy dog."))}
          spids: [24]
        )
      ]
      spids: [24]
    )
    (ForEach
      iter_name: i
      iter_words: [{(1)} {(2)} {(3)} {(4)} {(5)} {(6)} {(7)} {(8)} {(9)} {(10)}]
      do_arg_iter: False
      body: 
        (DoGroup
          children: [(C {(echo)} {(DQ ($ VSub_Name "$i") (" ") ($ VSub_Name "$T"))})]
          spids: [56 67]
        )
      redirects: [(Redir op_id:Redir_Great fd:-1 arg_word:{(original)} spids:[69])]
      spids: [35 -1]
    )
    (C {(test_expect_success)} {(setup)} 
      {
        (SQ <"\n"> <"\tgit add original &&\n"> <"\tgit commit -m\"initial\" &&\n"> 
          <"\tgit branch side &&\n"> <"\techo \"11 $T\" >>original &&\n"> <"\tgit commit -a -m\"master updates a bit.\" &&\n"> <"\n"> 
          <"\techo \"12 $T\" >>original &&\n"> <"\tgit commit -a -m\"master updates a bit more.\" &&\n"> <"\n"> <"\tgit checkout side &&\n"> 
          <"\t(echo \"0 $T\" ; cat original) >renamed &&\n"> <"\tgit add renamed &&\n"> <"\tgit update-index --force-remove original &&\n"> 
          <"\tgit commit -a -m\"side renames and edits.\" &&\n"> <"\n"> <"\ttr \"[a-z]\" \"[A-Z]\" <original >newfile &&\n"> <"\tgit add newfile &&\n"> 
          <"\tgit commit -a -m\"side edits further.\" &&\n"> <"\tgit branch second-side &&\n"> <"\n"> <"\ttr \"[a-m]\" \"[A-M]\" <original >newfile &&\n"> 
          <"\trm -f original &&\n"> <"\tgit commit -a -m\"side edits once again.\" &&\n"> <"\n"> <"\tgit branch test-rebase side &&\n"> 
          <"\tgit branch test-rebase-pick side &&\n"> <"\tgit branch test-reference-pick side &&\n"> <"\tgit branch test-conflicts side &&\n"> 
          <"\tgit checkout -b test-merge side\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"reference merge">)} 
      {(SQ <"\n"> <"\tgit merge -s recursive -m \"reference merge\" master\n">)}
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:PRE_REBASE)
          op: Equal
          rhs: 
            {
              (CommandSubPart
                command_list: (CommandList children:[(C {(git)} {(rev-parse)} {(test-rebase)})])
                left_token: <Left_CommandSub "$(">
                spids: [124 130]
              )
            }
          spids: [123]
        )
      ]
      spids: [123]
    )
    (C {(test_expect_success)} {(rebase)} 
      {(SQ <"\n"> <"\tgit checkout test-rebase &&\n"> <"\tGIT_TRACE=1 git rebase --merge master\n">)}
    )
    (C {(test_expect_success)} {(SQ <"test-rebase@{1} is pre rebase">)} 
      {(SQ <"\n"> <"\ttest $PRE_REBASE = $(git rev-parse test-rebase@{1})\n">)}
    )
    (C {(test_expect_success)} {(SQ <"merge and rebase should match">)} 
      {
        (SQ <"\n"> <"\tgit diff-tree -r test-rebase test-merge >difference &&\n"> 
          <"\tif test -s difference\n"> <"\tthen\n"> <"\t\tcat difference\n"> <"\t\t(exit 1)\n"> <"\telse\n"> <"\t\techo happy\n"> <"\tfi\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"rebase the other way">)} 
      {(SQ <"\n"> <"\tgit reset --hard master &&\n"> <"\tgit rebase --merge side\n">)}
    )
    (C {(test_expect_success)} {(SQ <"rebase -Xtheirs">)} 
      {
        (SQ <"\n"> <"\tgit checkout -b conflicting master~2 &&\n"> 
          <"\techo \"AB $T\" >> original &&\n"> <"\tgit commit -mconflicting original &&\n"> <"\tgit rebase -Xtheirs master &&\n"> 
          <"\tgrep AB original &&\n"> <"\t! grep 11 original\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"rebase -Xtheirs from orphan">)} 
      {
        (SQ <"\n"> <"\tgit checkout --orphan orphan-conflicting master~2 &&\n"> 
          <"\techo \"AB $T\" >> original &&\n"> <"\tgit commit -morphan-conflicting original &&\n"> <"\tgit rebase -Xtheirs master &&\n"> 
          <"\tgrep AB original &&\n"> <"\t! grep 11 original\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"merge and rebase should match">)} 
      {
        (SQ <"\n"> <"\tgit diff-tree -r test-rebase test-merge >difference &&\n"> 
          <"\tif test -s difference\n"> <"\tthen\n"> <"\t\tcat difference\n"> <"\t\t(exit 1)\n"> <"\telse\n"> <"\t\techo happy\n"> <"\tfi\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"picking rebase">)} 
      {
        (SQ <"\n"> <"\tgit reset --hard side &&\n"> <"\tgit rebase --merge --onto master side^^ &&\n"> 
          <"\tmb=$(git merge-base master HEAD) &&\n"> <"\tif test \"$mb\" = \"$(git rev-parse master)\"\n"> <"\tthen\n"> <"\t\techo happy\n"> <"\telse\n"> 
          <"\t\tgit show-branch\n"> <"\t\t(exit 1)\n"> <"\tfi &&\n"> <"\tf=$(git diff-tree --name-only HEAD^ HEAD) &&\n"> 
          <"\tg=$(git diff-tree --name-only HEAD^^ HEAD^) &&\n"> <"\tcase \"$f,$g\" in\n"> <"\tnewfile,newfile)\n"> <"\t\techo happy ;;\n"> <"\t*)\n"> 
          <"\t\techo \"$f\"\n"> <"\t\techo \"$g\"\n"> <"\t\t(exit 1)\n"> <"\tesac\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"rebase -s funny -Xopt">)} 
      {
        (SQ <"\n"> <"\ttest_when_finished \"rm -fr test-bin funny.was.run\" &&\n"> 
          <"\tmkdir test-bin &&\n"> <"\tcat >test-bin/git-merge-funny <<-EOF &&\n"> <"\t#!$SHELL_PATH\n"> 
          <"\tcase \"\\$1\" in --opt) ;; *) exit 2 ;; esac\n"> <"\tshift &&\n"> <"\t>funny.was.run &&\n"> <"\texec git merge-recursive \"\\$@\"\n"> <"\tEOF\n"> 
          <"\tchmod +x test-bin/git-merge-funny &&\n"> <"\tgit reset --hard &&\n"> <"\tgit checkout -b test-funny master^ &&\n"> <"\ttest_commit funny &&\n"> 
          <"\t(\n"> <"\t\tPATH=./test-bin:$PATH\n"> <"\t\tgit rebase -s funny -Xopt master\n"> <"\t) &&\n"> 
          <"\ttest -f funny.was.run\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"rebase --skip works with two conflicts in a row">)} 
      {
        (SQ <"\n"> <"\tgit checkout second-side  &&\n"> <"\ttr \"[A-Z]\" \"[a-z]\" <newfile >tmp &&\n"> 
          <"\tmv tmp newfile &&\n"> <"\tgit commit -a -m\"edit conflicting with side\" &&\n"> 
          <"\ttr \"[d-f]\" \"[D-F]\" <newfile >tmp &&\n"> <"\tmv tmp newfile &&\n"> <"\tgit commit -a -m\"another edit conflicting with side\" &&\n"> 
          <"\ttest_must_fail git rebase --merge test-conflicts &&\n"> <"\ttest_must_fail git rebase --skip &&\n"> <"\tgit rebase --skip\n">
        )
      }
    )
    (C {(test_done)})
  ]
)