#!/bin/sh

global test_description := ''ancestor culling and limiting by parent number''

source ./test-lib.sh

proc check_revlist {
	global rev_list_args := $1 &&
	shift &&
	git rev-parse @Argv >expect &&
	git rev-list $rev_list_args --all >actual &&
	test_cmp expect actual
}

test_expect_success setup '

	touch file &&
	git add file &&

	test_commit one &&

	test_tick=$(($test_tick - 2400)) &&

	test_commit two &&
	test_commit three &&
	test_commit four &&

	git log --pretty=oneline --abbrev-commit
'

test_expect_success 'one is ancestor of others and should not be shown' '

	git rev-list one --not four >result &&
	>expect &&
	test_cmp expect result

'

test_expect_success 'setup roots, merges and octopuses' '

	git checkout --orphan newroot &&
	test_commit five &&
	git checkout -b sidebranch two &&
	test_commit six &&
	git checkout -b anotherbranch three &&
	test_commit seven &&
	git checkout -b yetanotherbranch four &&
	test_commit eight &&
	git checkout master &&
	test_tick &&
	git merge --allow-unrelated-histories -m normalmerge newroot &&
	git tag normalmerge &&
	test_tick &&
	git merge -m tripus sidebranch anotherbranch &&
	git tag tripus &&
	git checkout -b tetrabranch normalmerge &&
	test_tick &&
	git merge -m tetrapus sidebranch anotherbranch yetanotherbranch &&
	git tag tetrapus &&
	git checkout master
'

test_expect_success 'rev-list roots' '

	check_revlist "--max-parents=0" one five
'

test_expect_success 'rev-list no merges' '

	check_revlist "--max-parents=1" one eight seven six five four three two &&
	check_revlist "--no-merges" one eight seven six five four three two
'

test_expect_success 'rev-list no octopuses' '

	check_revlist "--max-parents=2" one normalmerge eight seven six five four three two
'

test_expect_success 'rev-list no roots' '

	check_revlist "--min-parents=1" tetrapus tripus normalmerge eight seven six four three two
'

test_expect_success 'rev-list merges' '

	check_revlist "--min-parents=2" tetrapus tripus normalmerge &&
	check_revlist "--merges" tetrapus tripus normalmerge
'

test_expect_success 'rev-list octopus' '

	check_revlist "--min-parents=3" tetrapus tripus
'

test_expect_success 'rev-list ordinary commits' '

	check_revlist "--min-parents=1 --max-parents=1" eight seven six four three two
'

test_expect_success 'rev-list --merges --no-merges yields empty set' '

	check_revlist "--min-parents=2 --no-merges" &&
	check_revlist "--merges --no-merges" &&
	check_revlist "--no-merges --merges"
'

test_expect_success 'rev-list override and infinities' '

	check_revlist "--min-parents=2 --max-parents=1 --max-parents=3" tripus normalmerge &&
	check_revlist "--min-parents=1 --min-parents=2 --max-parents=7" tetrapus tripus normalmerge &&
	check_revlist "--min-parents=2 --max-parents=8" tetrapus tripus normalmerge &&
	check_revlist "--min-parents=2 --max-parents=-1" tetrapus tripus normalmerge &&
	check_revlist "--min-parents=2 --no-max-parents" tetrapus tripus normalmerge &&
	check_revlist "--max-parents=0 --min-parents=1 --no-min-parents" one five
'

test_expect_success 'dodecapus' '

	roots= &&
	for i in 1 2 3 4 5 6 7 8 9 10 11
	do
		git checkout -b root$i five &&
		test_commit $i &&
		roots="$roots root$i" ||
		return
	done &&
	git checkout master &&
	test_tick &&
	git merge -m dodecapus $roots &&
	git tag dodecapus &&

	check_revlist "--min-parents=4" dodecapus tetrapus &&
	check_revlist "--min-parents=8" dodecapus &&
	check_revlist "--min-parents=12" dodecapus &&
	check_revlist "--min-parents=13" &&
	check_revlist "--min-parents=4 --max-parents=11" tetrapus
'

