#!/bin/sh
#
# Copyright (c) 2008 Christian Couder
#
global test_description := ''test git rev-parse --verify''

exec </dev/null

source ./test-lib.sh

proc add_line_into_file
{
    global _line := $1
    global _file := $2

    if test -f $_file {
        echo $_line >> $_file || return $?
        global MSG := ""Add <$_line> into <$_file>.""
    } else {
        echo $_line > $_file || return $?
        git add $_file || return $?
        global MSG := ""Create file <$_file> with <$_line> inside.""
    }

    test_tick
    git commit --quiet -m $MSG $_file
}

global HASH1 := ''
global HASH2 := ''
global HASH3 := ''
global HASH4 := ''

test_expect_success 'set up basic repo with 1 file (hello) and 4 commits' '
	add_line_into_file "1: Hello World" hello &&
	HASH1=$(git rev-parse --verify HEAD) &&
	add_line_into_file "2: A new day for git" hello &&
	HASH2=$(git rev-parse --verify HEAD) &&
	add_line_into_file "3: Another new day for git" hello &&
	HASH3=$(git rev-parse --verify HEAD) &&
	add_line_into_file "4: Ciao for now" hello &&
	HASH4=$(git rev-parse --verify HEAD)
'

test_expect_success 'works with one good rev' '
	rev_hash1=$(git rev-parse --verify $HASH1) &&
	test "$rev_hash1" = "$HASH1" &&
	rev_hash2=$(git rev-parse --verify $HASH2) &&
	test "$rev_hash2" = "$HASH2" &&
	rev_hash3=$(git rev-parse --verify $HASH3) &&
	test "$rev_hash3" = "$HASH3" &&
	rev_hash4=$(git rev-parse --verify $HASH4) &&
	test "$rev_hash4" = "$HASH4" &&
	rev_master=$(git rev-parse --verify master) &&
	test "$rev_master" = "$HASH4" &&
	rev_head=$(git rev-parse --verify HEAD) &&
	test "$rev_head" = "$HASH4"
'

test_expect_success 'fails with any bad rev or many good revs' '
	test_must_fail git rev-parse --verify 2>error &&
	grep "single revision" error &&
	test_must_fail git rev-parse --verify foo 2>error &&
	grep "single revision" error &&
	test_must_fail git rev-parse --verify HEAD bar 2>error &&
	grep "single revision" error &&
	test_must_fail git rev-parse --verify baz HEAD 2>error &&
	grep "single revision" error &&
	test_must_fail git rev-parse --verify $HASH2 HEAD 2>error &&
	grep "single revision" error
'

test_expect_success 'fails silently when using -q' '
	test_must_fail git rev-parse --verify --quiet 2>error &&
	test_must_be_empty error &&
	test_must_fail git rev-parse -q --verify foo 2>error &&
	test_must_be_empty error &&
	test_must_fail git rev-parse --verify -q HEAD bar 2>error &&
	test_must_be_empty error &&
	test_must_fail git rev-parse --quiet --verify baz HEAD 2>error &&
	test_must_be_empty error &&
	test_must_fail git rev-parse -q --verify $HASH2 HEAD 2>error &&
	test_must_be_empty error
'

test_expect_success 'fails silently when using -q with deleted reflogs' '
	ref=$(git rev-parse HEAD) &&
	git update-ref --create-reflog -m "message for refs/test" refs/test "$ref" &&
	git reflog delete --updateref --rewrite refs/test@{0} &&
	test_must_fail git rev-parse -q --verify refs/test@{0} >error 2>&1 &&
	test_must_be_empty error
'

test_expect_success 'fails silently when using -q with not enough reflogs' '
	ref=$(git rev-parse HEAD) &&
	git update-ref --create-reflog -m "message for refs/test2" refs/test2 "$ref" &&
	test_must_fail git rev-parse -q --verify refs/test2@{999} >error 2>&1 &&
	test_must_be_empty error
'

test_expect_success 'succeeds silently with -q and reflogs that do not go far back enough in time' '
	ref=$(git rev-parse HEAD) &&
	git update-ref --create-reflog -m "message for refs/test3" refs/test3 "$ref" &&
	git rev-parse -q --verify refs/test3@{1.year.ago} >actual 2>error &&
	test_must_be_empty error &&
	echo "$ref" >expect &&
	test_cmp expect actual
