(command.CommandList
  children: [
    (command.ShAssignment
      left: <Id.Lit_VarLike 'test_description='>
      pairs: [
        (AssignPair
          left: <Id.Lit_VarLike 'test_description='>
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'test_description='> name:test_description)
          op: assign_op.Equal
          rhs: {(SQ <'pack index with 64-bit offsets and object CRC'>)}
        )
      ]
      redirects: []
    )
    (command.Simple
      blame_tok: <.>
      more_env: []
      words: [{<.>} {<'./test-lib.sh'>}]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <setup>)}
        {
          (SQ <'rm -rf .git &&\n'> <'     git init &&\n'> <'     git config pack.threads 1 &&\n'> 
            <'     i=1 &&\n'> <'     while test $i -le 100\n'> <'     do\n'> <'         iii=$(printf '>
          ) <Id.Lit_Other '%'> <03i> 
          (SQ <' $i)\n'> <'         test-genrandom "bar" 200 > wide_delta_$iii &&\n'> 
            <'         test-genrandom "baz $iii" 50 >> wide_delta_$iii &&\n'> <'         test-genrandom "foo"$i 100 > deep_delta_$iii &&\n'> 
            <'         test-genrandom "foo"$(expr $i + 1) 100 >> deep_delta_$iii &&\n'> <'         test-genrandom "foo"$(expr $i + 2) 100 >> deep_delta_$iii &&\n'> 
            <'         echo $iii >file_$iii &&\n'> <'         test-genrandom "$iii" 8192 >>file_$iii &&\n'> 
            <'         git update-index --add file_$iii deep_delta_$iii wide_delta_$iii &&\n'> <'         i=$(expr $i + 1) || return 1\n'> <'     done &&\n'> 
            <'     { echo 101 && test-genrandom 100 8192; } >file_101 &&\n'> <'     git update-index --add file_101 &&\n'> <'     tree=$(git write-tree) &&\n'> 
            <'     commit=$(git commit-tree $tree </dev/null) && {\n'> <'\t echo $tree &&\n'> <'\t git ls-tree $tree | sed -e "s/.* \\\\([0-9a-f]*\\\\)\t.*/\\\\1/"\n'> 
            <'     } >obj-list &&\n'> <'     git update-ref HEAD $commit'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'pack-objects with index version 1'>)}
        {
          (SQ <'pack1=$(git pack-objects --index-version=1 test-1 <obj-list) &&\n'> 
            <'     git verify-pack -v "test-1-${pack1}.pack"'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'pack-objects with index version 2'>)}
        {
          (SQ <'pack2=$(git pack-objects --index-version=2 test-2 <obj-list) &&\n'> 
            <'     git verify-pack -v "test-2-${pack2}.pack"'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'both packs should be identical'>)}
        {(SQ <'cmp "test-1-${pack1}.pack" "test-2-${pack2}.pack"'>)}
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'index v1 and index v2 should be different'>)}
        {(SQ <'! cmp "test-1-${pack1}.idx" "test-2-${pack2}.idx"'>)}
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'index-pack with index version 1'>)}
        {(SQ <'git index-pack --index-version=1 -o 1.idx "test-1-${pack1}.pack"'>)}
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'index-pack with index version 2'>)}
        {(SQ <'git index-pack --index-version=2 -o 2.idx "test-1-${pack1}.pack"'>)}
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'index-pack results should match pack-objects ones'>)}
        {(SQ <'cmp "test-1-${pack1}.idx" "1.idx" &&\n'> <'     cmp "test-2-${pack2}.idx" "2.idx"'>)}
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'index-pack --verify on index version 1'>)}
        {(SQ <'\n'> <'\tgit index-pack --verify "test-1-${pack1}.pack"\n'>)}
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'index-pack --verify on index version 2'>)}
        {(SQ <'\n'> <'\tgit index-pack --verify "test-2-${pack2}.pack"\n'>)}
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'pack-objects --index-version=2, is not accepted'>)}
        {(SQ <'test_must_fail git pack-objects --index-version=2, test-3 <obj-list'>)}
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'index v2: force some 64-bit offsets with pack-objects'>)}
        {(SQ <'pack3=$(git pack-objects --index-version=2,0x40000 test-3 <obj-list)'>)}
      ]
      redirects: []
      do_fork: T
    )
    (command.If
      if_kw: <Id.KW_If if>
      arms: [
        (IfArm
          keyword: <Id.KW_If if>
          cond: 
            (condition.Shell
              commands: [
                (command.AndOr
                  children: [
                    (command.ShAssignment
                      left: <Id.Lit_VarLike 'msg='>
                      pairs: [
                        (AssignPair
                          left: <Id.Lit_VarLike 'msg='>
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'msg='> name:msg)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (CommandSub
                                left_token: <Id.Left_DollarParen '$('>
                                child: 
                                  (command.Simple
                                    blame_tok: <git>
                                    more_env: []
                                    words: [
                                      {<git>}
                                      {<verify-pack>}
                                      {<-v>}
                                      {(DQ <test-3-> (${ Id.VSub_Name pack3) <.pack>)}
                                    ]
                                    redirects: [
                                      (Redir
                                        op: <Id.Redir_GreatAnd '2>&'>
                                        loc: (redir_loc.Fd fd:2)
                                        arg: {<1>}
                                      )
                                    ]
                                    do_fork: T
                                  )
                                right: <Id.Eof_RParen _>
                              )
                            }
                        )
                      ]
                      redirects: []
                    )
                    (command.Pipeline
                      negated: <Id.KW_Bang '!'>
                      children: [
                        (command.Subshell
                          left: <Id.Op_LParen _>
                          child: 
                            (command.Pipeline
                              children: [
                                (command.Simple
                                  blame_tok: <echo>
                                  more_env: []
                                  words: [{<echo>} {(DQ ($ Id.VSub_DollarName msg))}]
                                  redirects: []
                                  do_fork: T
                                )
                                (command.Simple
                                  blame_tok: <grep>
                                  more_env: []
                                  words: [{<grep>} {(DQ <'pack too large .* off_t'>)}]
                                  redirects: []
                                  do_fork: T
                                )
                              ]
                              ops: [<Id.Op_Pipe _>]
                            )
                          right: <Id.Right_Subshell _>
                          redirects: []
                        )
                      ]
                      ops: []
                    )
                  ]
                  ops: [<Id.Op_DPipe _>]
                )
              ]
            )
          then_kw: <Id.KW_Then then>
          action: [
            (command.Simple
              blame_tok: <test_set_prereq>
              more_env: []
              words: [{<test_set_prereq>} {<OFF64_T>}]
              redirects: []
              do_fork: T
            )
          ]
          spids: [229 272]
        )
      ]
      else_kw: <Id.KW_Else else>
      else_action: [
        (command.Simple
          blame_tok: <say>
          more_env: []
          words: [{<say>} {(DQ <'# skipping tests concerning 64-bit offsets'>)}]
          redirects: []
          do_fork: T
        )
      ]
      fi_kw: <Id.KW_Fi fi>
      redirects: []
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {<OFF64_T>}
        {(SQ <'index v2: verify a pack with some 64-bit offsets'>)}
        {(SQ <'git verify-pack -v "test-3-${pack3}.pack"'>)}
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {<OFF64_T>}
        {(SQ <'64-bit offsets: should be different from previous index v2 results'>)}
        {(SQ <'! cmp "test-2-${pack2}.idx" "test-3-${pack3}.idx"'>)}
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {<OFF64_T>}
        {(SQ <'index v2: force some 64-bit offsets with index-pack'>)}
        {(SQ <'git index-pack --index-version=2,0x40000 -o 3.idx "test-1-${pack1}.pack"'>)}
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {<OFF64_T>}
        {(SQ <'64-bit offsets: index-pack result should match pack-objects one'>)}
        {(SQ <'cmp "test-3-${pack3}.idx" "3.idx"'>)}
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {<OFF64_T>}
        {(SQ <'index-pack --verify on 64-bit offset v2 (cheat)'>)}
        {
          (SQ <'\n'> <'\t# This cheats by knowing which lower offset should still be encoded\n'> 
            <'\t# in 64-bit representation.\n'> <'\tgit index-pack --verify --index-version=2,0x40000 "test-3-${pack3}.pack"\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {<OFF64_T>}
        {(SQ <'index-pack --verify on 64-bit offset v2'>)}
        {(SQ <'\n'> <'\tgit index-pack --verify "test-3-${pack3}.pack"\n'>)}
      ]
      redirects: []
      do_fork: T
    )
    (command.ShFunction
      name_tok: <index_obj_nr>
      name: index_obj_nr
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.ShAssignment
              left: <Id.Lit_VarLike 'idx_file='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'idx_file='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'idx_file='> name:idx_file)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_Number 1)}
                )
              ]
              redirects: []
            )
            (command.ShAssignment
              left: <Id.Lit_VarLike 'object_sha1='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'object_sha1='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'object_sha1='> name:object_sha1)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_Number 2)}
                )
              ]
              redirects: []
            )
            (command.ShAssignment
              left: <Id.Lit_VarLike 'nr='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'nr='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'nr='> name:nr)
                  op: assign_op.Equal
                  rhs: {<0>}
                )
              ]
              redirects: []
            )
            (command.Pipeline
              children: [
                (command.Simple
                  blame_tok: <git>
                  more_env: []
                  words: [{<git>} {<show-index>}]
                  redirects: [
                    (Redir
                      op: <Id.Redir_Less '<'>
                      loc: (redir_loc.Fd fd:0)
                      arg: {($ Id.VSub_DollarName idx_file)}
                    )
                  ]
                  do_fork: T
                )
                (command.WhileUntil
                  keyword: <Id.KW_While while>
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Simple
                          blame_tok: <read>
                          more_env: []
                          words: [{<read>} {<offs>} {<sha1>} {<extra>}]
                          redirects: []
                          do_fork: T
                        )
                      ]
                    )
                  body: 
                    (command.DoGroup
                      left: <Id.KW_Do do>
                      children: [
                        (command.ShAssignment
                          left: <Id.Lit_VarLike 'nr='>
                          pairs: [
                            (AssignPair
                              left: <Id.Lit_VarLike 'nr='>
                              lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'nr='> name:nr)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (word_part.ArithSub
                                    left: <Id.Left_DollarDParen '$(('>
                                    anode: 
                                      (arith_expr.Binary
                                        op_id: Id.Arith_Plus
                                        left: {($ Id.VSub_DollarName nr)}
                                        right: {<Id.Lit_Digits 1>}
                                      )
                                    right: <Id.Right_DollarDParen _>
                                  )
                                }
                            )
                          ]
                          redirects: []
                        )
                        (command.AndOr
                          children: [
                            (command.Simple
                              blame_tok: <test>
                              more_env: []
                              words: [
                                {<test>}
                                {(DQ ($ Id.VSub_DollarName sha1))}
                                {<Id.Lit_Equals '='>}
                                {(DQ ($ Id.VSub_DollarName object_sha1))}
                              ]
                              redirects: []
                              do_fork: T
                            )
                            (command.ControlFlow
                              keyword: <Id.ControlFlow_Continue continue>
                            )
                          ]
                          ops: [<Id.Op_DPipe _>]
                        )
                        (command.Simple
                          blame_tok: <echo>
                          more_env: []
                          words: [
                            {<echo>}
                            {
                              (DQ 
                                (word_part.ArithSub
                                  left: <Id.Left_DollarDParen '$(('>
                                  anode: 
                                    (arith_expr.Binary
                                      op_id: Id.Arith_Minus
                                      left: {($ Id.VSub_DollarName nr)}
                                      right: {<Id.Lit_Digits 1>}
                                    )
                                  right: <Id.Right_DollarDParen _>
                                )
                              )
                            }
                          ]
                          redirects: []
                          do_fork: T
                        )
                        (command.ControlFlow
                          keyword: <Id.ControlFlow_Break break>
                        )
                      ]
                      right: <Id.KW_Done done>
                    )
                  redirects: []
                )
              ]
              ops: [<Id.Op_Pipe _>]
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name_tok: <index_obj_offset>
      name: index_obj_offset
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.ShAssignment
              left: <Id.Lit_VarLike 'idx_file='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'idx_file='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'idx_file='> name:idx_file)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_Number 1)}
                )
              ]
              redirects: []
            )
            (command.ShAssignment
              left: <Id.Lit_VarLike 'object_sha1='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'object_sha1='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'object_sha1='> name:object_sha1)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_Number 2)}
                )
              ]
              redirects: []
            )
            (command.Pipeline
              children: [
                (command.Simple
                  blame_tok: <git>
                  more_env: []
                  words: [{<git>} {<show-index>}]
                  redirects: [
                    (Redir
                      op: <Id.Redir_Less '<'>
                      loc: (redir_loc.Fd fd:0)
                      arg: {($ Id.VSub_DollarName idx_file)}
                    )
                  ]
                  do_fork: T
                )
                (command.Simple
                  blame_tok: <grep>
                  more_env: []
                  words: [{<grep>} {($ Id.VSub_DollarName object_sha1)}]
                  redirects: []
                  do_fork: T
                )
                (command.Subshell
                  left: <Id.Op_LParen _>
                  child: 
                    (command.AndOr
                      children: [
                        (command.Simple
                          blame_tok: <read>
                          more_env: []
                          words: [{<read>} {<offs>} {<extra>}]
                          redirects: []
                          do_fork: T
                        )
                        (command.Simple
                          blame_tok: <echo>
                          more_env: []
                          words: [{<echo>} {(DQ ($ Id.VSub_DollarName offs))}]
                          redirects: []
                          do_fork: T
                        )
                      ]
                      ops: [<Id.Op_DAmp _>]
                    )
                  right: <Id.Right_Subshell _>
                  redirects: []
                )
              ]
              ops: [<Id.Op_Pipe _> <Id.Op_Pipe _>]
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'[index v1] 1) stream pack to repository'>)}
        {
          (SQ <'git index-pack --index-version=1 --stdin < "test-1-${pack1}.pack" &&\n'> 
            <'     git prune-packed &&\n'> <'     git count-objects | ( read nr rest && test "$nr" -eq 1 ) &&\n'> 
            <'     cmp "test-1-${pack1}.pack" ".git/objects/pack/pack-${pack1}.pack" &&\n'> <'     cmp "test-1-${pack1}.idx"  ".git/objects/pack/pack-${pack1}.idx"'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'[index v1] 2) create a stealth corruption in a delta base reference'>)}
        {
          (SQ <'# This test assumes file_101 is a delta smaller than 16 bytes.\n'> 
            <'     # It should be against file_100 but we substitute its base for file_099\n'> <'     sha1_101=$(git hash-object file_101) &&\n'> <'     sha1_099=$(git hash-object file_099) &&\n'> 
            <'     offs_101=$(index_obj_offset 1.idx $sha1_101) &&\n'> <'     nr_099=$(index_obj_nr 1.idx $sha1_099) &&\n'> 
            <'     chmod +w ".git/objects/pack/pack-${pack1}.pack" &&\n'> <'     dd of=".git/objects/pack/pack-${pack1}.pack" seek=$(($offs_101 + 1)) \\\n'> 
            <'        if=".git/objects/pack/pack-${pack1}.idx" \\\n'> <'        skip=$((4 + 256 * 4 + $nr_099 * 24)) \\\n'> <'        bs=1 count=20 conv=notrunc &&\n'> 
            <'     git cat-file blob $sha1_101 > file_101_foo1'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'[index v1] 3) corrupted delta happily returned wrong data'>)}
        {(SQ <'test -f file_101_foo1 && ! cmp file_101 file_101_foo1'>)}
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'[index v1] 4) confirm that the pack is actually corrupted'>)}
        {(SQ <'test_must_fail git fsck --full $commit'>)}
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'[index v1] 5) pack-objects happily reuses corrupted data'>)}
        {
          (SQ <'pack4=$(git pack-objects test-4 <obj-list) &&\n'> 
            <'     test -f "test-4-${pack4}.pack"'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'[index v1] 6) newly created pack is BAD !'>)}
        {(SQ <'test_must_fail git verify-pack -v "test-4-${pack4}.pack"'>)}
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'[index v2] 1) stream pack to repository'>)}
        {
          (SQ <'rm -f .git/objects/pack/* &&\n'> 
            <'     git index-pack --index-version=2 --stdin < "test-1-${pack1}.pack" &&\n'> <'     git prune-packed &&\n'> <'     git count-objects | ( read nr rest && test "$nr" -eq 1 ) &&\n'> 
            <'     cmp "test-1-${pack1}.pack" ".git/objects/pack/pack-${pack1}.pack" &&\n'> <'     cmp "test-2-${pack1}.idx"  ".git/objects/pack/pack-${pack1}.idx"'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'[index v2] 2) create a stealth corruption in a delta base reference'>)}
        {
          (SQ <'# This test assumes file_101 is a delta smaller than 16 bytes.\n'> 
            <'     # It should be against file_100 but we substitute its base for file_099\n'> <'     sha1_101=$(git hash-object file_101) &&\n'> <'     sha1_099=$(git hash-object file_099) &&\n'> 
            <'     offs_101=$(index_obj_offset 1.idx $sha1_101) &&\n'> <'     nr_099=$(index_obj_nr 1.idx $sha1_099) &&\n'> 
            <'     chmod +w ".git/objects/pack/pack-${pack1}.pack" &&\n'> <'     dd of=".git/objects/pack/pack-${pack1}.pack" seek=$(($offs_101 + 1)) \\\n'> 
            <'        if=".git/objects/pack/pack-${pack1}.idx" \\\n'> <'        skip=$((8 + 256 * 4 + $nr_099 * 20)) \\\n'> <'        bs=1 count=20 conv=notrunc &&\n'> 
            <'     git cat-file blob $sha1_101 > file_101_foo2'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'[index v2] 3) corrupted delta happily returned wrong data'>)}
        {(SQ <'test -f file_101_foo2 && ! cmp file_101 file_101_foo2'>)}
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'[index v2] 4) confirm that the pack is actually corrupted'>)}
        {(SQ <'test_must_fail git fsck --full $commit'>)}
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'[index v2] 5) pack-objects refuses to reuse corrupted data'>)}
        {
          (SQ <'test_must_fail git pack-objects test-5 <obj-list &&\n'> 
            <'     test_must_fail git pack-objects --no-reuse-object test-6 <obj-list'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'[index v2] 6) verify-pack detects CRC mismatch'>)}
        {
          (SQ <'rm -f .git/objects/pack/* &&\n'> 
            <'     git index-pack --index-version=2 --stdin < "test-1-${pack1}.pack" &&\n'> <'     git verify-pack ".git/objects/pack/pack-${pack1}.pack" &&\n'> 
            <'     obj=$(git hash-object file_001) &&\n'> <'     nr=$(index_obj_nr ".git/objects/pack/pack-${pack1}.idx" $obj) &&\n'> 
            <'     chmod +w ".git/objects/pack/pack-${pack1}.idx" &&\n'> <'     printf xxxx | dd of=".git/objects/pack/pack-${pack1}.idx" conv=notrunc \\\n'> 
            <'        bs=1 count=4 seek=$((8 + 256 * 4 + $(wc -l <obj-list) * 20 + $nr * 4)) &&\n'> <'     ( while read obj\n'> <'       do git cat-file -p $obj >/dev/null || exit 1\n'> 
            <'       done <obj-list ) &&\n'> <'     test_must_fail git verify-pack ".git/objects/pack/pack-${pack1}.pack"\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'running index-pack in the object store'>)}
        {
          (SQ <'\n'> <'    rm -f .git/objects/pack/* &&\n'> 
            <'    cp test-1-${pack1}.pack .git/objects/pack/pack-${pack1}.pack &&\n'> <'    (\n'> <'\tcd .git/objects/pack\n'> <'\tgit index-pack pack-${pack1}.pack\n'> <'    ) &&\n'> 
            <'    test -f .git/objects/pack/pack-${pack1}.idx\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'index-pack --strict warns upon missing tagger in tag'>)}
        {
          (SQ <'\n'> <'    sha=$(git rev-parse HEAD) &&\n'> <'    cat >wrong-tag <<EOF &&\n'> 
            <'object $sha\n'> <'type commit\n'> <'tag guten tag\n'> <'\n'> <'This is an invalid tag.\n'> <'EOF\n'> <'\n'> 
            <'    tag=$(git hash-object -t tag -w --stdin <wrong-tag) &&\n'> <'    pack1=$(echo $tag $sha | git pack-objects tag-test) &&\n'> <'    echo remove tag object &&\n'> 
            <'    thirtyeight=${tag#??} &&\n'> <'    rm -f .git/objects/${tag%$thirtyeight}/$thirtyeight &&\n'> 
            <'    git index-pack --strict tag-test-${pack1}.pack 2>err &&\n'> <'    grep "^warning:.* expected .tagger. line" err\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_done>
      more_env: []
      words: [{<test_done>}]
      redirects: []
      do_fork: T
    )
  ]
)