test_expect_success 'ancestors with the same commit time' '

	test_tick_keep=$test_tick &&
	for i in 1 2 3 4 5 6 7 8; do
		test_tick=$test_tick_keep
		test_commit t$i
	done &&
	git rev-list t1^! --not t$i >result &&
	>expect &&
	test_cmp expect result
'

test_done
(CommandList
  children: [
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:test_description)
          op: Equal
          rhs: {(SQ <"ancestor culling and limiting by parent number">)}
          spids: [4]
        )
      ]
      spids: [4]
    )
    (C {(.)} {(./test-lib.sh)})
    (FuncDef
      name: check_revlist
      body: 
        (BraceGroup
          children: [
            (AndOr
              children: [
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:rev_list_args)
                      op: Equal
                      rhs: {(DQ ($ VSub_Number "$1"))}
                      spids: [23]
                    )
                  ]
                  spids: [23]
                )
                (AndOr
                  children: [
                    (C {(shift)})
                    (AndOr
                      children: [
                        (SimpleCommand
                          words: [{(git)} {(rev-parse)} {(DQ ($ VSub_At "$@"))}]
                          redirects: [(Redir op_id:Redir_Great fd:-1 arg_word:{(expect)} spids:[44])]
                        )
                        (AndOr
                          children: [
                            (SimpleCommand
                              words: [{(git)} {(rev-list)} {($ VSub_Name "$rev_list_args")} {(--all)}]
                              redirects: [
                                (Redir
                                  op_id: Redir_Great
                                  fd: -1
                                  arg_word: {(actual)}
                                  spids: [58]
                                )
                              ]
                            )
                            (C {(test_cmp)} {(expect)} {(actual)})
                          ]
                          op_id: Op_DAmp
                        )
                      ]
                      op_id: Op_DAmp
                    )
                  ]
                  op_id: Op_DAmp
                )
              ]
              op_id: Op_DAmp
            )
          ]
          spids: [20]
        )
      spids: [15 19]
    )
    (C {(test_expect_success)} {(setup)} 
      {
        (SQ <"\n"> <"\n"> <"\ttouch file &&\n"> <"\tgit add file &&\n"> <"\n"> <"\ttest_commit one &&\n"> 
          <"\n"> <"\ttest_tick=$(($test_tick - 2400)) &&\n"> <"\n"> <"\ttest_commit two &&\n"> 
          <"\ttest_commit three &&\n"> <"\ttest_commit four &&\n"> <"\n"> <"\tgit log --pretty=oneline --abbrev-commit\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"one is ancestor of others and should not be shown">)} 
      {
        (SQ <"\n"> <"\n"> <"\tgit rev-list one --not four >result &&\n"> <"\t>expect &&\n"> 
          <"\ttest_cmp expect result\n"> <"\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"setup roots, merges and octopuses">)} 
      {
        (SQ <"\n"> <"\n"> <"\tgit checkout --orphan newroot &&\n"> <"\ttest_commit five &&\n"> 
          <"\tgit checkout -b sidebranch two &&\n"> <"\ttest_commit six &&\n"> <"\tgit checkout -b anotherbranch three &&\n"> <"\ttest_commit seven &&\n"> 
          <"\tgit checkout -b yetanotherbranch four &&\n"> <"\ttest_commit eight &&\n"> <"\tgit checkout master &&\n"> <"\ttest_tick &&\n"> 
          <"\tgit merge --allow-unrelated-histories -m normalmerge newroot &&\n"> <"\tgit tag normalmerge &&\n"> <"\ttest_tick &&\n"> 
          <"\tgit merge -m tripus sidebranch anotherbranch &&\n"> <"\tgit tag tripus &&\n"> <"\tgit checkout -b tetrabranch normalmerge &&\n"> <"\ttest_tick &&\n"> 
          <"\tgit merge -m tetrapus sidebranch anotherbranch yetanotherbranch &&\n"> <"\tgit tag tetrapus &&\n"> <"\tgit checkout master\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"rev-list roots">)} 
      {(SQ <"\n"> <"\n"> <"\tcheck_revlist \"--max-parents=0\" one five\n">)}
    )
    (C {(test_expect_success)} {(SQ <"rev-list no merges">)} 
      {
        (SQ <"\n"> <"\n"> 
          <"\tcheck_revlist \"--max-parents=1\" one eight seven six five four three two &&\n"> <"\tcheck_revlist \"--no-merges\" one eight seven six five four three two\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"rev-list no octopuses">)} 
      {
        (SQ <"\n"> <"\n"> 
          <
"\tcheck_revlist \"--max-parents=2\" one normalmerge eight seven six five four three two\n"
          >
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"rev-list no roots">)} 
      {
        (SQ <"\n"> <"\n"> 
          <
"\tcheck_revlist \"--min-parents=1\" tetrapus tripus normalmerge eight seven six four three two\n"
          >
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"rev-list merges">)} 
      {
        (SQ <"\n"> <"\n"> <"\tcheck_revlist \"--min-parents=2\" tetrapus tripus normalmerge &&\n"> 
          <"\tcheck_revlist \"--merges\" tetrapus tripus normalmerge\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"rev-list octopus">)} 
      {(SQ <"\n"> <"\n"> <"\tcheck_revlist \"--min-parents=3\" tetrapus tripus\n">)}
    )
    (C {(test_expect_success)} {(SQ <"rev-list ordinary commits">)} 
      {
        (SQ <"\n"> <"\n"> 
          <"\tcheck_revlist \"--min-parents=1 --max-parents=1\" eight seven six four three two\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"rev-list --merges --no-merges yields empty set">)} 
      {
        (SQ <"\n"> <"\n"> <"\tcheck_revlist \"--min-parents=2 --no-merges\" &&\n"> 
          <"\tcheck_revlist \"--merges --no-merges\" &&\n"> <"\tcheck_revlist \"--no-merges --merges\"\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"rev-list override and infinities">)} 
      {
        (SQ <"\n"> <"\n"> 
          <
"\tcheck_revlist \"--min-parents=2 --max-parents=1 --max-parents=3\" tripus normalmerge &&\n"
          > 
          <
"\tcheck_revlist \"--min-parents=1 --min-parents=2 --max-parents=7\" tetrapus tripus normalmerge &&\n"
          > <"\tcheck_revlist \"--min-parents=2 --max-parents=8\" tetrapus tripus normalmerge &&\n"> 
          <"\tcheck_revlist \"--min-parents=2 --max-parents=-1\" tetrapus tripus normalmerge &&\n"> <"\tcheck_revlist \"--min-parents=2 --no-max-parents\" tetrapus tripus normalmerge &&\n"> 
          <"\tcheck_revlist \"--max-parents=0 --min-parents=1 --no-min-parents\" one five\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <dodecapus>)} 
      {
        (SQ <"\n"> <"\n"> <"\troots= &&\n"> <"\tfor i in 1 2 3 4 5 6 7 8 9 10 11\n"> <"\tdo\n"> 
          <"\t\tgit checkout -b root$i five &&\n"> <"\t\ttest_commit $i &&\n"> <"\t\troots=\"$roots root$i\" ||\n"> <"\t\treturn\n"> <"\tdone &&\n"> 
          <"\tgit checkout master &&\n"> <"\ttest_tick &&\n"> <"\tgit merge -m dodecapus $roots &&\n"> <"\tgit tag dodecapus &&\n"> <"\n"> 
          <"\tcheck_revlist \"--min-parents=4\" dodecapus tetrapus &&\n"> <"\tcheck_revlist \"--min-parents=8\" dodecapus &&\n"> 
          <"\tcheck_revlist \"--min-parents=12\" dodecapus &&\n"> <"\tcheck_revlist \"--min-parents=13\" &&\n"> 
          <"\tcheck_revlist \"--min-parents=4 --max-parents=11\" tetrapus\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"ancestors with the same commit time">)} 
      {
        (SQ <"\n"> <"\n"> <"\ttest_tick_keep=$test_tick &&\n"> <"\tfor i in 1 2 3 4 5 6 7 8; do\n"> 
          <"\t\ttest_tick=$test_tick_keep\n"> <"\t\ttest_commit t$i\n"> <"\tdone &&\n"> <"\tgit rev-list t1^! --not t$i >result &&\n"> 
          <"\t>expect &&\n"> <"\ttest_cmp expect result\n">
        )
      }
    )
    (C {(test_done)})
  ]
)