'

test_expect_success 'no stdout output on error' '
	test -z "$(git rev-parse --verify)" &&
	test -z "$(git rev-parse --verify foo)" &&
	test -z "$(git rev-parse --verify baz HEAD)" &&
	test -z "$(git rev-parse --verify HEAD bar)" &&
	test -z "$(git rev-parse --verify $HASH2 HEAD)"
'

test_expect_success 'use --default' '
	git rev-parse --verify --default master &&
	git rev-parse --verify --default master HEAD &&
	git rev-parse --default master --verify &&
	git rev-parse --default master --verify HEAD &&
	git rev-parse --verify HEAD --default master &&
	test_must_fail git rev-parse --verify foo --default master &&
	test_must_fail git rev-parse --default HEAD --verify bar &&
	test_must_fail git rev-parse --verify --default HEAD baz &&
	test_must_fail git rev-parse --default foo --verify &&
	test_must_fail git rev-parse --verify --default bar
'

test_expect_success 'master@{n} for various n' '
	N=$(git reflog | wc -l) &&
	Nm1=$(($N-1)) &&
	Np1=$(($N+1)) &&
	git rev-parse --verify master@{0} &&
	git rev-parse --verify master@{1} &&
	git rev-parse --verify master@{$Nm1} &&
	test_must_fail git rev-parse --verify master@{$N} &&
	test_must_fail git rev-parse --verify master@{$Np1}
'

test_expect_success SYMLINKS 'ref resolution not confused by broken symlinks' '
	ln -s does-not-exist .git/refs/heads/broken &&
	test_must_fail git rev-parse --verify broken
'

