(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: 
            {
              (DQ <'Test whether cache-tree is properly updated\n'> <'\n'> 
                <'Tests whether various commands properly update and/or rewrite the\n'> <'cache-tree extension.\n'>
              )
            }
        )
      ]
      redirects: []
    )
    (command.Simple
      blame_tok: <.>
      more_env: []
      words: [{<.>} {<'./test-lib.sh'>}]
      redirects: []
      do_fork: T
    )
    (command.ShFunction
      name_tok: <cmp_cache_tree>
      name: cmp_cache_tree
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.AndOr
              children: [
                (command.Pipeline
                  children: [
                    (command.Simple
                      blame_tok: <test-dump-cache-tree>
                      more_env: []
                      words: [{<test-dump-cache-tree>}]
                      redirects: []
                      do_fork: T
                    )
                    (command.Simple
                      blame_tok: <sed>
                      more_env: []
                      words: [{<sed>} {<-e>} {(SQ <'/#(ref)/d'>)}]
                      redirects: [
                        (Redir
                          op: <Id.Redir_Great '>'>
                          loc: (redir_loc.Fd fd:1)
                          arg: {<actual>}
                        )
                      ]
                      do_fork: T
                    )
                  ]
                  ops: [<Id.Op_Pipe _>]
                )
                (command.Simple
                  blame_tok: <sed>
                  more_env: []
                  words: [{<sed>} {(DQ <'s/'> ($ Id.VSub_DollarName _x40) <'/SHA/'>)}]
                  redirects: [
                    (Redir
                      op: <Id.Redir_Less '<'>
                      loc: (redir_loc.Fd fd:0)
                      arg: {<actual>}
                    )
                    (Redir
                      op: <Id.Redir_Great '>'>
                      loc: (redir_loc.Fd fd:1)
                      arg: {<filtered>}
                    )
                  ]
                  do_fork: T
                )
                (command.Simple
                  blame_tok: <test_cmp>
                  more_env: []
                  words: [{<test_cmp>} {(DQ ($ Id.VSub_Number 1))} {<filtered>}]
                  redirects: []
                  do_fork: T
                )
              ]
              ops: [<Id.Op_DAmp _> <Id.Op_DAmp _>]
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name_tok: <generate_expected_cache_tree_rec>
      name: generate_expected_cache_tree_rec
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.AndOr
              children: [
                (command.ShAssignment
                  left: <Id.Lit_VarLike 'dir='>
                  pairs: [
                    (AssignPair
                      left: <Id.Lit_VarLike 'dir='>
                      lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'dir='> name:dir)
                      op: assign_op.Equal
                      rhs: 
                        {
                          (DQ ($ Id.VSub_Number 1) 
                            (BracedVarSub
                              left: <Id.Left_DollarBrace '${'>
                              token: <Id.VSub_Number 1>
                              var_name: 1
                              suffix_op: 
                                (suffix_op.Unary
                                  op: <Id.VTest_ColonPlus _>
                                  arg_word: {<Id.Lit_Slash '/'>}
                                )
                              right: <Id.Right_DollarBrace '}'>
                            )
                          )
                        }
                    )
                  ]
                  redirects: []
                )
                (command.ShAssignment
                  left: <Id.Lit_VarLike 'parent='>
                  pairs: [
                    (AssignPair
                      left: <Id.Lit_VarLike 'parent='>
                      lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'parent='> name:parent)
                      op: assign_op.Equal
                      rhs: {(DQ ($ Id.VSub_Number 2))}
                    )
                  ]
                  redirects: []
                )
                (command.ShAssignment
                  left: <Id.Lit_VarLike 'subtrees='>
                  pairs: [
                    (AssignPair
                      left: <Id.Lit_VarLike 'subtrees='>
                      lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'subtrees='> name:subtrees)
                      op: assign_op.Equal
                      rhs: 
                        {
                          (CommandSub
                            left_token: <Id.Left_DollarParen '$('>
                            child: 
                              (command.Pipeline
                                children: [
                                  (command.Simple
                                    blame_tok: <git>
                                    more_env: []
                                    words: [{<git>} {<ls-files>}]
                                    redirects: []
                                    do_fork: T
                                  )
                                  (command.Simple
                                    blame_tok: <grep>
                                    more_env: []
                                    words: [{<grep>} {<'/'>}]
                                    redirects: []
                                    do_fork: T
                                  )
                                  (command.Simple
                                    blame_tok: <cut>
                                    more_env: []
                                    words: [{<cut>} {<-d>} {<'/'>} {<-f>} {<1>}]
                                    redirects: []
                                    do_fork: T
                                  )
                                  (command.Simple
                                    blame_tok: <uniq>
                                    more_env: []
                                    words: [{<uniq>}]
                                    redirects: []
                                    do_fork: T
                                  )
                                ]
                                ops: [<Id.Op_Pipe _> <Id.Op_Pipe _> <Id.Op_Pipe _>]
                              )
                            right: <Id.Eof_RParen _>
                          )
                        }
                    )
                  ]
                  redirects: []
                )
                (command.ShAssignment
                  left: <Id.Lit_VarLike 'subtree_count='>
                  pairs: [
                    (AssignPair
                      left: <Id.Lit_VarLike 'subtree_count='>
                      lhs: 
                        (sh_lhs_expr.Name
                          left: <Id.Lit_VarLike 'subtree_count='>
                          name: subtree_count
                        )
                      op: assign_op.Equal
                      rhs: 
                        {
                          (CommandSub
                            left_token: <Id.Left_DollarParen '$('>
                            child: 
                              (command.Pipeline
                                children: [
                                  (command.Simple
                                    blame_tok: <echo>
                                    more_env: []
                                    words: [{<echo>} {(DQ ($ Id.VSub_DollarName subtrees))}]
                                    redirects: []
                                    do_fork: T
                                  )
                                  (command.Simple
                                    blame_tok: <awk>
                                    more_env: []
                                    words: [
                                      {<awk>}
                                      {<-v>}
                                      {<Id.Lit_VarLike 'c='> <0>}
                                      {(SQ <'$1 != "" {++c} END {print c}'>)}
                                    ]
                                    redirects: []
                                    do_fork: T
                                  )
                                ]
                                ops: [<Id.Op_Pipe _>]
                              )
                            right: <Id.Eof_RParen _>
                          )
                        }
                    )
                  ]
                  redirects: []
                )
                (command.ShAssignment
                  left: <Id.Lit_VarLike 'entries='>
                  pairs: [
                    (AssignPair
                      left: <Id.Lit_VarLike 'entries='>
                      lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'entries='> name:entries)
                      op: assign_op.Equal
                      rhs: 
                        {
                          (CommandSub
                            left_token: <Id.Left_DollarParen '$('>
                            child: 
                              (command.Pipeline
                                children: [
                                  (command.Simple
                                    blame_tok: <git>
                                    more_env: []
                                    words: [{<git>} {<ls-files>}]
                                    redirects: []
                                    do_fork: T
                                  )
                                  (command.Simple
                                    blame_tok: <wc>
                                    more_env: []
                                    words: [{<wc>} {<-l>}]
                                    redirects: []
                                    do_fork: T
                                  )
                                ]
                                ops: [<Id.Op_Pipe _>]
                              )
                            right: <Id.Eof_RParen _>
                          )
                        }
                    )
                  ]
                  redirects: []
                )
                (command.Simple
                  blame_tok: <printf>
                  more_env: []
                  words: [
                    {<printf>}
                    {
                      (DQ <'SHA '> ($ Id.VSub_DollarName dir) <' (%d entries, %d subtrees)'> 
                        <Id.Lit_BadBackslash '\\'> <n>
                      )
                    }
                    {(DQ ($ Id.VSub_DollarName entries))}
                    {(DQ ($ Id.VSub_DollarName subtree_count))}
                  ]
                  redirects: []
                  do_fork: T
                )
                (command.ForEach
                  keyword: <Id.KW_For for>
                  iter_names: [subtree]
                  iterable: (for_iter.Words words:[{($ Id.VSub_DollarName subtrees)}])
                  body: 
                    (command.DoGroup
                      left: <Id.KW_Do do>
                      children: [
                        (command.Simple
                          blame_tok: <cd>
                          more_env: []
                          words: [{<cd>} {(DQ ($ Id.VSub_DollarName subtree))}]
                          redirects: []
                          do_fork: T
                        )
                        (command.AndOr
                          children: [
                            (command.Simple
                              blame_tok: <generate_expected_cache_tree_rec>
                              more_env: []
                              words: [
                                {<generate_expected_cache_tree_rec>}
                                {(DQ ($ Id.VSub_DollarName dir) ($ Id.VSub_DollarName subtree))}
                                {(DQ ($ Id.VSub_DollarName dir))}
                              ]
                              redirects: []
                              do_fork: T
                            )
                            (command.ControlFlow
                              keyword: <Id.ControlFlow_Return return>
                              arg_word: {<1>}
                            )
                          ]
                          ops: [<Id.Op_DPipe _>]
                        )
                        (command.Simple
                          blame_tok: <cd>
                          more_env: []
                          words: [{<cd>} {<..>}]
                          redirects: []
                          do_fork: T
                        )
                      ]
                      right: <Id.KW_Done done>
                    )
                  redirects: []
                )
                (command.ShAssignment
                  left: <Id.Lit_VarLike 'dir='>
                  pairs: [
                    (AssignPair
                      left: <Id.Lit_VarLike 'dir='>
                      lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'dir='> name:dir)
                      op: assign_op.Equal
                      rhs: {($ Id.VSub_DollarName parent)}
                    )
                  ]
                  redirects: []
                )
              ]
              ops: [
                <Id.Op_DAmp _>
                <Id.Op_DAmp _>
                <Id.Op_DAmp _>
                <Id.Op_DAmp _>
                <Id.Op_DAmp _>
                <Id.Op_DAmp _>
                <Id.Op_DAmp _>
              ]
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name_tok: <generate_expected_cache_tree>
      name: generate_expected_cache_tree
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.Subshell
              left: <Id.Op_LParen _>
              child: 
                (command.Simple
                  blame_tok: <generate_expected_cache_tree_rec>
                  more_env: []
                  words: [{<generate_expected_cache_tree_rec>}]
                  redirects: []
                  do_fork: T
                )
              right: <Id.Right_Subshell _>
              redirects: []
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name_tok: <test_cache_tree>
      name: test_cache_tree
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.AndOr
              children: [
                (command.Simple
                  blame_tok: <generate_expected_cache_tree>
                  more_env: []
                  words: [{<generate_expected_cache_tree>}]
                  redirects: [(Redir op:<Id.Redir_Great '>'> loc:(redir_loc.Fd fd:1) arg:{<expect>})]
                  do_fork: T
                )
                (command.Simple
                  blame_tok: <cmp_cache_tree>
                  more_env: []
                  words: [{<cmp_cache_tree>} {<expect>}]
                  redirects: []
                  do_fork: T
                )
              ]
              ops: [<Id.Op_DAmp _>]
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name_tok: <test_invalid_cache_tree>
      name: test_invalid_cache_tree
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.AndOr
              children: [
                (command.Simple
                  blame_tok: <printf>
                  more_env: []
                  words: [
                    {<printf>}
                    {
                      (DQ <'invalid                                  %s ()'> 
                        <Id.Lit_BadBackslash '\\'> <n>
                      )
                    }
                    {(DQ )}
                    {(DQ ($ Id.VSub_At '@'))}
                  ]
                  redirects: [(Redir op:<Id.Redir_Great '>'> loc:(redir_loc.Fd fd:1) arg:{<expect>})]
                  do_fork: T
                )
                (command.Pipeline
                  children: [
                    (command.Simple
                      blame_tok: <test-dump-cache-tree>
                      more_env: []
                      words: [{<test-dump-cache-tree>}]
                      redirects: []
                      do_fork: T
                    )
                    (command.Simple
                      blame_tok: <sed>
                      more_env: []
                      words: [
                        {<sed>}
                        {<-n>}
                        {<-e>}
                        {(DQ <'s/[0-9]* subtrees//'>)}
                        {<-e>}
                        {(SQ <'/#(ref)/d'>)}
                        {<-e>}
                        {(SQ <'/^invalid /p'>)}
                      ]
                      redirects: [
                        (Redir
                          op: <Id.Redir_Great '>'>
                          loc: (redir_loc.Fd fd:1)
                          arg: {<actual>}
                        )
                      ]
                      do_fork: T
                    )
                  ]
                  ops: [<Id.Op_Pipe _>]
                )
                (command.Simple
                  blame_tok: <test_cmp>
                  more_env: []
                  words: [{<test_cmp>} {<expect>} {<actual>}]
                  redirects: []
                  do_fork: T
                )
              ]
              ops: [<Id.Op_DAmp _> <Id.Op_DAmp _>]
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name_tok: <test_no_cache_tree>
      name: test_no_cache_tree
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.AndOr
              children: [
                (command.Simple
                  blame_tok: <Id.Lit_Colon ':'>
                  more_env: []
                  words: [{<Id.Lit_Colon ':'>}]
                  redirects: [(Redir op:<Id.Redir_Great '>'> loc:(redir_loc.Fd fd:1) arg:{<expect>})]
                  do_fork: T
                )
                (command.Simple
                  blame_tok: <cmp_cache_tree>
                  more_env: []
                  words: [{<cmp_cache_tree>} {<expect>}]
                  redirects: []
                  do_fork: T
                )
              ]
              ops: [<Id.Op_DAmp _>]
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'initial commit has cache-tree'>)}
        {(SQ <'\n'> <'\ttest_commit foo &&\n'> <'\ttest_cache_tree\n'>)}
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'read-tree HEAD establishes cache-tree'>)}
        {(SQ <'\n'> <'\tgit read-tree HEAD &&\n'> <'\ttest_cache_tree\n'>)}
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'git-add invalidates cache-tree'>)}
        {
          (SQ <'\n'> <'\ttest_when_finished "git reset --hard; git read-tree HEAD" &&\n'> 
            <'\techo "I changed this file" >foo &&\n'> <'\tgit add foo &&\n'> <'\ttest_invalid_cache_tree\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'git-add in subdir invalidates cache-tree'>)}
        {
          (SQ <'\n'> <'\ttest_when_finished "git reset --hard; git read-tree HEAD" &&\n'> 
            <'\tmkdir dirx &&\n'> <'\techo "I changed this file" >dirx/foo &&\n'> <'\tgit add dirx/foo &&\n'> 
            <'\ttest_invalid_cache_tree\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <cat>
      more_env: []
      words: [{<cat>}]
      redirects: [
        (Redir op:<Id.Redir_Great '>'> loc:(redir_loc.Fd fd:1) arg:{<before>})
        (Redir
          op: <Id.Redir_DLess '<<'>
          loc: (redir_loc.Fd fd:0)
          arg: 
            (redir_param.HereDoc
              here_begin: {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\E'> ch:E) <OF>}
              here_end_tok: <Id.Undefined_Tok ''>
              stdin_parts: [
                <'SHA  (3 entries, 2 subtrees)\n'>
                <'SHA dir1/ (1 entries, 0 subtrees)\n'>
                <'SHA dir2/ (1 entries, 0 subtrees)\n'>
              ]
            )
        )
      ]
      do_fork: T
    )
    (command.Simple
      blame_tok: <cat>
      more_env: []
      words: [{<cat>}]
      redirects: [
        (Redir op:<Id.Redir_Great '>'> loc:(redir_loc.Fd fd:1) arg:{<expect>})
        (Redir
          op: <Id.Redir_DLess '<<'>
          loc: (redir_loc.Fd fd:0)
          arg: 
            (redir_param.HereDoc
              here_begin: {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\E'> ch:E) <OF>}
              here_end_tok: <Id.Undefined_Tok ''>
              stdin_parts: [
                <'invalid                                   (2 subtrees)\n'>
                <'invalid                                  dir1/ (0 subtrees)\n'>
                <'SHA dir2/ (1 entries, 0 subtrees)\n'>
              ]
            )
        )
      ]
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'git-add in subdir does not invalidate sibling cache-tree'>)}
        {
          (SQ <'\n'> <'\tgit tag no-children &&\n'> 
            <'\ttest_when_finished "git reset --hard no-children; git read-tree HEAD" &&\n'> <'\tmkdir dir1 dir2 &&\n'> <'\ttest_commit dir1/a &&\n'> <'\ttest_commit dir2/b &&\n'> 
            <'\techo "I changed this file" >dir1/a &&\n'> <'\tcmp_cache_tree before &&\n'> <'\techo "I changed this file" >dir1/a &&\n'> 
            <'\tgit add dir1/a &&\n'> <'\tcmp_cache_tree expect\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'update-index invalidates cache-tree'>)}
        {
          (SQ <'\n'> <'\ttest_when_finished "git reset --hard; git read-tree HEAD" &&\n'> 
            <'\techo "I changed this file" >foo &&\n'> <'\tgit update-index --add foo &&\n'> <'\ttest_invalid_cache_tree\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'write-tree establishes cache-tree'>)}
        {
          (SQ <'\n'> <'\ttest-scrap-cache-tree &&\n'> <'\tgit write-tree &&\n'> <'\ttest_cache_tree\n'>)
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'test-scrap-cache-tree works'>)}
        {
          (SQ <'\n'> <'\tgit read-tree HEAD &&\n'> <'\ttest-scrap-cache-tree &&\n'> 
            <'\ttest_no_cache_tree\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'second commit has cache-tree'>)}
        {(SQ <'\n'> <'\ttest_commit bar &&\n'> <'\ttest_cache_tree\n'>)}
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {<PERL>}
        {(SQ <'commit --interactive gives cache-tree on partial commit'>)}
        {
          (SQ <'\n'> <'\tcat <<-\\EOT >foo.c &&\n'> <'\tint foo()\n'> <'\t{\n'> <'\t\treturn 42;\n'> 
            <'\t}\n'> <'\tint bar()\n'> <'\t{\n'> <'\t\treturn 42;\n'> <'\t}\n'> <'\tEOT\n'> <'\tgit add foo.c &&\n'> 
            <'\ttest_invalid_cache_tree &&\n'> <'\tgit commit -m "add a file" &&\n'> <'\ttest_cache_tree &&\n'> <'\tcat <<-\\EOT >foo.c &&\n'> 
            <'\tint foo()\n'> <'\t{\n'> <'\t\treturn 43;\n'> <'\t}\n'> <'\tint bar()\n'> <'\t{\n'> <'\t\treturn 44;\n'> <'\t}\n'> 
            <'\tEOT\n'> <'\t(echo p; echo 1; echo; echo s; echo n; echo y; echo q) |\n'> 
            <'\tgit commit --interactive -m foo &&\n'> <'\ttest_cache_tree\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'commit in child dir has cache-tree'>)}
        {
          (SQ <'\n'> <'\tmkdir dir &&\n'> <'\t>dir/child.t &&\n'> <'\tgit add dir/child.t &&\n'> 
            <'\tgit commit -m dir/child.t &&\n'> <'\ttest_cache_tree\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'reset --hard gives cache-tree'>)}
        {
          (SQ <'\n'> <'\ttest-scrap-cache-tree &&\n'> <'\tgit reset --hard &&\n'> 
            <'\ttest_cache_tree\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'reset --hard without index gives cache-tree'>)}
        {(SQ <'\n'> <'\trm -f .git/index &&\n'> <'\tgit reset --hard &&\n'> <'\ttest_cache_tree\n'>)}
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'checkout gives cache-tree'>)}
        {(SQ <'\n'> <'\tgit tag current &&\n'> <'\tgit checkout HEAD^ &&\n'> <'\ttest_cache_tree\n'>)}
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'checkout -b gives cache-tree'>)}
        {
          (SQ <'\n'> <'\tgit checkout current &&\n'> <'\tgit checkout -b prev HEAD^ &&\n'> 
            <'\ttest_cache_tree\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'checkout -B gives cache-tree'>)}
        {
          (SQ <'\n'> <'\tgit checkout current &&\n'> <'\tgit checkout -B prev HEAD^ &&\n'> 
            <'\ttest_cache_tree\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'merge --ff-only maintains cache-tree'>)}
        {
          (SQ <'\n'> <'\tgit checkout current &&\n'> <'\tgit checkout -b changes &&\n'> 
            <'\ttest_commit llamas &&\n'> <'\ttest_commit pachyderm &&\n'> <'\ttest_cache_tree &&\n'> <'\tgit checkout current &&\n'> 
            <'\ttest_cache_tree &&\n'> <'\tgit merge --ff-only changes &&\n'> <'\ttest_cache_tree\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'merge maintains cache-tree'>)}
        {
          (SQ <'\n'> <'\tgit checkout current &&\n'> <'\tgit checkout -b changes2 &&\n'> 
            <'\ttest_commit alpacas &&\n'> <'\ttest_cache_tree &&\n'> <'\tgit checkout current &&\n'> <'\ttest_commit struthio &&\n'> 
            <'\ttest_cache_tree &&\n'> <'\tgit merge changes2 &&\n'> <'\ttest_cache_tree\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'partial commit gives cache-tree'>)}
        {
          (SQ <'\n'> <'\tgit checkout -b partial no-children &&\n'> <'\ttest_commit one &&\n'> 
            <'\ttest_commit two &&\n'> <'\techo "some change" >one.t &&\n'> <'\tgit add one.t &&\n'> 
            <'\techo "some other change" >two.t &&\n'> <'\tgit commit two.t -m partial &&\n'> <'\ttest_cache_tree\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'no phantom error when switching trees'>)}
        {
          (SQ <'\n'> <'\tmkdir newdir &&\n'> <'\t>newdir/one &&\n'> <'\tgit add newdir/one &&\n'> 
            <'\tgit checkout 2>errors &&\n'> <'\t! test -s errors\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'switching trees does not invalidate shared index'>)}
        {
          (SQ <'\n'> <'\tgit update-index --split-index &&\n'> <'\t>split &&\n'> 
            <'\tgit add split &&\n'> <'\ttest-dump-split-index .git/index | grep -v ^own >before &&\n'> <'\tgit commit -m "as-is" &&\n'> 
            <'\ttest-dump-split-index .git/index | grep -v ^own >after &&\n'> <'\ttest_cmp before after\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_done>
      more_env: []
      words: [{<test_done>}]
      redirects: []
      do_fork: T
    )
  ]
)