(CommandList
  children: [
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:test_description)
          op: Equal
          rhs: {(SQ <"Test prune and reflog expiration">)}
          spids: [13]
        )
      ]
      spids: [13]
    )
    (C {(.)} {(./test-lib.sh)})
    (FuncDef
      name: check_have
      body: 
        (BraceGroup
          children: [
            (AndOr
              children: [
                (Assignment
                  keyword: Assign_None
                  pairs: [(assign_pair lhs:(LhsName name:gaah) op:Equal rhs:{(SQ )} spids:[31])]
                  spids: [31]
                )
                (AndOr
                  children: [
                    (ForEach
                      iter_name: N
                      iter_words: [{(DQ ($ VSub_At "$@"))}]
                      do_arg_iter: False
                      body: 
                        (DoGroup
                          children: [
                            (AndOr
                              children: [
                                (C {(eval)} 
                                  {
                                    (DQ ("o=") (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) 
                                      ($ VSub_Name "$N")
                                    )
                                  }
                                )
                                (AndOr
                                  children: [
                                    (C {(git)} {(cat-file)} {(-t)} {($ VSub_Name "$o")})
                                    (BraceGroup
                                      children: [
                                        (C {(echo)} {(Gaah)} {($ VSub_Name "$N")})
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:gaah)
                                              op: Equal
                                              rhs: {($ VSub_Name "$N")}
                                              spids: [80]
                                            )
                                          ]
                                          spids: [80]
                                        )
                                        (ControlFlow
                                          token: <ControlFlow_Break break>
                                        )
                                      ]
                                      spids: [70]
                                    )
                                  ]
                                  op_id: Op_DPipe
                                )
                              ]
                              op_id: Op_DAmp
                            )
                          ]
                          spids: [47 90]
                        )
                      spids: [41 -1]
                    )
                    (C {(test)} {(-z)} {(DQ ($ VSub_Name "$gaah"))})
                  ]
                  op_id: Op_DAmp
                )
              ]
              op_id: Op_DAmp
            )
          ]
          spids: [28]
        )
      spids: [23 27]
    )
    (FuncDef
      name: check_fsck
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:output)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: (CommandList children:[(C {(git)} {(fsck)} {(--full)})])
                        left_token: <Left_CommandSub "$(">
                        spids: [115 121]
                      )
                    }
                  spids: [114]
                )
              ]
              spids: [114]
            )
            (Case
              to_match: {(DQ ($ VSub_Number "$1"))}
              arms: [
                (case_arm
                  pat_list: [{(SQ )}]
                  action: [(C {(test)} {(-z)} {(DQ ($ VSub_Name "$output"))})]
                  spids: [-1 135 146 -1]
                )
                (case_arm
                  pat_list: [{(Lit_Other "*")}]
                  action: [
                    (Pipeline
                      children: [
                        (C {(echo)} {(DQ ($ VSub_Name "$output"))})
                        (C {(grep)} {(DQ ($ VSub_Number "$1"))})
                      ]
                      negated: False
                    )
                  ]
                  spids: [149 150 167 -1]
                )
              ]
              spids: [124 130 170]
            )
          ]
          spids: [111]
        )
      spids: [106 110]
    )
    (FuncDef
      name: corrupt
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:aa)
                  op: Equal
                  rhs: 
                    {
                      (BracedVarSub
                        token: <VSub_Number 1>
                        suffix_op: 
                          (StringUnary
                            op_id: VOp1_Percent
                            arg_word: {("??????????????????????????????????????")}
                          )
                        spids: [184 188]
                      )
                    }
                  spids: [183]
                )
                (assign_pair
                  lhs: (LhsName name:zz)
                  op: Equal
                  rhs: 
                    {
                      (BracedVarSub
                        token: <VSub_Number 1>
                        suffix_op: (StringUnary op_id:VOp1_Pound arg_word:{("??")})
                        spids: [191 195]
                      )
                    }
                  spids: [190]
                )
              ]
              spids: [183]
            )
            (C {(mv)} {(.git/objects/) ($ VSub_Name "$aa") (/) ($ VSub_Name "$zz")} 
              {(.git/) ($ VSub_Name "$aa") ($ VSub_Name "$zz")}
            )
          ]
          spids: [180]
        )
      spids: [175 179]
    )
    (FuncDef
      name: recover
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:aa)
                  op: Equal
                  rhs: 
                    {
                      (BracedVarSub
                        token: <VSub_Number 1>
                        suffix_op: 
                          (StringUnary
                            op_id: VOp1_Percent
                            arg_word: {("??????????????????????????????????????")}
                          )
                        spids: [221 225]
                      )
                    }
                  spids: [220]
                )
                (assign_pair
                  lhs: (LhsName name:zz)
                  op: Equal
                  rhs: 
                    {
                      (BracedVarSub
                        token: <VSub_Number 1>
                        suffix_op: (StringUnary op_id:VOp1_Pound arg_word:{("??")})
                        spids: [228 232]
                      )
                    }
                  spids: [227]
                )
              ]
              spids: [220]
            )
            (C {(mkdir)} {(-p)} {(.git/objects/) ($ VSub_Name "$aa")})
            (C {(mv)} {(.git/) ($ VSub_Name "$aa") ($ VSub_Name "$zz")} 
              {(.git/objects/) ($ VSub_Name "$aa") (/) ($ VSub_Name "$zz")}
            )
          ]
          spids: [217]
        )
      spids: [212 216]
    )
    (FuncDef
      name: check_dont_have
      body: 
        (BraceGroup
          children: [
            (AndOr
              children: [
                (Assignment
                  keyword: Assign_None
                  pairs: [(assign_pair lhs:(LhsName name:gaah) op:Equal rhs:{(SQ )} spids:[265])]
                  spids: [265]
                )
                (ForEach
                  iter_name: N
                  iter_words: [{(DQ ($ VSub_At "$@"))}]
                  do_arg_iter: False
                  body: 
                    (DoGroup
                      children: [
                        (C {(eval)} 
                          {
                            (DQ ("o=") (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) 
                              ($ VSub_Name "$N")
                            )
                          }
                        )
                        (AndOr
                          children: [
                            (C {(git)} {(cat-file)} {(-t)} {($ VSub_Name "$o")})
                            (BraceGroup
                              children: [
                                (C {(echo)} {(Gaah)} {($ VSub_Name "$N")})
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:gaah)
                                      op: Equal
                                      rhs: {($ VSub_Name "$N")}
                                      spids: [313]
                                    )
                                  ]
                                  spids: [313]
                                )
                                (ControlFlow
                                  token: <ControlFlow_Break break>
                                )
                              ]
                              spids: [303]
                            )
                          ]
                          op_id: Op_DAmp
                        )
                      ]
                      spids: [281 323]
                    )
                  spids: [275 -1]
                )
              ]
              op_id: Op_DAmp
            )
            (C {(test)} {(-z)} {(DQ ($ VSub_Name "$gaah"))})
          ]
          spids: [262]
        )
      spids: [257 261]
    )
    (C {(test_expect_success)} {(setup)} 
      {
        (SQ <"\n"> <"\tmkdir -p A/B &&\n"> <"\techo rat >C &&\n"> <"\techo ox >A/D &&\n"> 
          <"\techo tiger >A/B/E &&\n"> <"\tgit add . &&\n"> <"\n"> <"\ttest_tick && git commit -m rabbit &&\n"> 
          <"\tH=$(git rev-parse --verify HEAD) &&\n"> <"\tA=$(git rev-parse --verify HEAD:A) &&\n"> <"\tB=$(git rev-parse --verify HEAD:A/B) &&\n"> 
          <"\tC=$(git rev-parse --verify HEAD:C) &&\n"> <"\tD=$(git rev-parse --verify HEAD:A/D) &&\n"> <"\tE=$(git rev-parse --verify HEAD:A/B/E) &&\n"> 
          <"\tcheck_fsck &&\n"> <"\n"> <"\ttest_chmod +x C &&\n"> <"\tgit add C &&\n"> <"\ttest_tick && git commit -m dragon &&\n"> 
          <"\tL=$(git rev-parse --verify HEAD) &&\n"> <"\tcheck_fsck &&\n"> <"\n"> <"\trm -f C A/B/E &&\n"> <"\techo snake >F &&\n"> <"\techo horse >A/G &&\n"> 
          <"\tgit add F A/G &&\n"> <"\ttest_tick && git commit -a -m sheep &&\n"> <"\tF=$(git rev-parse --verify HEAD:F) &&\n"> 
          <"\tG=$(git rev-parse --verify HEAD:A/G) &&\n"> <"\tI=$(git rev-parse --verify HEAD:A) &&\n"> <"\tJ=$(git rev-parse --verify HEAD) &&\n"> 
          <"\tcheck_fsck &&\n"> <"\n"> <"\trm -f A/G &&\n"> <"\ttest_tick && git commit -a -m monkey &&\n"> 
          <"\tK=$(git rev-parse --verify HEAD) &&\n"> <"\tcheck_fsck &&\n"> <"\n"> <"\tcheck_have A B C D E F G H I J K L &&\n"> <"\n"> <"\tgit prune &&\n"> 
          <"\n"> <"\tcheck_have A B C D E F G H I J K L &&\n"> <"\n"> <"\tcheck_fsck &&\n"> <"\n"> 
          <"\tgit reflog refs/heads/master >output &&\n"> <"\ttest_line_count = 4 output\n">
        )
      }
    )
    (C {(test_expect_success)} {(rewind)} 
      {
        (SQ <"\n"> <"\ttest_tick && git reset --hard HEAD~2 &&\n"> <"\ttest -f C &&\n"> 
          <"\ttest -f A/B/E &&\n"> <"\t! test -f F &&\n"> <"\t! test -f A/G &&\n"> <"\n"> <"\tcheck_have A B C D E F G H I J K L &&\n"> 
          <"\n"> <"\tgit prune &&\n"> <"\n"> <"\tcheck_have A B C D E F G H I J K L &&\n"> <"\n"> 
          <"\tgit reflog refs/heads/master >output &&\n"> <"\ttest_line_count = 5 output\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"corrupt and check">)} 
      {(SQ <"\n"> <"\n"> <"\tcorrupt $F &&\n"> <"\tcheck_fsck \"missing blob $F\"\n"> <"\n">)}
    )
    (C {(test_expect_success)} {(SQ <"reflog expire --dry-run should not touch reflog">)} 
      {
        (SQ <"\n"> <"\n"> <"\tgit reflog expire --dry-run \\\n"> 
          <"\t\t--expire=$(($test_tick - 10000)) \\\n"> <"\t\t--expire-unreachable=$(($test_tick - 10000)) \\\n"> <"\t\t--stale-fix \\\n"> <"\t\t--all &&\n"> 
          <"\n"> <"\tgit reflog refs/heads/master >output &&\n"> <"\ttest_line_count = 5 output &&\n"> <"\n"> 
          <"\tcheck_fsck \"missing blob $F\"\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"reflog expire">)} 
      {
        (SQ <"\n"> <"\n"> <"\tgit reflog expire --verbose \\\n"> 
          <"\t\t--expire=$(($test_tick - 10000)) \\\n"> <"\t\t--expire-unreachable=$(($test_tick - 10000)) \\\n"> <"\t\t--stale-fix \\\n"> <"\t\t--all &&\n"> 
          <"\n"> <"\tgit reflog refs/heads/master >output &&\n"> <"\ttest_line_count = 2 output &&\n"> <"\n"> 
          <"\tcheck_fsck \"dangling commit $K\"\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"prune and fsck">)} 
      {
        (SQ <"\n"> <"\n"> <"\tgit prune &&\n"> <"\tcheck_fsck &&\n"> <"\n"> 
          <"\tcheck_have A B C D E H L &&\n"> <"\tcheck_dont_have F G I J K\n"> <"\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"recover and check">)} 
      {(SQ <"\n"> <"\n"> <"\trecover $F &&\n"> <"\tcheck_fsck \"dangling blob $F\"\n"> <"\n">)}
    )
    (C {(test_expect_success)} {(SQ <delete>)} 
      {
        (SQ <"\n"> <"\techo 1 > C &&\n"> <"\ttest_tick &&\n"> <"\tgit commit -m rat C &&\n"> <"\n"> 
          <"\techo 2 > C &&\n"> <"\ttest_tick &&\n"> <"\tgit commit -m ox C &&\n"> <"\n"> <"\techo 3 > C &&\n"> <"\ttest_tick &&\n"> 
          <"\tgit commit -m tiger C &&\n"> <"\n"> <"\tHEAD_entry_count=$(git reflog | wc -l) &&\n"> 
          <"\tmaster_entry_count=$(git reflog show master | wc -l) &&\n"> <"\n"> <"\ttest $HEAD_entry_count = 5 &&\n"> <"\ttest $master_entry_count = 5 &&\n"> <"\n"> <"\n"> 
          <"\tgit reflog delete master@{1} &&\n"> <"\tgit reflog show master > output &&\n"> 
          <"\ttest $(($master_entry_count - 1)) = $(wc -l < output) &&\n"> <"\ttest $HEAD_entry_count = $(git reflog | wc -l) &&\n"> <"\t! grep ox < output &&\n"> <"\n"> 
          <"\tmaster_entry_count=$(wc -l < output) &&\n"> <"\n"> <"\tgit reflog delete HEAD@{1} &&\n"> 
          <"\ttest $(($HEAD_entry_count -1)) = $(git reflog | wc -l) &&\n"> <"\ttest $master_entry_count = $(git reflog show master | wc -l) &&\n"> <"\n"> 
          <"\tHEAD_entry_count=$(git reflog | wc -l) &&\n"> <"\n"> <"\tgit reflog delete master@{07.04.2005.15:15:00.-0700} &&\n"> 
          <"\tgit reflog show master > output &&\n"> <"\ttest $(($master_entry_count - 1)) = $(wc -l < output) &&\n"> <"\t! grep dragon < output\n"> <"\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <rewind2>)} 
      {
        (SQ <"\n"> <"\n"> <"\ttest_tick && git reset --hard HEAD~2 &&\n"> 
          <"\tgit reflog refs/heads/master >output &&\n"> <"\ttest_line_count = 4 output\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"--expire=never">)} 
      {
        (SQ <"\n"> <"\n"> <"\tgit reflog expire --verbose \\\n"> <"\t\t--expire=never \\\n"> 
          <"\t\t--expire-unreachable=never \\\n"> <"\t\t--all &&\n"> <"\tgit reflog refs/heads/master >output &&\n"> <"\ttest_line_count = 4 output\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"gc.reflogexpire=never">)} 
      {
        (SQ <"\n"> <"\n"> <"\tgit config gc.reflogexpire never &&\n"> 
          <"\tgit config gc.reflogexpireunreachable never &&\n"> <"\tgit reflog expire --verbose --all &&\n"> <"\tgit reflog refs/heads/master >output &&\n"> 
          <"\ttest_line_count = 4 output\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"gc.reflogexpire=false">)} 
      {
        (SQ <"\n"> <"\n"> <"\tgit config gc.reflogexpire false &&\n"> 
          <"\tgit config gc.reflogexpireunreachable false &&\n"> <"\tgit reflog expire --verbose --all &&\n"> <"\tgit reflog refs/heads/master >output &&\n"> 
          <"\ttest_line_count = 4 output &&\n"> <"\n"> <"\tgit config --unset gc.reflogexpire &&\n"> 
          <"\tgit config --unset gc.reflogexpireunreachable\n"> <"\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"checkout should not delete log for packed ref">)} 
      {
        (SQ <"\n"> <"\ttest $(git reflog master | wc -l) = 4 &&\n"> <"\tgit branch foo &&\n"> 
          <"\tgit pack-refs --all &&\n"> <"\tgit checkout foo &&\n"> <"\ttest $(git reflog master | wc -l) = 4\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"stale dirs do not cause d/f conflicts (reflogs on)">)} 
      {
        (SQ <"\n"> <"\ttest_when_finished \"git branch -d one || git branch -d one/two\" &&\n"> <"\n"> 
          <"\tgit branch one/two master &&\n"> <"\techo \"one/two@{0} branch: Created from master\" >expect &&\n"> 
          <"\tgit log -g --format=\"%gd %gs\" one/two >actual &&\n"> <"\ttest_cmp expect actual &&\n"> <"\tgit branch -d one/two &&\n"> <"\n"> 
          <"\t# now logs/refs/heads/one is a stale directory, but\n"> <"\t# we should move it out of the way to create \"one\" reflog\n"> <"\tgit branch one master &&\n"> 
          <"\techo \"one@{0} branch: Created from master\" >expect &&\n"> <"\tgit log -g --format=\"%gd %gs\" one >actual &&\n"> <"\ttest_cmp expect actual\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"stale dirs do not cause d/f conflicts (reflogs off)">)} 
      {
        (SQ <"\n"> <"\ttest_when_finished \"git branch -d one || git branch -d one/two\" &&\n"> <"\n"> 
          <"\tgit branch one/two master &&\n"> <"\techo \"one/two@{0} branch: Created from master\" >expect &&\n"> 
          <"\tgit log -g --format=\"%gd %gs\" one/two >actual &&\n"> <"\ttest_cmp expect actual &&\n"> <"\tgit branch -d one/two &&\n"> <"\n"> 
          <"\t# same as before, but we only create a reflog for \"one\" if\n"> <"\t# it already exists, which it does not\n"> 
          <"\tgit -c core.logallrefupdates=false branch one master &&\n"> <"\t: >expect &&\n"> <"\tgit log -g --format=\"%gd %gs\" one >actual &&\n"> 
          <"\ttest_cmp expect actual\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"parsing reverse reflogs at BUFSIZ boundaries">)} 
      {
        (SQ <"\n"> <"\tgit checkout -b reflogskip &&\n"> 
          <"\tz38=00000000000000000000000000000000000000 &&\n"> <"\tident=\"abc <xyz> 0000000001 +0000\" &&\n"> <"\tfor i in $(test_seq 1 75); do\n"> 
          <"\t\tprintf \"$z38%02d $z38%02d %s\\t\" $i $(($i+1)) \"$ident\" &&\n"> <"\t\tif test $i = 75; then\n"> <"\t\t\tfor j in $(test_seq 1 89); do\n"> <"\t\t\t\tprintf X\n"> 
          <"\t\t\tdone\n"> <"\t\telse\n"> <"\t\t\tprintf X\n"> <"\t\tfi &&\n"> <"\t\tprintf \"\\n\"\n"> 
          <"\tdone >.git/logs/refs/heads/reflogskip &&\n"> <"\tgit rev-parse reflogskip@{73} >actual &&\n"> <"\techo ${z38}03 >expect &&\n"> 
          <"\ttest_cmp expect actual\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"no segfaults for reflog containing non-commit sha1s">)} 
      {
        (SQ <"\n"> <"\tgit update-ref --create-reflog -m \"Creating ref\" \\\n"> 
          <"\t\trefs/tests/tree-in-reflog HEAD &&\n"> <"\tgit update-ref -m \"Forcing tree\" refs/tests/tree-in-reflog HEAD^{tree} &&\n"> 
          <"\tgit update-ref -m \"Restoring to commit\" refs/tests/tree-in-reflog HEAD &&\n"> <"\tgit reflog refs/tests/tree-in-reflog\n">
        )
      }
    )
    (C {(test_expect_failure)} {(SQ <"reflog with non-commit entries displays all entries">)} 
      {
        (SQ <"\n"> <"\tgit reflog refs/tests/tree-in-reflog >actual &&\n"> 
          <"\ttest_line_count = 3 actual\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"reflog expire operates on symref not referrent">)} 
      {
        (SQ <"\n"> <"\tgit branch -l the_symref &&\n"> <"\tgit branch -l referrent &&\n"> 
          <"\tgit update-ref referrent HEAD &&\n"> <"\tgit symbolic-ref refs/heads/the_symref refs/heads/referrent &&\n"> 
          <"\ttest_when_finished \"rm -f .git/refs/heads/referrent.lock\" &&\n"> <"\ttouch .git/refs/heads/referrent.lock &&\n"> <"\tgit reflog expire --expire=all the_symref\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"continue walking past root commits">)} 
      {
        (SQ <"\n"> <"\tgit init orphanage &&\n"> <"\t(\n"> <"\t\tcd orphanage &&\n"> 
          <"\t\tcat >expect <<-\\EOF &&\n"> <"\t\tHEAD@{0} commit (initial): orphan2-1\n"> <"\t\tHEAD@{1} commit: orphan1-2\n"> 
          <"\t\tHEAD@{2} commit (initial): orphan1-1\n"> <"\t\tHEAD@{3} commit (initial): initial\n"> <"\t\tEOF\n"> <"\t\ttest_commit initial &&\n"> 
          <"\t\tgit checkout --orphan orphan1 &&\n"> <"\t\ttest_commit orphan1-1 &&\n"> <"\t\ttest_commit orphan1-2 &&\n"> 
          <"\t\tgit checkout --orphan orphan2 &&\n"> <"\t\ttest_commit orphan2-1 &&\n"> <"\t\tgit log -g --format=\"%gd %gs\" >actual &&\n"> 
          <"\t\ttest_cmp expect actual\n"> <"\t)\n">
        )
      }
    )
    (C {(test_done)})
  ]
)