test_done
(CommandList
  children: [
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:test_description)
          op: Equal
          rhs: {(SQ <"test git rev-parse --verify">)}
          spids: [12]
        )
      ]
      spids: [12]
    )
    (SimpleCommand
      words: [{(exec)}]
      redirects: [(Redir op_id:Redir_Less fd:-1 arg_word:{(/dev/null)} spids:[20])]
    )
    (C {(.)} {(./test-lib.sh)})
    (FuncDef
      name: add_line_into_file
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:_line)
                  op: Equal
                  rhs: {($ VSub_Number "$1")}
                  spids: [36]
                )
              ]
              spids: [36]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:_file)
                  op: Equal
                  rhs: {($ VSub_Number "$2")}
                  spids: [40]
                )
              ]
              spids: [40]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (C {(Lit_Other "[")} {(-f)} {(DQ ($ VSub_Name "$_file"))} {(Lit_Other "]")})
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (AndOr
                      children: [
                        (SimpleCommand
                          words: [{(echo)} {(DQ ($ VSub_Name "$_line"))}]
                          redirects: [
                            (Redir
                              op_id: Redir_DGreat
                              fd: -1
                              arg_word: {($ VSub_Name "$_file")}
                              spids: [67]
                            )
                          ]
                        )
                        (ControlFlow
                          token: <ControlFlow_Return return>
                          arg_word: {($ VSub_QMark "$?")}
                        )
                      ]
                      op_id: Op_DPipe
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:MSG)
                          op: Equal
                          rhs: 
                            {
                              (DQ ("Add <") ($ VSub_Name "$_line") ("> into <") ($ VSub_Name "$_file") 
                                (">.")
                              )
                            }
                          spids: [78]
                        )
                      ]
                      spids: [78]
                    )
                  ]
                  spids: [-1 58]
                )
              ]
              else_action: [
                (AndOr
                  children: [
                    (SimpleCommand
                      words: [{(echo)} {(DQ ($ VSub_Name "$_line"))}]
                      redirects: [
                        (Redir
                          op_id: Redir_Great
                          fd: -1
                          arg_word: {($ VSub_Name "$_file")}
                          spids: [97]
                        )
                      ]
                    )
                    (ControlFlow
                      token: <ControlFlow_Return return>
                      arg_word: {($ VSub_QMark "$?")}
                    )
                  ]
                  op_id: Op_DPipe
                )
                (AndOr
                  children: [
                    (C {(git)} {(add)} {($ VSub_Name "$_file")})
                    (ControlFlow
                      token: <ControlFlow_Return return>
                      arg_word: {($ VSub_QMark "$?")}
                    )
                  ]
                  op_id: Op_DPipe
                )
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:MSG)
                      op: Equal
                      rhs: 
                        {
                          (DQ ("Create file <") ($ VSub_Name "$_file") ("> with <") 
                            ($ VSub_Name "$_line") ("> inside.")
                          )
                        }
                      spids: [121]
                    )
                  ]
                  spids: [121]
                )
              ]
              spids: [88 131]
            )
            (C {(test_tick)})
            (C {(git)} {(commit)} {(--quiet)} {(-m)} {(DQ ($ VSub_Name "$MSG"))} {($ VSub_Name "$_file")})
          ]
          spids: [33]
        )
      spids: [29 32]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:HASH1) op:Equal rhs:{(SQ )} spids:[155])]
      spids: [155]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:HASH2) op:Equal rhs:{(SQ )} spids:[157])]
      spids: [157]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:HASH3) op:Equal rhs:{(SQ )} spids:[159])]
      spids: [159]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:HASH4) op:Equal rhs:{(SQ )} spids:[161])]
      spids: [161]
    )
    (C {(test_expect_success)} {(SQ <"set up basic repo with 1 file (hello) and 4 commits">)} 
      {
        (SQ <"\n"> <"\tadd_line_into_file \"1: Hello World\" hello &&\n"> 
          <"\tHASH1=$(git rev-parse --verify HEAD) &&\n"> <"\tadd_line_into_file \"2: A new day for git\" hello &&\n"> 
          <"\tHASH2=$(git rev-parse --verify HEAD) &&\n"> <"\tadd_line_into_file \"3: Another new day for git\" hello &&\n"> 
          <"\tHASH3=$(git rev-parse --verify HEAD) &&\n"> <"\tadd_line_into_file \"4: Ciao for now\" hello &&\n"> <"\tHASH4=$(git rev-parse --verify HEAD)\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"works with one good rev">)} 
      {
        (SQ <"\n"> <"\trev_hash1=$(git rev-parse --verify $HASH1) &&\n"> 
          <"\ttest \"$rev_hash1\" = \"$HASH1\" &&\n"> <"\trev_hash2=$(git rev-parse --verify $HASH2) &&\n"> <"\ttest \"$rev_hash2\" = \"$HASH2\" &&\n"> 
          <"\trev_hash3=$(git rev-parse --verify $HASH3) &&\n"> <"\ttest \"$rev_hash3\" = \"$HASH3\" &&\n"> <"\trev_hash4=$(git rev-parse --verify $HASH4) &&\n"> 
          <"\ttest \"$rev_hash4\" = \"$HASH4\" &&\n"> <"\trev_master=$(git rev-parse --verify master) &&\n"> <"\ttest \"$rev_master\" = \"$HASH4\" &&\n"> 
          <"\trev_head=$(git rev-parse --verify HEAD) &&\n"> <"\ttest \"$rev_head\" = \"$HASH4\"\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"fails with any bad rev or many good revs">)} 
      {
        (SQ <"\n"> <"\ttest_must_fail git rev-parse --verify 2>error &&\n"> 
          <"\tgrep \"single revision\" error &&\n"> <"\ttest_must_fail git rev-parse --verify foo 2>error &&\n"> <"\tgrep \"single revision\" error &&\n"> 
          <"\ttest_must_fail git rev-parse --verify HEAD bar 2>error &&\n"> <"\tgrep \"single revision\" error &&\n"> 
          <"\ttest_must_fail git rev-parse --verify baz HEAD 2>error &&\n"> <"\tgrep \"single revision\" error &&\n"> 
          <"\ttest_must_fail git rev-parse --verify $HASH2 HEAD 2>error &&\n"> <"\tgrep \"single revision\" error\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"fails silently when using -q">)} 
      {
        (SQ <"\n"> <"\ttest_must_fail git rev-parse --verify --quiet 2>error &&\n"> 
          <"\ttest_must_be_empty error &&\n"> <"\ttest_must_fail git rev-parse -q --verify foo 2>error &&\n"> <"\ttest_must_be_empty error &&\n"> 
          <"\ttest_must_fail git rev-parse --verify -q HEAD bar 2>error &&\n"> <"\ttest_must_be_empty error &&\n"> 
          <"\ttest_must_fail git rev-parse --quiet --verify baz HEAD 2>error &&\n"> <"\ttest_must_be_empty error &&\n"> 
          <"\ttest_must_fail git rev-parse -q --verify $HASH2 HEAD 2>error &&\n"> <"\ttest_must_be_empty error\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"fails silently when using -q with deleted reflogs">)} 
      {
        (SQ <"\n"> <"\tref=$(git rev-parse HEAD) &&\n"> 
          <"\tgit update-ref --create-reflog -m \"message for refs/test\" refs/test \"$ref\" &&\n"> <"\tgit reflog delete --updateref --rewrite refs/test@{0} &&\n"> 
          <"\ttest_must_fail git rev-parse -q --verify refs/test@{0} >error 2>&1 &&\n"> <"\ttest_must_be_empty error\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"fails silently when using -q with not enough reflogs">)} 
      {
        (SQ <"\n"> <"\tref=$(git rev-parse HEAD) &&\n"> 
          <
"\tgit update-ref --create-reflog -m \"message for refs/test2\" refs/test2 \"$ref\" &&\n"
          > <"\ttest_must_fail git rev-parse -q --verify refs/test2@{999} >error 2>&1 &&\n"> 
          <"\ttest_must_be_empty error\n">
        )
      }
    )
    (C {(test_expect_success)} 
      {(SQ <"succeeds silently with -q and reflogs that do not go far back enough in time">)} 
      {
        (SQ <"\n"> <"\tref=$(git rev-parse HEAD) &&\n"> 
          <
"\tgit update-ref --create-reflog -m \"message for refs/test3\" refs/test3 \"$ref\" &&\n"
          > <"\tgit rev-parse -q --verify refs/test3@{1.year.ago} >actual 2>error &&\n"> 
          <"\ttest_must_be_empty error &&\n"> <"\techo \"$ref\" >expect &&\n"> <"\ttest_cmp expect actual\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"no stdout output on error">)} 
      {
        (SQ <"\n"> <"\ttest -z \"$(git rev-parse --verify)\" &&\n"> 
          <"\ttest -z \"$(git rev-parse --verify foo)\" &&\n"> <"\ttest -z \"$(git rev-parse --verify baz HEAD)\" &&\n"> 
          <"\ttest -z \"$(git rev-parse --verify HEAD bar)\" &&\n"> <"\ttest -z \"$(git rev-parse --verify $HASH2 HEAD)\"\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"use --default">)} 
      {
        (SQ <"\n"> <"\tgit rev-parse --verify --default master &&\n"> 
          <"\tgit rev-parse --verify --default master HEAD &&\n"> <"\tgit rev-parse --default master --verify &&\n"> 
          <"\tgit rev-parse --default master --verify HEAD &&\n"> <"\tgit rev-parse --verify HEAD --default master &&\n"> 
          <"\ttest_must_fail git rev-parse --verify foo --default master &&\n"> <"\ttest_must_fail git rev-parse --default HEAD --verify bar &&\n"> 
          <"\ttest_must_fail git rev-parse --verify --default HEAD baz &&\n"> <"\ttest_must_fail git rev-parse --default foo --verify &&\n"> 
          <"\ttest_must_fail git rev-parse --verify --default bar\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"master@{n} for various n">)} 
      {
        (SQ <"\n"> <"\tN=$(git reflog | wc -l) &&\n"> <"\tNm1=$(($N-1)) &&\n"> <"\tNp1=$(($N+1)) &&\n"> 
          <"\tgit rev-parse --verify master@{0} &&\n"> <"\tgit rev-parse --verify master@{1} &&\n"> <"\tgit rev-parse --verify master@{$Nm1} &&\n"> 
          <"\ttest_must_fail git rev-parse --verify master@{$N} &&\n"> <"\ttest_must_fail git rev-parse --verify master@{$Np1}\n">
        )
      }
    )
    (C {(test_expect_success)} {(SYMLINKS)} {(SQ <"ref resolution not confused by broken symlinks">)} 
      {
        (SQ <"\n"> <"\tln -s does-not-exist .git/refs/heads/broken &&\n"> 
          <"\ttest_must_fail git rev-parse --verify broken\n">
        )
      }
    )
    (C {(test_done)})
  ]
)