(CommandList
  children: [
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:test_description)
          op: Equal
          rhs: {(SQ <"Tests git bisect functionality">)}
          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"> <"     add_line_into_file \"1: Hello World\" hello &&\n"> 
          <"     HASH1=$(git rev-parse --verify HEAD) &&\n"> <"     add_line_into_file \"2: A new day for git\" hello &&\n"> 
          <"     HASH2=$(git rev-parse --verify HEAD) &&\n"> <"     add_line_into_file \"3: Another new day for git\" hello &&\n"> 
          <"     HASH3=$(git rev-parse --verify HEAD) &&\n"> <"     add_line_into_file \"4: Ciao for now\" hello &&\n"> 
          <"     HASH4=$(git rev-parse --verify HEAD)\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"bisect starts with only one bad">)} 
      {
        (SQ <"\n"> <"\tgit bisect reset &&\n"> <"\tgit bisect start &&\n"> 
          <"\tgit bisect bad $HASH4 &&\n"> <"\tgit bisect next\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"bisect does not start with only one good">)} 
      {
        (SQ <"\n"> <"\tgit bisect reset &&\n"> <"\tgit bisect start &&\n"> 
          <"\tgit bisect good $HASH1 &&\n"> <"\ttest_must_fail git bisect next\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"bisect start with one bad and good">)} 
      {
        (SQ <"\n"> <"\tgit bisect reset &&\n"> <"\tgit bisect start &&\n"> 
          <"\tgit bisect good $HASH1 &&\n"> <"\tgit bisect bad $HASH4 &&\n"> <"\tgit bisect next\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"bisect fails if given any junk instead of revs">)} 
      {
        (SQ <"\n"> <"\tgit bisect reset &&\n"> <"\ttest_must_fail git bisect start foo $HASH1 -- &&\n"> 
          <"\ttest_must_fail git bisect start $HASH4 $HASH1 bar -- &&\n"> <"\ttest -z \"$(git for-each-ref \"refs/bisect/*\")\" &&\n"> 
          <"\ttest -z \"$(ls .git/BISECT_* 2>/dev/null)\" &&\n"> <"\tgit bisect start &&\n"> <"\ttest_must_fail git bisect good foo $HASH1 &&\n"> 
          <"\ttest_must_fail git bisect good $HASH1 bar &&\n"> <"\ttest_must_fail git bisect bad frotz &&\n"> <"\ttest_must_fail git bisect bad $HASH3 $HASH4 &&\n"> 
          <"\ttest_must_fail git bisect skip bar $HASH3 &&\n"> <"\ttest_must_fail git bisect skip $HASH1 foo &&\n"> 
          <"\ttest -z \"$(git for-each-ref \"refs/bisect/*\")\" &&\n"> <"\tgit bisect good $HASH1 &&\n"> <"\tgit bisect bad $HASH4\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"bisect reset: back in the master branch">)} 
      {
        (SQ <"\n"> <"\tgit bisect reset &&\n"> <"\techo \"* master\" > branch.expect &&\n"> 
          <"\tgit branch > branch.output &&\n"> <"\tcmp branch.expect branch.output\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"bisect reset: back in another branch">)} 
      {
        (SQ <"\n"> <"\tgit checkout -b other &&\n"> <"\tgit bisect start &&\n"> 
          <"\tgit bisect good $HASH1 &&\n"> <"\tgit bisect bad $HASH3 &&\n"> <"\tgit bisect reset &&\n"> 
          <"\techo \"  master\" > branch.expect &&\n"> <"\techo \"* other\" >> branch.expect &&\n"> <"\tgit branch > branch.output &&\n"> 
          <"\tcmp branch.expect branch.output\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"bisect reset when not bisecting">)} 
      {
        (SQ <"\n"> <"\tgit bisect reset &&\n"> <"\tgit branch > branch.output &&\n"> 
          <"\tcmp branch.expect branch.output\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"bisect reset removes packed refs">)} 
      {
        (SQ <"\n"> <"\tgit bisect reset &&\n"> <"\tgit bisect start &&\n"> 
          <"\tgit bisect good $HASH1 &&\n"> <"\tgit bisect bad $HASH3 &&\n"> <"\tgit pack-refs --all --prune &&\n"> <"\tgit bisect next &&\n"> 
          <"\tgit bisect reset &&\n"> <"\ttest -z \"$(git for-each-ref \"refs/bisect/*\")\" &&\n"> 
          <"\ttest -z \"$(git for-each-ref \"refs/heads/bisect\")\"\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"bisect reset removes bisect state after --no-checkout">)} 
      {
        (SQ <"\n"> <"\tgit bisect reset &&\n"> <"\tgit bisect start --no-checkout &&\n"> 
          <"\tgit bisect good $HASH1 &&\n"> <"\tgit bisect bad $HASH3 &&\n"> <"\tgit bisect next &&\n"> <"\tgit bisect reset &&\n"> 
          <"\ttest -z \"$(git for-each-ref \"refs/bisect/*\")\" &&\n"> <"\ttest -z \"$(git for-each-ref \"refs/heads/bisect\")\" &&\n"> 
          <"\ttest -z \"$(git for-each-ref \"BISECT_HEAD\")\"\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"bisect start: back in good branch">)} 
      {
        (SQ <"\n"> <"\tgit branch > branch.output &&\n"> 
          <"\tgrep \"* other\" branch.output > /dev/null &&\n"> <"\tgit bisect start $HASH4 $HASH1 -- &&\n"> <"\tgit bisect good &&\n"> 
          <"\tgit bisect start $HASH4 $HASH1 -- &&\n"> <"\tgit bisect bad &&\n"> <"\tgit bisect reset &&\n"> <"\tgit branch > branch.output &&\n"> 
          <"\tgrep \"* other\" branch.output > /dev/null\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"bisect start: no \".git/BISECT_START\" created if junk rev">)} 
      {
        (SQ <"\n"> <"\tgit bisect reset &&\n"> <"\ttest_must_fail git bisect start $HASH4 foo -- &&\n"> 
          <"\tgit branch > branch.output &&\n"> <"\tgrep \"* other\" branch.output > /dev/null &&\n"> <"\ttest_must_fail test -e .git/BISECT_START\n">
        )
      }
    )
    (C {(test_expect_success)} 
      {(SQ <"bisect start: existing \".git/BISECT_START\" not modified if junk rev">)} 
      {
        (SQ <"\n"> <"\tgit bisect start $HASH4 $HASH1 -- &&\n"> <"\tgit bisect good &&\n"> 
          <"\tcp .git/BISECT_START saved &&\n"> <"\ttest_must_fail git bisect start $HASH4 foo -- &&\n"> <"\tgit branch > branch.output &&\n"> 
          <
"\ttest_i18ngrep \"* (no branch, bisect started on other)\" branch.output > /dev/null &&\n"
          > <"\ttest_cmp saved .git/BISECT_START\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"bisect start: no \".git/BISECT_START\" if mistaken rev">)} 
      {
        (SQ <"\n"> <"\tgit bisect start $HASH4 $HASH1 -- &&\n"> <"\tgit bisect good &&\n"> 
          <"\ttest_must_fail git bisect start $HASH1 $HASH4 -- &&\n"> <"\tgit branch > branch.output &&\n"> <"\tgrep \"* other\" branch.output > /dev/null &&\n"> 
          <"\ttest_must_fail test -e .git/BISECT_START\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"bisect start: no \".git/BISECT_START\" if checkout error">)} 
      {
        (SQ <"\n"> <"\techo \"temp stuff\" > hello &&\n"> 
          <"\ttest_must_fail git bisect start $HASH4 $HASH1 -- &&\n"> <"\tgit branch &&\n"> <"\tgit branch > branch.output &&\n"> 
          <"\tgrep \"* other\" branch.output > /dev/null &&\n"> <"\ttest_must_fail test -e .git/BISECT_START &&\n"> 
          <"\ttest -z \"$(git for-each-ref \"refs/bisect/*\")\" &&\n"> <"\tgit checkout HEAD hello\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"bisect skip: successful result">)} 
      {
        (SQ <"\n"> <"\ttest_when_finished git bisect reset &&\n"> <"\tgit bisect reset &&\n"> 
          <"\tgit bisect start $HASH4 $HASH1 &&\n"> <"\tgit bisect skip &&\n"> <"\tgit bisect bad > my_bisect_log.txt &&\n"> 
          <"\tgrep \"$HASH2 is the first bad commit\" my_bisect_log.txt\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"bisect skip: cannot tell between 3 commits">)} 
      {
        (SQ <"\n"> <"\ttest_when_finished git bisect reset &&\n"> 
          <"\tgit bisect start $HASH4 $HASH1 &&\n"> <"\tgit bisect skip &&\n"> <"\ttest_expect_code 2 git bisect skip >my_bisect_log.txt &&\n"> 
          <"\tgrep \"first bad commit could be any of\" my_bisect_log.txt &&\n"> <"\t! grep $HASH1 my_bisect_log.txt &&\n"> <"\tgrep $HASH2 my_bisect_log.txt &&\n"> 
          <"\tgrep $HASH3 my_bisect_log.txt &&\n"> <"\tgrep $HASH4 my_bisect_log.txt\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"bisect skip: cannot tell between 2 commits">)} 
      {
        (SQ <"\n"> <"\ttest_when_finished git bisect reset &&\n"> 
          <"\tgit bisect start $HASH4 $HASH1 &&\n"> <"\tgit bisect skip &&\n"> <"\ttest_expect_code 2 git bisect good >my_bisect_log.txt &&\n"> 
          <"\tgrep \"first bad commit could be any of\" my_bisect_log.txt &&\n"> <"\t! grep $HASH1 my_bisect_log.txt &&\n"> <"\t! grep $HASH2 my_bisect_log.txt &&\n"> 
          <"\tgrep $HASH3 my_bisect_log.txt &&\n"> <"\tgrep $HASH4 my_bisect_log.txt\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"bisect skip: with commit both bad and skipped">)} 
      {
        (SQ <"\n"> <"\ttest_when_finished git bisect reset &&\n"> <"\tgit bisect start &&\n"> 
          <"\tgit bisect skip &&\n"> <"\tgit bisect bad &&\n"> <"\tgit bisect good $HASH1 &&\n"> <"\tgit bisect skip &&\n"> 
          <"\ttest_expect_code 2 git bisect good >my_bisect_log.txt &&\n"> <"\tgrep \"first bad commit could be any of\" my_bisect_log.txt &&\n"> 
          <"\t! grep $HASH1 my_bisect_log.txt &&\n"> <"\t! grep $HASH2 my_bisect_log.txt &&\n"> <"\tgrep $HASH3 my_bisect_log.txt &&\n"> 
          <"\tgrep $HASH4 my_bisect_log.txt\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"\"git bisect run\" simple case">)} 
      {
        (SQ <"echo \"#\"\\!\"/bin/sh\" > test_script.sh &&\n"> 
          <"     echo \"grep Another hello > /dev/null\" >> test_script.sh &&\n"> <"     echo \"test \\$? -ne 0\" >> test_script.sh &&\n"> <"     chmod +x test_script.sh &&\n"> 
          <"     git bisect start &&\n"> <"     git bisect good $HASH1 &&\n"> <"     git bisect bad $HASH4 &&\n"> 
          <"     git bisect run ./test_script.sh > my_bisect_log.txt &&\n"> <"     grep \"$HASH3 is the first bad commit\" my_bisect_log.txt &&\n"> <"     git bisect reset">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"\"git bisect run\" with more complex \"git bisect start\"">)} 
      {
        (SQ <"echo \"#\"\\!\"/bin/sh\" > test_script.sh &&\n"> 
          <"     echo \"grep Ciao hello > /dev/null\" >> test_script.sh &&\n"> <"     echo \"test \\$? -ne 0\" >> test_script.sh &&\n"> <"     chmod +x test_script.sh &&\n"> 
          <"     git bisect start $HASH4 $HASH1 &&\n"> <"     git bisect run ./test_script.sh > my_bisect_log.txt &&\n"> 
          <"     grep \"$HASH4 is the first bad commit\" my_bisect_log.txt &&\n"> <"     git bisect reset">
        )
      }
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:HASH5) op:Equal rhs:{(SQ )} spids:[622])]
      spids: [622]
    )
    (C {(test_expect_success)} {(SQ <"bisect skip: add line and then a new test">)} 
      {
        (SQ <"\n"> <"\tadd_line_into_file \"5: Another new line.\" hello &&\n"> 
          <"\tHASH5=$(git rev-parse --verify HEAD) &&\n"> <"\tgit bisect start $HASH5 $HASH1 &&\n"> <"\tgit bisect skip &&\n"> 
          <"\tgit bisect good > my_bisect_log.txt &&\n"> <"\tgrep \"$HASH5 is the first bad commit\" my_bisect_log.txt &&\n"> 
          <"\tgit bisect log > log_to_replay.txt &&\n"> <"\tgit bisect reset\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"bisect skip and bisect replay">)} 
      {
        (SQ <"\n"> <"\tgit bisect replay log_to_replay.txt > my_bisect_log.txt &&\n"> 
          <"\tgrep \"$HASH5 is the first bad commit\" my_bisect_log.txt &&\n"> <"\tgit bisect reset\n">
        )
      }
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:HASH6) op:Equal rhs:{(SQ )} spids:[657])]
      spids: [657]
    )
    (C {(test_expect_success)} {(SQ <"bisect run & skip: cannot tell between 2">)} 
      {
        (SQ <"\n"> <"\tadd_line_into_file \"6: Yet a line.\" hello &&\n"> 
          <"\tHASH6=$(git rev-parse --verify HEAD) &&\n"> <"\techo \"#\"\\!\"/bin/sh\" > test_script.sh &&\n"> 
          <
"\techo \"sed -ne \\\\\\$p hello | grep Ciao > /dev/null && exit 125\" >> test_script.sh &&\n"
          > <"\techo \"grep line hello > /dev/null\" >> test_script.sh &&\n"> 
          <"\techo \"test \\$? -ne 0\" >> test_script.sh &&\n"> <"\tchmod +x test_script.sh &&\n"> <"\tgit bisect start $HASH6 $HASH1 &&\n"> 
          <"\tif git bisect run ./test_script.sh > my_bisect_log.txt\n"> <"\tthen\n"> <"\t\techo Oops, should have failed.\n"> <"\t\tfalse\n"> <"\telse\n"> 
          <"\t\ttest $? -eq 2 &&\n"> <"\t\tgrep \"first bad commit could be any of\" my_bisect_log.txt &&\n"> 
          <"\t\t! grep $HASH3 my_bisect_log.txt &&\n"> <"\t\t! grep $HASH6 my_bisect_log.txt &&\n"> <"\t\tgrep $HASH4 my_bisect_log.txt &&\n"> 
          <"\t\tgrep $HASH5 my_bisect_log.txt\n"> <"\tfi\n">
        )
      }
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:HASH7) op:Equal rhs:{(SQ )} spids:[690])]
      spids: [690]
    )
    (C {(test_expect_success)} {(SQ <"bisect run & skip: find first bad">)} 
      {
        (SQ <"\n"> <"\tgit bisect reset &&\n"> 
          <"\tadd_line_into_file \"7: Should be the last line.\" hello &&\n"> <"\tHASH7=$(git rev-parse --verify HEAD) &&\n"> <"\techo \"#\"\\!\"/bin/sh\" > test_script.sh &&\n"> 
          <
"\techo \"sed -ne \\\\\\$p hello | grep Ciao > /dev/null && exit 125\" >> test_script.sh &&\n"
          > <"\techo \"sed -ne \\\\\\$p hello | grep day > /dev/null && exit 125\" >> test_script.sh &&\n"> 
          <"\techo \"grep Yet hello > /dev/null\" >> test_script.sh &&\n"> <"\techo \"test \\$? -ne 0\" >> test_script.sh &&\n"> <"\tchmod +x test_script.sh &&\n"> 
          <"\tgit bisect start $HASH7 $HASH1 &&\n"> <"\tgit bisect run ./test_script.sh > my_bisect_log.txt &&\n"> 
          <"\tgrep \"$HASH6 is the first bad commit\" my_bisect_log.txt\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"bisect skip only one range">)} 
      {
        (SQ <"\n"> <"\tgit bisect reset &&\n"> <"\tgit bisect start $HASH7 $HASH1 &&\n"> 
          <"\tgit bisect skip $HASH1..$HASH5 &&\n"> <"\ttest \"$HASH6\" = \"$(git rev-parse --verify HEAD)\" &&\n"> 
          <"\ttest_must_fail git bisect bad > my_bisect_log.txt &&\n"> <"\tgrep \"first bad commit could be any of\" my_bisect_log.txt\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"bisect skip many ranges">)} 
      {
        (SQ <"\n"> <"\tgit bisect start $HASH7 $HASH1 &&\n"> 
          <"\ttest \"$HASH4\" = \"$(git rev-parse --verify HEAD)\" &&\n"> <"\tgit bisect skip $HASH2 $HASH2.. ..$HASH5 &&\n"> 
          <"\ttest \"$HASH6\" = \"$(git rev-parse --verify HEAD)\" &&\n"> <"\ttest_must_fail git bisect bad > my_bisect_log.txt &&\n"> 
          <"\tgrep \"first bad commit could be any of\" my_bisect_log.txt\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"bisect starting with a detached HEAD">)} 
      {
        (SQ <"\n"> <"\tgit bisect reset &&\n"> <"\tgit checkout master^ &&\n"> 
          <"\tHEAD=$(git rev-parse --verify HEAD) &&\n"> <"\tgit bisect start &&\n"> <"\ttest $HEAD = $(cat .git/BISECT_START) &&\n"> 
          <"\tgit bisect reset &&\n"> <"\ttest $HEAD = $(git rev-parse --verify HEAD)\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"bisect errors out if bad and good are mistaken">)} 
      {
        (SQ <"\n"> <"\tgit bisect reset &&\n"> 
          <"\ttest_must_fail git bisect start $HASH2 $HASH4 2> rev_list_error &&\n"> <"\ttest_i18ngrep \"mistook good and bad\" rev_list_error &&\n"> <"\tgit bisect reset\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"bisect does not create a \"bisect\" branch">)} 
      {
        (SQ <"\n"> <"\tgit bisect reset &&\n"> <"\tgit bisect start $HASH7 $HASH1 &&\n"> 
          <"\tgit branch bisect &&\n"> <"\trev_hash4=$(git rev-parse --verify HEAD) &&\n"> <"\ttest \"$rev_hash4\" = \"$HASH4\" &&\n"> 
          <"\tgit branch -D bisect &&\n"> <"\tgit bisect good &&\n"> <"\tgit branch bisect &&\n"> 
          <"\trev_hash6=$(git rev-parse --verify HEAD) &&\n"> <"\ttest \"$rev_hash6\" = \"$HASH6\" &&\n"> <"\tgit bisect good > my_bisect_log.txt &&\n"> 
          <"\tgrep \"$HASH7 is the first bad commit\" my_bisect_log.txt &&\n"> <"\tgit bisect reset &&\n"> <"\trev_hash6=$(git rev-parse --verify bisect) &&\n"> 
          <"\ttest \"$rev_hash6\" = \"$HASH6\" &&\n"> <"\tgit branch -D bisect\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"side branch creation">)} 
      {
        (SQ <"\n"> <"\tgit bisect reset &&\n"> <"\tgit checkout -b side $HASH4 &&\n"> 
          <"\tadd_line_into_file \"5(side): first line on a side branch\" hello2 &&\n"> <"\tSIDE_HASH5=$(git rev-parse --verify HEAD) &&\n"> 
          <"\tadd_line_into_file \"6(side): second line on a side branch\" hello2 &&\n"> <"\tSIDE_HASH6=$(git rev-parse --verify HEAD) &&\n"> 
          <"\tadd_line_into_file \"7(side): third line on a side branch\" hello2 &&\n"> <"\tSIDE_HASH7=$(git rev-parse --verify HEAD)\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"good merge base when good and bad are siblings">)} 
      {
        (SQ <"\n"> <"\tgit bisect start \"$HASH7\" \"$SIDE_HASH7\" > my_bisect_log.txt &&\n"> 
          <"\ttest_i18ngrep \"merge base must be tested\" my_bisect_log.txt &&\n"> <"\tgrep $HASH4 my_bisect_log.txt &&\n"> <"\tgit bisect good > my_bisect_log.txt &&\n"> 
          <"\ttest_must_fail grep \"merge base must be tested\" my_bisect_log.txt &&\n"> <"\tgrep $HASH6 my_bisect_log.txt &&\n"> <"\tgit bisect reset\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"skipped merge base when good and bad are siblings">)} 
      {
        (SQ <"\n"> <"\tgit bisect start \"$SIDE_HASH7\" \"$HASH7\" > my_bisect_log.txt &&\n"> 
          <"\ttest_i18ngrep \"merge base must be tested\" my_bisect_log.txt &&\n"> <"\tgrep $HASH4 my_bisect_log.txt &&\n"> <"\tgit bisect skip > my_bisect_log.txt 2>&1 &&\n"> 
          <"\tgrep \"warning\" my_bisect_log.txt &&\n"> <"\tgrep $SIDE_HASH6 my_bisect_log.txt &&\n"> <"\tgit bisect reset\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"bad merge base when good and bad are siblings">)} 
      {
        (SQ <"\n"> <"\tgit bisect start \"$HASH7\" HEAD > my_bisect_log.txt &&\n"> 
          <"\ttest_i18ngrep \"merge base must be tested\" my_bisect_log.txt &&\n"> <"\tgrep $HASH4 my_bisect_log.txt &&\n"> 
          <"\ttest_must_fail git bisect bad > my_bisect_log.txt 2>&1 &&\n"> <"\ttest_i18ngrep \"merge base $HASH4 is bad\" my_bisect_log.txt &&\n"> 
          <"\ttest_i18ngrep \"fixed between $HASH4 and \\[$SIDE_HASH7\\]\" my_bisect_log.txt &&\n"> <"\tgit bisect reset\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"many merge bases creation">)} 
      {
        (SQ <"\n"> <"\tgit checkout \"$SIDE_HASH5\" &&\n"> 
          <"\tgit merge -m \"merge HASH5 and SIDE_HASH5\" \"$HASH5\" &&\n"> <"\tA_HASH=$(git rev-parse --verify HEAD) &&\n"> <"\tgit checkout side &&\n"> 
          <"\tgit merge -m \"merge HASH7 and SIDE_HASH7\" \"$HASH7\" &&\n"> <"\tB_HASH=$(git rev-parse --verify HEAD) &&\n"> 
          <"\tgit merge-base --all \"$A_HASH\" \"$B_HASH\" > merge_bases.txt &&\n"> <"\ttest_line_count = 2 merge_bases.txt &&\n"> <"\tgrep \"$HASH5\" merge_bases.txt &&\n"> 
          <"\tgrep \"$SIDE_HASH5\" merge_bases.txt\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"good merge bases when good and bad are siblings">)} 
      {
        (SQ <"\n"> <"\tgit bisect start \"$B_HASH\" \"$A_HASH\" > my_bisect_log.txt &&\n"> 
          <"\ttest_i18ngrep \"merge base must be tested\" my_bisect_log.txt &&\n"> <"\tgit bisect good > my_bisect_log2.txt &&\n"> 
          <"\ttest_i18ngrep \"merge base must be tested\" my_bisect_log2.txt &&\n"> <"\t{\n"> <"\t\t{\n"> <"\t\t\tgrep \"$SIDE_HASH5\" my_bisect_log.txt &&\n"> 
          <"\t\t\tgrep \"$HASH5\" my_bisect_log2.txt\n"> <"\t\t} || {\n"> <"\t\t\tgrep \"$SIDE_HASH5\" my_bisect_log2.txt &&\n"> 
          <"\t\t\tgrep \"$HASH5\" my_bisect_log.txt\n"> <"\t\t}\n"> <"\t} &&\n"> <"\tgit bisect reset\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"optimized merge base checks">)} 
      {
        (SQ <"\n"> <"\tgit bisect start \"$HASH7\" \"$SIDE_HASH7\" > my_bisect_log.txt &&\n"> 
          <"\ttest_i18ngrep \"merge base must be tested\" my_bisect_log.txt &&\n"> <"\tgrep \"$HASH4\" my_bisect_log.txt &&\n"> <"\tgit bisect good > my_bisect_log2.txt &&\n"> 
          <"\ttest -f \".git/BISECT_ANCESTORS_OK\" &&\n"> <"\ttest \"$HASH6\" = $(git rev-parse --verify HEAD) &&\n"> 
          <"\tgit bisect bad > my_bisect_log3.txt &&\n"> <"\tgit bisect good \"$A_HASH\" > my_bisect_log4.txt &&\n"> 
          <"\ttest_i18ngrep \"merge base must be tested\" my_bisect_log4.txt &&\n"> <"\ttest_must_fail test -f \".git/BISECT_ANCESTORS_OK\"\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"\"parallel\" side branch creation">)} 
      {
        (SQ <"\n"> <"\tgit bisect reset &&\n"> <"\tgit checkout -b parallel $HASH1 &&\n"> 
          <"\tmkdir dir1 dir2 &&\n"> <"\tadd_line_into_file \"1(para): line 1 on parallel branch\" dir1/file1 &&\n"> 
          <"\tPARA_HASH1=$(git rev-parse --verify HEAD) &&\n"> <"\tadd_line_into_file \"2(para): line 2 on parallel branch\" dir2/file2 &&\n"> 
          <"\tPARA_HASH2=$(git rev-parse --verify HEAD) &&\n"> <"\tadd_line_into_file \"3(para): line 3 on parallel branch\" dir2/file3 &&\n"> 
          <"\tPARA_HASH3=$(git rev-parse --verify HEAD) &&\n"> <"\tgit merge -m \"merge HASH4 and PARA_HASH3\" \"$HASH4\" &&\n"> 
          <"\tPARA_HASH4=$(git rev-parse --verify HEAD) &&\n"> <"\tadd_line_into_file \"5(para): add line on parallel branch\" dir1/file1 &&\n"> 
          <"\tPARA_HASH5=$(git rev-parse --verify HEAD) &&\n"> <"\tadd_line_into_file \"6(para): add line on parallel branch\" dir2/file2 &&\n"> 
          <"\tPARA_HASH6=$(git rev-parse --verify HEAD) &&\n"> <"\tgit merge -m \"merge HASH7 and PARA_HASH6\" \"$HASH7\" &&\n"> 
          <"\tPARA_HASH7=$(git rev-parse --verify HEAD)\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"restricting bisection on one dir">)} 
      {
        (SQ <"\n"> <"\tgit bisect reset &&\n"> <"\tgit bisect start HEAD $HASH1 -- dir1 &&\n"> 
          <"\tpara1=$(git rev-parse --verify HEAD) &&\n"> <"\ttest \"$para1\" = \"$PARA_HASH1\" &&\n"> <"\tgit bisect bad > my_bisect_log.txt &&\n"> 
          <"\tgrep \"$PARA_HASH1 is the first bad commit\" my_bisect_log.txt\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"restricting bisection on one dir and a file">)} 
      {
        (SQ <"\n"> <"\tgit bisect reset &&\n"> <"\tgit bisect start HEAD $HASH1 -- dir1 hello &&\n"> 
          <"\tpara4=$(git rev-parse --verify HEAD) &&\n"> <"\ttest \"$para4\" = \"$PARA_HASH4\" &&\n"> <"\tgit bisect bad &&\n"> 
          <"\thash3=$(git rev-parse --verify HEAD) &&\n"> <"\ttest \"$hash3\" = \"$HASH3\" &&\n"> <"\tgit bisect good &&\n"> 
          <"\thash4=$(git rev-parse --verify HEAD) &&\n"> <"\ttest \"$hash4\" = \"$HASH4\" &&\n"> <"\tgit bisect good &&\n"> 
          <"\tpara1=$(git rev-parse --verify HEAD) &&\n"> <"\ttest \"$para1\" = \"$PARA_HASH1\" &&\n"> <"\tgit bisect good > my_bisect_log.txt &&\n"> 
          <"\tgrep \"$PARA_HASH4 is the first bad commit\" my_bisect_log.txt\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"skipping away from skipped commit">)} 
      {
        (SQ <"\n"> <"\tgit bisect start $PARA_HASH7 $HASH1 &&\n"> 
          <"\tpara4=$(git rev-parse --verify HEAD) &&\n"> <"\ttest \"$para4\" = \"$PARA_HASH4\" &&\n"> <"        git bisect skip &&\n"> 
          <"\thash7=$(git rev-parse --verify HEAD) &&\n"> <"\ttest \"$hash7\" = \"$HASH7\" &&\n"> <"        git bisect skip &&\n"> 
          <"\tpara3=$(git rev-parse --verify HEAD) &&\n"> <"\ttest \"$para3\" = \"$PARA_HASH3\"\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"erroring out when using bad path parameters">)} 
      {
        (SQ <"\n"> 
          <"\ttest_must_fail git bisect start $PARA_HASH7 $HASH1 -- foobar 2> error.txt &&\n"> <"\ttest_i18ngrep \"bad path parameters\" error.txt\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"test bisection on bare repo - --no-checkout specified">)} 
      {
        (SQ <"\n"> <"\tgit clone --bare . bare.nocheckout &&\n"> <"\t(\n"> 
          <"\t\tcd bare.nocheckout &&\n"> <"\t\tgit bisect start --no-checkout &&\n"> <"\t\tgit bisect good $HASH1 &&\n"> 
          <"\t\tgit bisect bad $HASH4 &&\n"> <"\t\tgit bisect run eval \\\n"> 
          <"\t\t\t\"test \\$(git rev-list BISECT_HEAD ^$HASH2 --max-count=1 | wc -l) = 0\" \\\n"> <"\t\t\t>../nocheckout.log\n"> <"\t) &&\n"> 
          <"\tgrep \"$HASH3 is the first bad commit\" nocheckout.log\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"test bisection on bare repo - --no-checkout defaulted">)} 
      {
        (SQ <"\n"> <"\tgit clone --bare . bare.defaulted &&\n"> <"\t(\n"> <"\t\tcd bare.defaulted &&\n"> 
          <"\t\tgit bisect start &&\n"> <"\t\tgit bisect good $HASH1 &&\n"> <"\t\tgit bisect bad $HASH4 &&\n"> <"\t\tgit bisect run eval \\\n"> 
          <"\t\t\t\"test \\$(git rev-list BISECT_HEAD ^$HASH2 --max-count=1 | wc -l) = 0\" \\\n"> <"\t\t\t>../defaulted.log\n"> <"\t) &&\n"> 
          <"\tgrep \"$HASH3 is the first bad commit\" defaulted.log\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"broken branch creation">)} 
      {
        (SQ <"\n"> <"\tgit bisect reset &&\n"> <"\tgit checkout -b broken $HASH4 &&\n"> 
          <"\tgit tag BROKEN_HASH4 $HASH4 &&\n"> <"\tadd_line_into_file \"5(broken): first line on a broken branch\" hello2 &&\n"> 
          <"\tgit tag BROKEN_HASH5 &&\n"> <"\tmkdir missing &&\n"> <"\t:> missing/MISSING &&\n"> <"\tgit add missing/MISSING &&\n"> 
          <"\tgit commit -m \"6(broken): Added file that will be deleted\" &&\n"> <"\tgit tag BROKEN_HASH6 &&\n"> 
          <"\tadd_line_into_file \"7(broken): second line on a broken branch\" hello2 &&\n"> <"\tgit tag BROKEN_HASH7 &&\n"> 
          <"\tadd_line_into_file \"8(broken): third line on a broken branch\" hello2 &&\n"> <"\tgit tag BROKEN_HASH8 &&\n"> <"\tgit rm missing/MISSING &&\n"> 
          <"\tgit commit -m \"9(broken): Remove missing file\" &&\n"> <"\tgit tag BROKEN_HASH9 &&\n"> <"\trm .git/objects/39/f7e61a724187ab767d2e08442d9b6b9dab587d\n">
        )
      }
    )
    (SimpleCommand
      words: [{(echo)} {(DQ )}]
      redirects: [(Redir op_id:Redir_Great fd:-1 arg_word:{(expected.ok)} spids:[1260])]
    )
    (SimpleCommand
      words: [{(cat)}]
      redirects: [
        (Redir
          op_id: Redir_Great
          fd: -1
          arg_word: {(expected.missing-tree.default)}
          spids: [1266]
        )
        (HereDoc
          op_id: Redir_DLess
          fd: -1
          body: {(DQ ("fatal: unable to read tree 39f7e61a724187ab767d2e08442d9b6b9dab587d\n"))}
          do_expansion: True
          here_end: EOF
          was_filled: True
          spids: [1270]
        )
      ]
    )
    (C {(test_expect_success)} {(SQ <"bisect fails if tree is broken on start commit">)} 
      {
        (SQ <"\n"> <"\tgit bisect reset &&\n"> 
          <"\ttest_must_fail git bisect start BROKEN_HASH7 BROKEN_HASH4 2>error.txt &&\n"> <"\ttest_cmp expected.missing-tree.default error.txt\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"bisect fails if tree is broken on trial commit">)} 
      {
        (SQ <"\n"> <"\tgit bisect reset &&\n"> 
          <"\ttest_must_fail git bisect start BROKEN_HASH9 BROKEN_HASH4 2>error.txt &&\n"> <"\tgit reset --hard broken &&\n"> <"\tgit checkout broken &&\n"> 
          <"\ttest_cmp expected.missing-tree.default error.txt\n">
        )
      }
    )
    (FuncDef
      name: check_same
      body: 
        (BraceGroup
          children: [
            (AndOr
              children: [
                (C {(echo)} 
                  {(DQ ("Checking ") ($ VSub_Number "$1") (" is the same as ") ($ VSub_Number "$2"))}
                )
                (C {(test_cmp_rev)} {(DQ ($ VSub_Number "$1"))} {(DQ ($ VSub_Number "$2"))})
              ]
              op_id: Op_DAmp
            )
          ]
          spids: [1309]
        )
      spids: [1305 1308]
    )
    (C {(test_expect_success)} {(SQ <"bisect: --no-checkout - start commit bad">)} 
      {
        (SQ <"\n"> <"\tgit bisect reset &&\n"> 
          <"\tgit bisect start BROKEN_HASH7 BROKEN_HASH4 --no-checkout &&\n"> <"\tcheck_same BROKEN_HASH6 BISECT_HEAD &&\n"> <"\tgit bisect reset\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"bisect: --no-checkout - trial commit bad">)} 
      {
        (SQ <"\n"> <"\tgit bisect reset &&\n"> 
          <"\tgit bisect start broken BROKEN_HASH4 --no-checkout &&\n"> <"\tcheck_same BROKEN_HASH6 BISECT_HEAD &&\n"> <"\tgit bisect reset\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"bisect: --no-checkout - target before breakage">)} 
      {
        (SQ <"\n"> <"\tgit bisect reset &&\n"> 
          <"\tgit bisect start broken BROKEN_HASH4 --no-checkout &&\n"> <"\tcheck_same BROKEN_HASH6 BISECT_HEAD &&\n"> <"\tgit bisect bad BISECT_HEAD &&\n"> 
          <"\tcheck_same BROKEN_HASH5 BISECT_HEAD &&\n"> <"\tgit bisect bad BISECT_HEAD &&\n"> <"\tcheck_same BROKEN_HASH5 bisect/bad &&\n"> 
          <"\tgit bisect reset\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"bisect: --no-checkout - target in breakage">)} 
      {
        (SQ <"\n"> <"\tgit bisect reset &&\n"> 
          <"\tgit bisect start broken BROKEN_HASH4 --no-checkout &&\n"> <"\tcheck_same BROKEN_HASH6 BISECT_HEAD &&\n"> <"\tgit bisect bad BISECT_HEAD &&\n"> 
          <"\tcheck_same BROKEN_HASH5 BISECT_HEAD &&\n"> <"\tgit bisect good BISECT_HEAD &&\n"> <"\tcheck_same BROKEN_HASH6 bisect/bad &&\n"> 
          <"\tgit bisect reset\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"bisect: --no-checkout - target after breakage">)} 
      {
        (SQ <"\n"> <"\tgit bisect reset &&\n"> 
          <"\tgit bisect start broken BROKEN_HASH4 --no-checkout &&\n"> <"\tcheck_same BROKEN_HASH6 BISECT_HEAD &&\n"> <"\tgit bisect good BISECT_HEAD &&\n"> 
          <"\tcheck_same BROKEN_HASH8 BISECT_HEAD &&\n"> <"\tgit bisect good BISECT_HEAD &&\n"> <"\tcheck_same BROKEN_HASH9 bisect/bad &&\n"> 
          <"\tgit bisect reset\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"bisect: demonstrate identification of damage boundary">)} 
      {
        (DQ ("\n") ("\tgit bisect reset &&\n") ("\tgit checkout broken &&\n") 
          ("\tgit bisect start broken master --no-checkout &&\n") ("\tgit bisect run ") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) 
          (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) (SHELL_PATH) (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) (" -c '\n") ("\t\tGOOD=") 
          (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) ("(git for-each-ref ") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) ("--format=%(objectname)") 
          (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) (" refs/bisect/good-*) &&\n") ("\t\tgit rev-list --objects BISECT_HEAD --not ") 
          (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) ("GOOD >tmp.") (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) 
          (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) (" &&\n") ("\t\tgit pack-objects --stdout >/dev/null < tmp.") 
          (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) ("\n") ("\t\trc=") 
          (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) ("?\n") ("\t\trm -f tmp.") (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) 
          (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) ("\n") ("\t\ttest ") (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) ("rc = 0' &&\n") 
          ("\tcheck_same BROKEN_HASH6 bisect/bad &&\n") ("\tgit bisect reset\n")
        )
      }
    )
    (SimpleCommand
      words: [{(cat)}]
      redirects: [
        (Redir op_id:Redir_Great fd:-1 arg_word:{(expected.bisect-log)} spids:[1475])
        (HereDoc
          op_id: Redir_DLess
          fd: -1
          body: 
            {
              (DQ 
                (
"# bad: [32a594a3fdac2d57cf6d02987e30eec68511498c] Add <4: Ciao for now> into <hello>.\n"
                ) ("# good: [7b7f204a749c3125d5224ed61ea2ae1187ad046f] Add <2: A new day for git> into <hello>.\n") 
                (
"git bisect start '32a594a3fdac2d57cf6d02987e30eec68511498c' '7b7f204a749c3125d5224ed61ea2ae1187ad046f'\n"
                ) 
                (
"# good: [3de952f2416b6084f557ec417709eac740c6818c] Add <3: Another new day for git> into <hello>.\n"
                ) ("git bisect good 3de952f2416b6084f557ec417709eac740c6818c\n") 
                (
"# first bad commit: [32a594a3fdac2d57cf6d02987e30eec68511498c] Add <4: Ciao for now> into <hello>.\n"
                )
              )
            }
          do_expansion: True
          here_end: EOF
          was_filled: True
          spids: [1479]
        )
      ]
    )
    (C {(test_expect_success)} {(SQ <"bisect log: successful result">)} 
      {
        (SQ <"\n"> <"\tgit bisect reset &&\n"> <"\tgit bisect start $HASH4 $HASH2 &&\n"> 
          <"\tgit bisect good &&\n"> <"\tgit bisect log >bisect-log.txt &&\n"> <"\ttest_cmp expected.bisect-log bisect-log.txt &&\n"> 
          <"\tgit bisect reset\n">
        )
      }
    )
    (SimpleCommand
      words: [{(cat)}]
      redirects: [
        (Redir op_id:Redir_Great fd:-1 arg_word:{(expected.bisect-skip-log)} spids:[1508])
        (HereDoc
          op_id: Redir_DLess
          fd: -1
          body: 
            {
              (DQ 
                (
"# bad: [32a594a3fdac2d57cf6d02987e30eec68511498c] Add <4: Ciao for now> into <hello>.\n"
                ) ("# good: [7b7f204a749c3125d5224ed61ea2ae1187ad046f] Add <2: A new day for git> into <hello>.\n") 
                (
"git bisect start '32a594a3fdac2d57cf6d02987e30eec68511498c' '7b7f204a749c3125d5224ed61ea2ae1187ad046f'\n"
                ) 
                (
"# skip: [3de952f2416b6084f557ec417709eac740c6818c] Add <3: Another new day for git> into <hello>.\n"
                ) ("git bisect skip 3de952f2416b6084f557ec417709eac740c6818c\n") 
                ("# only skipped commits left to test\n") 
                (
"# possible first bad commit: [32a594a3fdac2d57cf6d02987e30eec68511498c] Add <4: Ciao for now> into <hello>.\n"
                ) 
                (
"# possible first bad commit: [3de952f2416b6084f557ec417709eac740c6818c] Add <3: Another new day for git> into <hello>.\n"
                )
              )
            }
          do_expansion: True
          here_end: EOF
          was_filled: True
          spids: [1512]
        )
      ]
    )
    (C {(test_expect_success)} {(SQ <"bisect log: only skip commits left">)} 
      {
        (SQ <"\n"> <"\tgit bisect reset &&\n"> <"\tgit bisect start $HASH4 $HASH2 &&\n"> 
          <"\ttest_must_fail git bisect skip &&\n"> <"\tgit bisect log >bisect-skip-log.txt &&\n"> 
          <"\ttest_cmp expected.bisect-skip-log bisect-skip-log.txt &&\n"> <"\tgit bisect reset\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"\"git bisect bad HEAD\" behaves as \"git bisect bad\"">)} 
      {
        (SQ <"\n"> <"\tgit checkout parallel &&\n"> <"\tgit bisect start HEAD $HASH1 &&\n"> 
          <"\tgit bisect good HEAD &&\n"> <"\tgit bisect bad HEAD &&\n"> <"\ttest \"$HASH6\" = $(git rev-parse --verify HEAD) &&\n"> 
          <"\tgit bisect reset\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"bisect starts with only one new">)} 
      {
        (SQ <"\n"> <"\tgit bisect reset &&\n"> <"\tgit bisect start &&\n"> 
          <"\tgit bisect new $HASH4 &&\n"> <"\tgit bisect next\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"bisect does not start with only one old">)} 
      {
        (SQ <"\n"> <"\tgit bisect reset &&\n"> <"\tgit bisect start &&\n"> 
          <"\tgit bisect old $HASH1 &&\n"> <"\ttest_must_fail git bisect next\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"bisect start with one new and old">)} 
      {
        (SQ <"\n"> <"\tgit bisect reset &&\n"> <"\tgit bisect start &&\n"> 
          <"\tgit bisect old $HASH1 &&\n"> <"\tgit bisect new $HASH4 &&\n"> <"\tgit bisect new &&\n"> <"\tgit bisect new >bisect_result &&\n"> 
          <"\tgrep \"$HASH2 is the first new commit\" bisect_result &&\n"> <"\tgit bisect log >log_to_replay.txt &&\n"> <"\tgit bisect reset\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"bisect replay with old and new">)} 
      {
        (SQ <"\n"> <"\tgit bisect replay log_to_replay.txt >bisect_result &&\n"> 
          <"\tgrep \"$HASH2 is the first new commit\" bisect_result &&\n"> <"\tgit bisect reset\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"bisect cannot mix old/new and good/bad">)} 
      {
        (SQ <"\n"> <"\tgit bisect start &&\n"> <"\tgit bisect bad $HASH4 &&\n"> 
          <"\ttest_must_fail git bisect old $HASH1\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"bisect terms needs 0 or 1 argument">)} 
      {
        (SQ <"\n"> <"\tgit bisect reset &&\n"> <"\ttest_must_fail git bisect terms only-one &&\n"> 
          <"\ttest_must_fail git bisect terms 1 2 &&\n"> <"\ttest_must_fail git bisect terms 2>actual &&\n"> <"\techo \"no terms defined\" >expected &&\n"> 
          <"\ttest_i18ncmp expected actual\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"bisect terms shows good/bad after start">)} 
      {
        (SQ <"\n"> <"\tgit bisect reset &&\n"> <"\tgit bisect start HEAD $HASH1 &&\n"> 
          <"\tgit bisect terms --term-good >actual &&\n"> <"\techo good >expected &&\n"> <"\ttest_cmp expected actual &&\n"> 
          <"\tgit bisect terms --term-bad >actual &&\n"> <"\techo bad >expected &&\n"> <"\ttest_cmp expected actual\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"bisect start with one term1 and term2">)} 
      {
        (SQ <"\n"> <"\tgit bisect reset &&\n"> 
          <"\tgit bisect start --term-old term2 --term-new term1 &&\n"> <"\tgit bisect term2 $HASH1 &&\n"> <"\tgit bisect term1 $HASH4 &&\n"> <"\tgit bisect term1 &&\n"> 
          <"\tgit bisect term1 >bisect_result &&\n"> <"\tgrep \"$HASH2 is the first term1 commit\" bisect_result &&\n"> 
          <"\tgit bisect log >log_to_replay.txt &&\n"> <"\tgit bisect reset\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"bisect replay with term1 and term2">)} 
      {
        (SQ <"\n"> <"\tgit bisect replay log_to_replay.txt >bisect_result &&\n"> 
          <"\tgrep \"$HASH2 is the first term1 commit\" bisect_result &&\n"> <"\tgit bisect reset\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"bisect start term1 term2">)} 
      {
        (SQ <"\n"> <"\tgit bisect reset &&\n"> 
          <"\tgit bisect start --term-new term1 --term-old term2 $HASH4 $HASH1 &&\n"> <"\tgit bisect term1 &&\n"> <"\tgit bisect term1 >bisect_result &&\n"> 
          <"\tgrep \"$HASH2 is the first term1 commit\" bisect_result &&\n"> <"\tgit bisect log >log_to_replay.txt &&\n"> <"\tgit bisect reset\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"bisect cannot mix terms">)} 
      {
        (SQ <"\n"> <"\tgit bisect reset &&\n"> 
          <"\tgit bisect start --term-good term1 --term-bad term2 $HASH4 $HASH1 &&\n"> <"\ttest_must_fail git bisect a &&\n"> <"\ttest_must_fail git bisect b &&\n"> 
          <"\ttest_must_fail git bisect bad &&\n"> <"\ttest_must_fail git bisect good &&\n"> <"\ttest_must_fail git bisect new &&\n"> 
          <"\ttest_must_fail git bisect old\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"bisect terms rejects invalid terms">)} 
      {
        (SQ <"\n"> <"\tgit bisect reset &&\n"> 
          <"\ttest_must_fail git bisect start --term-good invalid..term &&\n"> <"\ttest_must_fail git bisect terms --term-bad invalid..term &&\n"> 
          <"\ttest_must_fail git bisect terms --term-good bad &&\n"> <"\ttest_must_fail git bisect terms --term-good old &&\n"> 
          <"\ttest_must_fail git bisect terms --term-good skip &&\n"> <"\ttest_must_fail git bisect terms --term-good reset &&\n"> 
          <"\ttest_path_is_missing .git/BISECT_TERMS\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"bisect start --term-* does store terms">)} 
      {
        (SQ <"\n"> <"\tgit bisect reset &&\n"> 
          <"\tgit bisect start --term-bad=one --term-good=two &&\n"> <"\tgit bisect terms >actual &&\n"> <"\tcat <<-EOF >expected &&\n"> 
          <"\tYour current terms are two for the old state\n"> <"\tand one for the new state.\n"> <"\tEOF\n"> <"\ttest_i18ncmp expected actual &&\n"> 
          <"\tgit bisect terms --term-bad >actual &&\n"> <"\techo one >expected &&\n"> <"\ttest_cmp expected actual &&\n"> 
          <"\tgit bisect terms --term-good >actual &&\n"> <"\techo two >expected &&\n"> <"\ttest_cmp expected actual\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"bisect start takes options and revs in any order">)} 
      {
        (SQ <"\n"> <"\tgit bisect reset &&\n"> <"\tgit bisect start --term-good one $HASH4 \\\n"> 
          <"\t\t--term-good two --term-bad bad-term \\\n"> <"\t\t$HASH1 --term-good three -- &&\n"> 
          <"\t(git bisect terms --term-bad && git bisect terms --term-good) >actual &&\n"> <"\tprintf \"%s\\n%s\\n\" bad-term three >expected &&\n"> <"\ttest_cmp expected actual\n">
        )
      }
    )
    (C {(test_done)})
  ]
)