#!/bin/sh

global test_description := ''"git merge" top-level frontend''

source ./test-lib.sh

proc t3033_reset {
	git checkout -B master two &&
	git branch -f left three &&
	git branch -f right four
}

test_expect_success setup '
	test_commit one &&
	git branch left &&
	git branch right &&
	test_commit two &&
	git checkout left &&
	test_commit three &&
	git checkout right &&
	test_commit four &&
	git checkout --orphan newroot &&
	test_commit five &&
	git checkout master
'

# Local branches

test_expect_success 'merge an octopus into void' '
	t3033_reset &&
	git checkout --orphan test &&
	git rm -fr . &&
	test_must_fail git merge left right &&
	test_must_fail git rev-parse --verify HEAD &&
	git diff --quiet &&
	test_must_fail git rev-parse HEAD
'

test_expect_success 'merge an octopus, fast-forward (ff)' '
	t3033_reset &&
	git reset --hard one &&
	git merge left right &&
	# one is ancestor of three (left) and four (right)
	test_must_fail git rev-parse --verify HEAD^3 &&
	git rev-parse HEAD^1 HEAD^2 | sort >actual &&
	git rev-parse three four | sort >expect &&
	test_cmp expect actual
'

test_expect_success 'merge octopus, non-fast-forward (ff)' '
	t3033_reset &&
	git reset --hard one &&
	git merge --no-ff left right &&
	# one is ancestor of three (left) and four (right)
	test_must_fail git rev-parse --verify HEAD^4 &&
	git rev-parse HEAD^1 HEAD^2 HEAD^3 | sort >actual &&
	git rev-parse one three four | sort >expect &&
	test_cmp expect actual
'

test_expect_success 'merge octopus, fast-forward (does not ff)' '
	t3033_reset &&
	git merge left right &&
	# two (master) is not an ancestor of three (left) and four (right)
	test_must_fail git rev-parse --verify HEAD^4 &&
	git rev-parse HEAD^1 HEAD^2 HEAD^3 | sort >actual &&
	git rev-parse two three four | sort >expect &&
	test_cmp expect actual
'

test_expect_success 'merge octopus, non-fast-forward' '
	t3033_reset &&
	git merge --no-ff left right &&
	test_must_fail git rev-parse --verify HEAD^4 &&
	git rev-parse HEAD^1 HEAD^2 HEAD^3 | sort >actual &&
	git rev-parse two three four | sort >expect &&
	test_cmp expect actual
'

# The same set with FETCH_HEAD

test_expect_success 'merge FETCH_HEAD octopus into void' '
	t3033_reset &&
	git checkout --orphan test &&
	git rm -fr . &&
	git fetch . left right &&
	test_must_fail git merge FETCH_HEAD &&
	test_must_fail git rev-parse --verify HEAD &&
	git diff --quiet &&
	test_must_fail git rev-parse HEAD
'

test_expect_success 'merge FETCH_HEAD octopus fast-forward (ff)' '
	t3033_reset &&
	git reset --hard one &&
	git fetch . left right &&
	git merge FETCH_HEAD &&
	# one is ancestor of three (left) and four (right)
	test_must_fail git rev-parse --verify HEAD^3 &&
	git rev-parse HEAD^1 HEAD^2 | sort >actual &&
	git rev-parse three four | sort >expect &&
	test_cmp expect actual
'

test_expect_success 'merge FETCH_HEAD octopus non-fast-forward (ff)' '
	t3033_reset &&
	git reset --hard one &&
	git fetch . left right &&
	git merge --no-ff FETCH_HEAD &&
	# one is ancestor of three (left) and four (right)
	test_must_fail git rev-parse --verify HEAD^4 &&
	git rev-parse HEAD^1 HEAD^2 HEAD^3 | sort >actual &&
	git rev-parse one three four | sort >expect &&
	test_cmp expect actual
'

test_expect_success 'merge FETCH_HEAD octopus fast-forward (does not ff)' '
	t3033_reset &&
	git fetch . left right &&
	git merge FETCH_HEAD &&
	# two (master) is not an ancestor of three (left) and four (right)
	test_must_fail git rev-parse --verify HEAD^4 &&
	git rev-parse HEAD^1 HEAD^2 HEAD^3 | sort >actual &&
	git rev-parse two three four | sort >expect &&
	test_cmp expect actual
'

test_expect_success 'merge FETCH_HEAD octopus non-fast-forward' '
	t3033_reset &&
	git fetch . left right &&
	git merge --no-ff FETCH_HEAD &&
	test_must_fail git rev-parse --verify HEAD^4 &&
	git rev-parse HEAD^1 HEAD^2 HEAD^3 | sort >actual &&
	git rev-parse two three four | sort >expect &&
	test_cmp expect actual
'

# two-project merge
test_expect_success 'refuse two-project merge by default' '
	t3033_reset &&
	git reset --hard four &&
	test_must_fail git merge five
'

test_expect_success 'two-project merge with --allow-unrelated-histories' '
	t3033_reset &&
	git reset --hard four &&
	git merge --allow-unrelated-histories five &&
	git diff --exit-code five
'

test_done
(CommandList
  children: [
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:test_description)
          op: Equal
          rhs: {(SQ <"\"git merge\" top-level frontend">)}
          spids: [4]
        )
      ]
      spids: [4]
    )
    (C {(.)} {(./test-lib.sh)})
    (FuncDef
      name: t3033_reset
      body: 
        (BraceGroup
          children: [
            (AndOr
              children: [
                (C {(git)} {(checkout)} {(-B)} {(master)} {(two)})
                (AndOr
                  children: [
                    (C {(git)} {(branch)} {(-f)} {(left)} {(three)})
                    (C {(git)} {(branch)} {(-f)} {(right)} {(four)})
                  ]
                  op_id: Op_DAmp
                )
              ]
              op_id: Op_DAmp
            )
          ]
          spids: [20]
        )
      spids: [15 19]
    )
    (C {(test_expect_success)} {(setup)} 
      {
        (SQ <"\n"> <"\ttest_commit one &&\n"> <"\tgit branch left &&\n"> <"\tgit branch right &&\n"> 
          <"\ttest_commit two &&\n"> <"\tgit checkout left &&\n"> <"\ttest_commit three &&\n"> <"\tgit checkout right &&\n"> 
          <"\ttest_commit four &&\n"> <"\tgit checkout --orphan newroot &&\n"> <"\ttest_commit five &&\n"> <"\tgit checkout master\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"merge an octopus into void">)} 
      {
        (SQ <"\n"> <"\tt3033_reset &&\n"> <"\tgit checkout --orphan test &&\n"> <"\tgit rm -fr . &&\n"> 
          <"\ttest_must_fail git merge left right &&\n"> <"\ttest_must_fail git rev-parse --verify HEAD &&\n"> <"\tgit diff --quiet &&\n"> 
          <"\ttest_must_fail git rev-parse HEAD\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"merge an octopus, fast-forward (ff)">)} 
      {
        (SQ <"\n"> <"\tt3033_reset &&\n"> <"\tgit reset --hard one &&\n"> 
          <"\tgit merge left right &&\n"> <"\t# one is ancestor of three (left) and four (right)\n"> 
          <"\ttest_must_fail git rev-parse --verify HEAD^3 &&\n"> <"\tgit rev-parse HEAD^1 HEAD^2 | sort >actual &&\n"> 
          <"\tgit rev-parse three four | sort >expect &&\n"> <"\ttest_cmp expect actual\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"merge octopus, non-fast-forward (ff)">)} 
      {
        (SQ <"\n"> <"\tt3033_reset &&\n"> <"\tgit reset --hard one &&\n"> 
          <"\tgit merge --no-ff left right &&\n"> <"\t# one is ancestor of three (left) and four (right)\n"> 
          <"\ttest_must_fail git rev-parse --verify HEAD^4 &&\n"> <"\tgit rev-parse HEAD^1 HEAD^2 HEAD^3 | sort >actual &&\n"> 
          <"\tgit rev-parse one three four | sort >expect &&\n"> <"\ttest_cmp expect actual\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"merge octopus, fast-forward (does not ff)">)} 
      {
        (SQ <"\n"> <"\tt3033_reset &&\n"> <"\tgit merge left right &&\n"> 
          <"\t# two (master) is not an ancestor of three (left) and four (right)\n"> <"\ttest_must_fail git rev-parse --verify HEAD^4 &&\n"> 
          <"\tgit rev-parse HEAD^1 HEAD^2 HEAD^3 | sort >actual &&\n"> <"\tgit rev-parse two three four | sort >expect &&\n"> <"\ttest_cmp expect actual\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"merge octopus, non-fast-forward">)} 
      {
        (SQ <"\n"> <"\tt3033_reset &&\n"> <"\tgit merge --no-ff left right &&\n"> 
          <"\ttest_must_fail git rev-parse --verify HEAD^4 &&\n"> <"\tgit rev-parse HEAD^1 HEAD^2 HEAD^3 | sort >actual &&\n"> 
          <"\tgit rev-parse two three four | sort >expect &&\n"> <"\ttest_cmp expect actual\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"merge FETCH_HEAD octopus into void">)} 
      {
        (SQ <"\n"> <"\tt3033_reset &&\n"> <"\tgit checkout --orphan test &&\n"> <"\tgit rm -fr . &&\n"> 
          <"\tgit fetch . left right &&\n"> <"\ttest_must_fail git merge FETCH_HEAD &&\n"> <"\ttest_must_fail git rev-parse --verify HEAD &&\n"> 
          <"\tgit diff --quiet &&\n"> <"\ttest_must_fail git rev-parse HEAD\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"merge FETCH_HEAD octopus fast-forward (ff)">)} 
      {
        (SQ <"\n"> <"\tt3033_reset &&\n"> <"\tgit reset --hard one &&\n"> 
          <"\tgit fetch . left right &&\n"> <"\tgit merge FETCH_HEAD &&\n"> <"\t# one is ancestor of three (left) and four (right)\n"> 
          <"\ttest_must_fail git rev-parse --verify HEAD^3 &&\n"> <"\tgit rev-parse HEAD^1 HEAD^2 | sort >actual &&\n"> 
          <"\tgit rev-parse three four | sort >expect &&\n"> <"\ttest_cmp expect actual\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"merge FETCH_HEAD octopus non-fast-forward (ff)">)} 
      {
        (SQ <"\n"> <"\tt3033_reset &&\n"> <"\tgit reset --hard one &&\n"> 
          <"\tgit fetch . left right &&\n"> <"\tgit merge --no-ff FETCH_HEAD &&\n"> <"\t# one is ancestor of three (left) and four (right)\n"> 
          <"\ttest_must_fail git rev-parse --verify HEAD^4 &&\n"> <"\tgit rev-parse HEAD^1 HEAD^2 HEAD^3 | sort >actual &&\n"> 
          <"\tgit rev-parse one three four | sort >expect &&\n"> <"\ttest_cmp expect actual\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"merge FETCH_HEAD octopus fast-forward (does not ff)">)} 
      {
        (SQ <"\n"> <"\tt3033_reset &&\n"> <"\tgit fetch . left right &&\n"> 
          <"\tgit merge FETCH_HEAD &&\n"> <"\t# two (master) is not an ancestor of three (left) and four (right)\n"> 
          <"\ttest_must_fail git rev-parse --verify HEAD^4 &&\n"> <"\tgit rev-parse HEAD^1 HEAD^2 HEAD^3 | sort >actual &&\n"> 
          <"\tgit rev-parse two three four | sort >expect &&\n"> <"\ttest_cmp expect actual\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"merge FETCH_HEAD octopus non-fast-forward">)} 
      {
        (SQ <"\n"> <"\tt3033_reset &&\n"> <"\tgit fetch . left right &&\n"> 
          <"\tgit merge --no-ff FETCH_HEAD &&\n"> <"\ttest_must_fail git rev-parse --verify HEAD^4 &&\n"> 
          <"\tgit rev-parse HEAD^1 HEAD^2 HEAD^3 | sort >actual &&\n"> <"\tgit rev-parse two three four | sort >expect &&\n"> <"\ttest_cmp expect actual\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"refuse two-project merge by default">)} 
      {
        (SQ <"\n"> <"\tt3033_reset &&\n"> <"\tgit reset --hard four &&\n"> 
          <"\ttest_must_fail git merge five\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"two-project merge with --allow-unrelated-histories">)} 
      {
        (SQ <"\n"> <"\tt3033_reset &&\n"> <"\tgit reset --hard four &&\n"> 
          <"\tgit merge --allow-unrelated-histories five &&\n"> <"\tgit diff --exit-code five\n">
        )
      }
    )
    (C {(test_done)})
  ]
)