(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 <'test bash completion'>)}
        )
      ]
      redirects: []
    )
    (command.Simple
      blame_tok: <.>
      more_env: []
      words: [{<.>} {<'./lib-bash.sh'>}]
      redirects: []
      do_fork: T
    )
    (command.ShFunction
      name_tok: <complete>
      name: complete
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [(command.ControlFlow keyword:<Id.ControlFlow_Return return> arg_word:{<0>})]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShAssignment
      left: <Id.Lit_VarLike 'GIT_TESTING_COMMAND_COMPLETION='>
      pairs: [
        (AssignPair
          left: <Id.Lit_VarLike 'GIT_TESTING_COMMAND_COMPLETION='>
          lhs: 
            (sh_lhs_expr.Name
              left: <Id.Lit_VarLike 'GIT_TESTING_COMMAND_COMPLETION='>
              name: GIT_TESTING_COMMAND_COMPLETION
            )
          op: assign_op.Equal
          rhs: {(SQ <'add checkout check-attr filter-branch ls-files'>)}
        )
      ]
      redirects: []
    )
    (command.Simple
      blame_tok: <.>
      more_env: []
      words: [
        {<.>}
        {(DQ ($ Id.VSub_DollarName GIT_BUILD_DIR) <'/contrib/completion/git-completion.bash'>)}
      ]
      redirects: []
      do_fork: T
    )
    (command.ShFunction
      name_tok: <_get_comp_words_by_ref>
      name: _get_comp_words_by_ref
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.WhileUntil
              keyword: <Id.KW_While while>
              cond: 
                (condition.Shell
                  commands: [
                    (command.Sentence
                      child: 
                        (command.Simple
                          blame_tok: <Id.Lit_LBracket '['>
                          more_env: []
                          words: [
                            {<Id.Lit_LBracket '['>}
                            {($ Id.VSub_Pound '#')}
                            {<-gt>}
                            {<0>}
                            {<Id.Lit_RBracket ']'>}
                          ]
                          redirects: []
                          do_fork: T
                        )
                      terminator: <Id.Op_Semi _>
                    )
                  ]
                )
              body: 
                (command.DoGroup
                  left: <Id.KW_Do do>
                  children: [
                    (command.Case
                      case_kw: <Id.KW_Case case>
                      to_match: (case_arg.Word w:{(DQ ($ Id.VSub_Number 1))})
                      arms_start: <Id.KW_In in>
                      arms: [
                        (CaseArm
                          left: <cur>
                          pattern: (pat.Words words:[{<cur>}])
                          middle: <Id.Right_CasePat _>
                          action: [
                            (command.ShAssignment
                              left: <Id.Lit_VarLike 'cur='>
                              pairs: [
                                (AssignPair
                                  left: <Id.Lit_VarLike 'cur='>
                                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'cur='> name:cur)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (BracedVarSub
                                        left: <Id.Left_DollarBrace '${'>
                                        token: <Id.VSub_Name _words>
                                        var_name: _words
                                        bracket_op: 
                                          (bracket_op.ArrayIndex
                                            expr: ($ Id.Lit_ArithVarLike _cword)
                                          )
                                        right: <Id.Right_DollarBrace '}'>
                                      )
                                    }
                                )
                              ]
                              redirects: []
                            )
                          ]
                          right: <Id.Op_DSemi _>
                        )
                        (CaseArm
                          left: <prev>
                          pattern: (pat.Words words:[{<prev>}])
                          middle: <Id.Right_CasePat _>
                          action: [
                            (command.ShAssignment
                              left: <Id.Lit_VarLike 'prev='>
                              pairs: [
                                (AssignPair
                                  left: <Id.Lit_VarLike 'prev='>
                                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'prev='> name:prev)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (BracedVarSub
                                        left: <Id.Left_DollarBrace '${'>
                                        token: <Id.VSub_Name _words>
                                        var_name: _words
                                        bracket_op: 
                                          (bracket_op.ArrayIndex
                                            expr: 
                                              (arith_expr.Binary
                                                op_id: Id.Arith_Minus
                                                left: ($ Id.Lit_ArithVarLike _cword)
                                                right: {<Id.Lit_Digits 1>}
                                              )
                                          )
                                        right: <Id.Right_DollarBrace '}'>
                                      )
                                    }
                                )
                              ]
                              redirects: []
                            )
                          ]
                          right: <Id.Op_DSemi _>
                        )
                        (CaseArm
                          left: <words>
                          pattern: (pat.Words words:[{<words>}])
                          middle: <Id.Right_CasePat _>
                          action: [
                            (command.ShAssignment
                              left: <Id.Lit_VarLike 'words='>
                              pairs: [
                                (AssignPair
                                  left: <Id.Lit_VarLike 'words='>
                                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'words='> name:words)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (ShArrayLiteral
                                        left: <Id.Op_LParen _>
                                        words: [
                                          {
                                            (DQ 
                                              (BracedVarSub
                                                left: <Id.Left_DollarBrace '${'>
                                                token: <Id.VSub_Name _words>
                                                var_name: _words
                                                bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                                                right: <Id.Right_DollarBrace '}'>
                                              )
                                            )
                                          }
                                        ]
                                        right: <Id.Right_ShArrayLiteral _>
                                      )
                                    }
                                )
                              ]
                              redirects: []
                            )
                          ]
                          right: <Id.Op_DSemi _>
                        )
                        (CaseArm
                          left: <cword>
                          pattern: (pat.Words words:[{<cword>}])
                          middle: <Id.Right_CasePat _>
                          action: [
                            (command.ShAssignment
                              left: <Id.Lit_VarLike 'cword='>
                              pairs: [
                                (AssignPair
                                  left: <Id.Lit_VarLike 'cword='>
                                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'cword='> name:cword)
                                  op: assign_op.Equal
                                  rhs: {($ Id.VSub_DollarName _cword)}
                                )
                              ]
                              redirects: []
                            )
                          ]
                          right: <Id.Op_DSemi _>
                        )
                      ]
                      arms_end: <Id.KW_Esac esac>
                      redirects: []
                    )
                    (command.Simple
                      blame_tok: <shift>
                      more_env: []
                      words: [{<shift>}]
                      redirects: []
                      do_fork: T
                    )
                  ]
                  right: <Id.KW_Done done>
                )
              redirects: []
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name_tok: <print_comp>
      name: print_comp
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.Simple
              blame_tok: <local>
              more_env: []
              words: [
                {<local>}
                {<Id.Lit_VarLike 'IFS='> 
                  (SingleQuoted
                    left: <Id.Left_DollarSingleQuote '$\''>
                    tokens: [<Id.Char_OneChar '\\n'>]
                    right: <Id.Right_SingleQuote '\''>
                  )
                }
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <echo>
              more_env: []
              words: [
                {<echo>}
                {
                  (DQ 
                    (BracedVarSub
                      left: <Id.Left_DollarBrace '${'>
                      token: <Id.VSub_Name COMPREPLY>
                      var_name: COMPREPLY
                      bracket_op: (bracket_op.WholeArray op_id:Id.Arith_Star)
                      right: <Id.Right_DollarBrace '}'>
                    )
                  )
                }
              ]
              redirects: [(Redir op:<Id.Redir_Great '>'> loc:(redir_loc.Fd fd:1) arg:{<out>})]
              do_fork: T
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name_tok: <run_completion>
      name: run_completion
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.Simple
              blame_tok: <local>
              more_env: []
              words: [{<local>} {<-a>} {<COMPREPLY>} {<_words>}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <local>
              more_env: []
              words: [{<local>} {<_cword>}]
              redirects: []
              do_fork: T
            )
            (command.ShAssignment
              left: <Id.Lit_VarLike '_words='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike '_words='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike '_words='> name:_words)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (ShArrayLiteral
                        left: <Id.Op_LParen _>
                        words: [{($ Id.VSub_Number 1)}]
                        right: <Id.Right_ShArrayLiteral _>
                      )
                    }
                )
              ]
              redirects: []
            )
            (command.AndOr
              children: [
                (command.Simple
                  blame_tok: <test>
                  more_env: []
                  words: [
                    {<test>}
                    {
                      (DQ 
                        (BracedVarSub
                          left: <Id.Left_DollarBrace '${'>
                          token: <Id.VSub_Number 1>
                          var_name: 1
                          suffix_op: 
                            (suffix_op.Slice
                              begin: 
                                (arith_expr.Unary
                                  op_id: Id.Node_UnaryMinus
                                  child: {<Id.Lit_Digits 1>}
                                )
                            )
                          right: <Id.Arith_RBrace _>
                        )
                      )
                    }
                    {<Id.Lit_Equals '='>}
                    {(SQ <' '>)}
                  ]
                  redirects: []
                  do_fork: T
                )
                (command.ShAssignment
                  left: <Id.Lit_ArrayLhsOpen '_words['>
                  pairs: [
                    (AssignPair
                      left: <Id.Lit_ArrayLhsOpen '_words['>
                      lhs: 
                        (sh_lhs_expr.IndexedName
                          left: <Id.Lit_ArrayLhsOpen '_words['>
                          name: _words
                          index: 
                            (arith_expr.Binary
                              op_id: Id.Arith_Plus
                              left: 
                                {
                                  (BracedVarSub
                                    left: <Id.Left_DollarBrace '${'>
                                    token: <Id.VSub_Name _words>
                                    var_name: _words
                                    prefix_op: <Id.VSub_Pound '#'>
                                    bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                                    right: <Id.Right_DollarBrace '}'>
                                  )
                                }
                              right: {<Id.Lit_Digits 1>}
                            )
                        )
                      op: assign_op.Equal
                      rhs: {(SQ )}
                    )
                  ]
                  redirects: []
                )
              ]
              ops: [<Id.Op_DAmp _>]
            )
            (command.DParen
              left: <Id.Op_DLeftParen _>
              child: 
                (arith_expr.BinaryAssign
                  op_id: Id.Arith_Equal
                  left: ($ Id.Lit_ArithVarLike _cword)
                  right: 
                    (arith_expr.Binary
                      op_id: Id.Arith_Minus
                      left: 
                        {
                          (BracedVarSub
                            left: <Id.Left_DollarBrace '${'>
                            token: <Id.VSub_Name _words>
                            var_name: _words
                            prefix_op: <Id.VSub_Pound '#'>
                            bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                            right: <Id.Right_DollarBrace '}'>
                          )
                        }
                      right: {<Id.Lit_Digits 1>}
                    )
                )
              right: <Id.Op_DRightParen _>
              redirects: []
            )
            (command.AndOr
              children: [
                (command.Simple
                  blame_tok: <__git_wrap__git_main>
                  more_env: []
                  words: [{<__git_wrap__git_main>}]
                  redirects: []
                  do_fork: T
                )
                (command.Simple
                  blame_tok: <print_comp>
                  more_env: []
                  words: [{<print_comp>}]
                  redirects: []
                  do_fork: T
                )
              ]
              ops: [<Id.Op_DAmp _>]
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name_tok: <test_completion>
      name: test_completion
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.AndOr
              children: [
                (command.If
                  if_kw: <Id.KW_If if>
                  arms: [
                    (IfArm
                      keyword: <Id.KW_If if>
                      cond: 
                        (condition.Shell
                          commands: [
                            (command.Simple
                              blame_tok: <test>
                              more_env: []
                              words: [{<test>} {($ Id.VSub_Pound '#')} {<-gt>} {<1>}]
                              redirects: []
                              do_fork: T
                            )
                          ]
                        )
                      then_kw: <Id.KW_Then then>
                      action: [
                        (command.Simple
                          blame_tok: <printf>
                          more_env: []
                          words: [{<printf>} {(SQ <'%s\\n'>)} {(DQ ($ Id.VSub_Number 2))}]
                          redirects: [
                            (Redir
                              op: <Id.Redir_Great '>'>
                              loc: (redir_loc.Fd fd:1)
                              arg: {<expected>}
                            )
                          ]
                          do_fork: T
                        )
                      ]
                      spids: [384 395]
                    )
                  ]
                  else_kw: <Id.KW_Else else>
                  else_action: [
                    (command.Simple
                      blame_tok: <sed>
                      more_env: []
                      words: [{<sed>} {<-e>} {(SQ <'s/Z$//'>)}]
                      redirects: [
                        (Redir
                          op: <Id.Redir_Great '>'>
                          loc: (redir_loc.Fd fd:1)
                          arg: {<expected>}
                        )
                      ]
                      do_fork: T
                    )
                  ]
                  fi_kw: <Id.KW_Fi fi>
                  redirects: []
                )
                (command.Simple
                  blame_tok: <run_completion>
                  more_env: []
                  words: [{<run_completion>} {(DQ ($ Id.VSub_Number 1))}]
                  redirects: []
                  do_fork: T
                )
                (command.Simple
                  blame_tok: <test_cmp>
                  more_env: []
                  words: [{<test_cmp>} {<expected>} {<out>}]
                  redirects: []
                  do_fork: T
                )
              ]
              ops: [<Id.Op_DAmp _> <Id.Op_DAmp _>]
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name_tok: <test_gitcomp>
      name: test_gitcomp
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.AndOr
              children: [
                (command.Simple
                  blame_tok: <local>
                  more_env: []
                  words: [{<local>} {<-a>} {<COMPREPLY>}]
                  redirects: []
                  do_fork: T
                )
                (command.Simple
                  blame_tok: <sed>
                  more_env: []
                  words: [{<sed>} {<-e>} {(SQ <'s/Z$//'>)}]
                  redirects: [(Redir op:<Id.Redir_Great '>'> loc:(redir_loc.Fd fd:1) arg:{<expected>})]
                  do_fork: T
                )
                (command.ShAssignment
                  left: <Id.Lit_VarLike 'cur='>
                  pairs: [
                    (AssignPair
                      left: <Id.Lit_VarLike 'cur='>
                      lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'cur='> name:cur)
                      op: assign_op.Equal
                      rhs: {(DQ ($ Id.VSub_Number 1))}
                    )
                  ]
                  redirects: []
                )
                (command.Simple
                  blame_tok: <shift>
                  more_env: []
                  words: [{<shift>}]
                  redirects: []
                  do_fork: T
                )
                (command.Simple
                  blame_tok: <__gitcomp>
                  more_env: []
                  words: [{<__gitcomp>} {(DQ ($ Id.VSub_At '@'))}]
                  redirects: []
                  do_fork: T
                )
                (command.Simple
                  blame_tok: <print_comp>
                  more_env: []
                  words: [{<print_comp>}]
                  redirects: []
                  do_fork: T
                )
                (command.Simple
                  blame_tok: <test_cmp>
                  more_env: []
                  words: [{<test_cmp>} {<expected>} {<out>}]
                  redirects: []
                  do_fork: T
                )
              ]
              ops: [
                <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: <test_gitcomp_nl>
      name: test_gitcomp_nl
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.AndOr
              children: [
                (command.Simple
                  blame_tok: <local>
                  more_env: []
                  words: [{<local>} {<-a>} {<COMPREPLY>}]
                  redirects: []
                  do_fork: T
                )
                (command.Simple
                  blame_tok: <sed>
                  more_env: []
                  words: [{<sed>} {<-e>} {(SQ <'s/Z$//'>)}]
                  redirects: [(Redir op:<Id.Redir_Great '>'> loc:(redir_loc.Fd fd:1) arg:{<expected>})]
                  do_fork: T
                )
                (command.ShAssignment
                  left: <Id.Lit_VarLike 'cur='>
                  pairs: [
                    (AssignPair
                      left: <Id.Lit_VarLike 'cur='>
                      lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'cur='> name:cur)
                      op: assign_op.Equal
                      rhs: {(DQ ($ Id.VSub_Number 1))}
                    )
                  ]
                  redirects: []
                )
                (command.Simple
                  blame_tok: <shift>
                  more_env: []
                  words: [{<shift>}]
                  redirects: []
                  do_fork: T
                )
                (command.Simple
                  blame_tok: <__gitcomp_nl>
                  more_env: []
                  words: [{<__gitcomp_nl>} {(DQ ($ Id.VSub_At '@'))}]
                  redirects: []
                  do_fork: T
                )
                (command.Simple
                  blame_tok: <print_comp>
                  more_env: []
                  words: [{<print_comp>}]
                  redirects: []
                  do_fork: T
                )
                (command.Simple
                  blame_tok: <test_cmp>
                  more_env: []
                  words: [{<test_cmp>} {<expected>} {<out>}]
                  redirects: []
                  do_fork: T
                )
              ]
              ops: [
                <Id.Op_DAmp _>
                <Id.Op_DAmp _>
                <Id.Op_DAmp _>
                <Id.Op_DAmp _>
                <Id.Op_DAmp _>
                <Id.Op_DAmp _>
              ]
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShAssignment
      left: <Id.Lit_VarLike 'invalid_variable_name='>
      pairs: [
        (AssignPair
          left: <Id.Lit_VarLike 'invalid_variable_name='>
          lhs: 
            (sh_lhs_expr.Name
              left: <Id.Lit_VarLike 'invalid_variable_name='>
              name: invalid_variable_name
            )
          op: assign_op.Equal
          rhs: {(SQ <'${foo.bar}'>)}
        )
      ]
      redirects: []
    )
    (command.ShAssignment
      left: <Id.Lit_VarLike 'actual='>
      pairs: [
        (AssignPair
          left: <Id.Lit_VarLike 'actual='>
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'actual='> name:actual)
          op: assign_op.Equal
          rhs: {(DQ ($ Id.VSub_DollarName TRASH_DIRECTORY) <'/actual'>)}
        )
      ]
      redirects: []
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'setup for __gitdir tests'>)}
        {(SQ <'\n'> <'\tmkdir -p subdir/subsubdir &&\n'> <'\tgit init otherrepo\n'>)}
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'__gitdir - from command line (through $__git_dir)'>)}
        {
          (SQ <'\n'> <'\techo "$TRASH_DIRECTORY/otherrepo/.git" >expected &&\n'> <'\t(\n'> 
            <'\t\t__git_dir="$TRASH_DIRECTORY/otherrepo/.git" &&\n'> <'\t\t__gitdir >"$actual"\n'> <'\t) &&\n'> <'\ttest_cmp expected "$actual"\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'__gitdir - repo as argument'>)}
        {
          (SQ <'\n'> <'\techo "otherrepo/.git" >expected &&\n'> 
            <'\t__gitdir "otherrepo" >"$actual" &&\n'> <'\ttest_cmp expected "$actual"\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'__gitdir - remote as argument'>)}
        {
          (SQ <'\n'> <'\techo "remote" >expected &&\n'> <'\t__gitdir "remote" >"$actual" &&\n'> 
            <'\ttest_cmp expected "$actual"\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'__gitdir - .git directory in cwd'>)}
        {
          (SQ <'\n'> <'\techo ".git" >expected &&\n'> <'\t__gitdir >"$actual" &&\n'> 
            <'\ttest_cmp expected "$actual"\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'__gitdir - .git directory in parent'>)}
        {
          (SQ <'\n'> <'\techo "$(pwd -P)/.git" >expected &&\n'> <'\t(\n'> 
            <'\t\tcd subdir/subsubdir &&\n'> <'\t\t__gitdir >"$actual"\n'> <'\t) &&\n'> <'\ttest_cmp expected "$actual"\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'__gitdir - cwd is a .git directory'>)}
        {
          (SQ <'\n'> <'\techo "." >expected &&\n'> <'\t(\n'> <'\t\tcd .git &&\n'> 
            <'\t\t__gitdir >"$actual"\n'> <'\t) &&\n'> <'\ttest_cmp expected "$actual"\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'__gitdir - parent is a .git directory'>)}
        {
          (SQ <'\n'> <'\techo "$(pwd -P)/.git" >expected &&\n'> <'\t(\n'> 
            <'\t\tcd .git/refs/heads &&\n'> <'\t\t__gitdir >"$actual"\n'> <'\t) &&\n'> <'\ttest_cmp expected "$actual"\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'__gitdir - $GIT_DIR set while .git directory in cwd'>)}
        {
          (SQ <'\n'> <'\techo "$TRASH_DIRECTORY/otherrepo/.git" >expected &&\n'> <'\t(\n'> 
            <'\t\tGIT_DIR="$TRASH_DIRECTORY/otherrepo/.git" &&\n'> <'\t\texport GIT_DIR &&\n'> <'\t\t__gitdir >"$actual"\n'> <'\t) &&\n'> 
            <'\ttest_cmp expected "$actual"\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'__gitdir - $GIT_DIR set while .git directory in parent'>)}
        {
          (SQ <'\n'> <'\techo "$TRASH_DIRECTORY/otherrepo/.git" >expected &&\n'> <'\t(\n'> 
            <'\t\tGIT_DIR="$TRASH_DIRECTORY/otherrepo/.git" &&\n'> <'\t\texport GIT_DIR &&\n'> <'\t\tcd subdir &&\n'> <'\t\t__gitdir >"$actual"\n'> <'\t) &&\n'> 
            <'\ttest_cmp expected "$actual"\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'__gitdir - non-existing $GIT_DIR'>)}
        {
          (SQ <'\n'> <'\t(\n'> <'\t\tGIT_DIR="$TRASH_DIRECTORY/non-existing" &&\n'> 
            <'\t\texport GIT_DIR &&\n'> <'\t\ttest_must_fail __gitdir\n'> <'\t)\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.ShFunction
      keyword: <Id.KW_Function function>
      name_tok: <pwd_P_W>
      name: pwd_P_W
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.If
              if_kw: <Id.KW_If if>
              arms: [
                (IfArm
                  keyword: <Id.KW_If if>
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Simple
                          blame_tok: <test_have_prereq>
                          more_env: []
                          words: [{<test_have_prereq>} {<MINGW>}]
                          redirects: []
                          do_fork: T
                        )
                      ]
                    )
                  then_kw: <Id.KW_Then then>
                  action: [
                    (command.Simple
                      blame_tok: <pwd>
                      more_env: []
                      words: [{<pwd>} {<-W>}]
                      redirects: []
                      do_fork: T
                    )
                  ]
                  spids: [807 814]
                )
              ]
              else_kw: <Id.KW_Else else>
              else_action: [
                (command.Simple
                  blame_tok: <pwd>
                  more_env: []
                  words: [{<pwd>} {<-P>}]
                  redirects: []
                  do_fork: T
                )
              ]
              fi_kw: <Id.KW_Fi fi>
              redirects: []
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'__gitdir - gitfile in cwd'>)}
        {
          (SQ <'\n'> <'\techo "$(pwd_P_W)/otherrepo/.git" >expected &&\n'> 
            <'\techo "gitdir: $(pwd_P_W)/otherrepo/.git" >subdir/.git &&\n'> <'\ttest_when_finished "rm -f subdir/.git" &&\n'> <'\t(\n'> <'\t\tcd subdir &&\n'> 
            <'\t\t__gitdir >"$actual"\n'> <'\t) &&\n'> <'\ttest_cmp expected "$actual"\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'__gitdir - gitfile in parent'>)}
        {
          (SQ <'\n'> <'\techo "$(pwd_P_W)/otherrepo/.git" >expected &&\n'> 
            <'\techo "gitdir: $(pwd_P_W)/otherrepo/.git" >subdir/.git &&\n'> <'\ttest_when_finished "rm -f subdir/.git" &&\n'> <'\t(\n'> <'\t\tcd subdir/subsubdir &&\n'> 
            <'\t\t__gitdir >"$actual"\n'> <'\t) &&\n'> <'\ttest_cmp expected "$actual"\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {<SYMLINKS>}
        {(SQ <'__gitdir - resulting path avoids symlinks'>)}
        {
          (SQ <'\n'> <'\techo "$(pwd -P)/otherrepo/.git" >expected &&\n'> 
            <'\tmkdir otherrepo/dir &&\n'> <'\ttest_when_finished "rm -rf otherrepo/dir" &&\n'> <'\tln -s otherrepo/dir link &&\n'> 
            <'\ttest_when_finished "rm -f link" &&\n'> <'\t(\n'> <'\t\tcd link &&\n'> <'\t\t__gitdir >"$actual"\n'> <'\t) &&\n'> 
            <'\ttest_cmp expected "$actual"\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'__gitdir - not a git repository'>)}
        {
          (SQ <'\n'> <'\t(\n'> <'\t\tcd subdir/subsubdir &&\n'> 
            <'\t\tGIT_CEILING_DIRECTORIES="$TRASH_DIRECTORY" &&\n'> <'\t\texport GIT_CEILING_DIRECTORIES &&\n'> <'\t\ttest_must_fail __gitdir\n'> <'\t)\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'__gitcomp - trailing space - options'>)}
        {
          (SQ <'\n'> <'\ttest_gitcomp "--re" "--dry-run --reuse-message= --reedit-message=\n'> 
            <'\t\t--reset-author" <<-EOF\n'> <'\t--reuse-message=Z\n'> <'\t--reedit-message=Z\n'> <'\t--reset-author Z\n'> <'\tEOF\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'__gitcomp - trailing space - config keys'>)}
        {
          (SQ <'\n'> <'\ttest_gitcomp "br" "branch. branch.autosetupmerge\n'> 
            <'\t\tbranch.autosetuprebase browser." <<-\\EOF\n'> <'\tbranch.Z\n'> <'\tbranch.autosetupmerge Z\n'> <'\tbranch.autosetuprebase Z\n'> <'\tbrowser.Z\n'> 
            <'\tEOF\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'__gitcomp - option parameter'>)}
        {
          (SQ <'\n'> <'\ttest_gitcomp "--strategy=re" "octopus ours recursive resolve subtree" \\\n'> 
            <'\t\t"" "re" <<-\\EOF\n'> <'\trecursive Z\n'> <'\tresolve Z\n'> <'\tEOF\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'__gitcomp - prefix'>)}
        {
          (SQ <'\n'> <'\ttest_gitcomp "branch.me" "remote merge mergeoptions rebase" \\\n'> 
            <'\t\t"branch.maint." "me" <<-\\EOF\n'> <'\tbranch.maint.merge Z\n'> <'\tbranch.maint.mergeoptions Z\n'> <'\tEOF\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'__gitcomp - suffix'>)}
        {
          (SQ <'\n'> <'\ttest_gitcomp "branch.me" "master maint next pu" "branch." \\\n'> 
            <'\t\t"ma" "." <<-\\EOF\n'> <'\tbranch.master.Z\n'> <'\tbranch.maint.Z\n'> <'\tEOF\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'__gitcomp - doesnt fail because of invalid variable name'>)}
        {(SQ <'\n'> <'\t__gitcomp "$invalid_variable_name"\n'>)}
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <read>
      more_env: []
      words: [{<read>} {<-r>} {<-d>} {(DQ )} {<refs>}]
      redirects: [
        (Redir
          op: <Id.Redir_DLessDash '<<-'>
          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: [<'maint\n'> <'master\n'> <'next\n'> <'pu\n'>]
            )
        )
      ]
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'__gitcomp_nl - trailing space'>)}
        {
          (SQ <'\n'> <'\ttest_gitcomp_nl "m" "$refs" <<-EOF\n'> <'\tmaint Z\n'> <'\tmaster Z\n'> 
            <'\tEOF\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'__gitcomp_nl - prefix'>)}
        {
          (SQ <'\n'> <'\ttest_gitcomp_nl "--fixup=m" "$refs" "--fixup=" "m" <<-EOF\n'> 
            <'\t--fixup=maint Z\n'> <'\t--fixup=master Z\n'> <'\tEOF\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'__gitcomp_nl - suffix'>)}
        {
          (SQ <'\n'> <'\ttest_gitcomp_nl "branch.ma" "$refs" "branch." "ma" "." <<-\\EOF\n'> 
            <'\tbranch.maint.Z\n'> <'\tbranch.master.Z\n'> <'\tEOF\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'__gitcomp_nl - no suffix'>)}
        {
          (SQ <'\n'> <'\ttest_gitcomp_nl "ma" "$refs" "" "ma" "" <<-\\EOF\n'> <'\tmaintZ\n'> 
            <'\tmasterZ\n'> <'\tEOF\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'__gitcomp_nl - doesnt fail because of invalid variable name'>)}
        {(SQ <'\n'> <'\t__gitcomp_nl "$invalid_variable_name"\n'>)}
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'__git_remotes - list remotes from $GIT_DIR/remotes and from config file'>)}
        {
          (SQ <'\n'> <'\tcat >expect <<-EOF &&\n'> <'\tremote_from_file_1\n'> <'\tremote_from_file_2\n'> 
            <'\tremote_in_config_1\n'> <'\tremote_in_config_2\n'> <'\tEOF\n'> <'\ttest_when_finished "rm -rf .git/remotes" &&\n'> 
            <'\tmkdir -p .git/remotes &&\n'> <'\t>.git/remotes/remote_from_file_1 &&\n'> <'\t>.git/remotes/remote_from_file_2 &&\n'> 
            <'\ttest_when_finished "git remote remove remote_in_config_1" &&\n'> <'\tgit remote add remote_in_config_1 git://remote_1 &&\n'> 
            <'\ttest_when_finished "git remote remove remote_in_config_2" &&\n'> <'\tgit remote add remote_in_config_2 git://remote_2 &&\n'> <'\t__git_remotes >actual &&\n'> 
            <'\ttest_cmp expect actual\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <__git_get_config_variables>)}
        {
          (SQ <'\n'> <'\tcat >expect <<-EOF &&\n'> <'\tname-1\n'> <'\tname-2\n'> <'\tEOF\n'> 
            <'\ttest_config interesting.name-1 good &&\n'> <'\ttest_config interesting.name-2 good &&\n'> 
            <'\ttest_config subsection.interesting.name-3 bad &&\n'> <'\t__git_get_config_variables interesting >actual &&\n'> <'\ttest_cmp expect actual\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <__git_pretty_aliases>)}
        {
          (SQ <'\n'> <'\tcat >expect <<-EOF &&\n'> <'\tauthor\n'> <'\thash\n'> <'\tEOF\n'> 
            <'\ttest_config pretty.author "%an %ae" &&\n'> <'\ttest_config pretty.hash %H &&\n'> <'\t__git_pretty_aliases >actual &&\n'> 
            <'\ttest_cmp expect actual\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <__git_aliases>)}
        {
          (SQ <'\n'> <'\tcat >expect <<-EOF &&\n'> <'\tci\n'> <'\tco\n'> <'\tEOF\n'> 
            <'\ttest_config alias.ci commit &&\n'> <'\ttest_config alias.co checkout &&\n'> <'\t__git_aliases >actual &&\n'> 
            <'\ttest_cmp expect actual\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <basic>)}
        {
          (SQ <'\n'> <'\trun_completion "git " &&\n'> <'\t# built-in\n'> 
            <'\tgrep -q "^add \\$" out &&\n'> <'\t# script\n'> <'\tgrep -q "^filter-branch \\$" out &&\n'> <'\t# plumbing\n'> 
            <'\t! grep -q "^ls-files \\$" out &&\n'> <'\n'> <'\trun_completion "git f" &&\n'> <'\t! grep -q -v "^f" out\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'double dash "git" itself'>)}
        {
          (SQ <'\n'> <'\ttest_completion "git --" <<-\\EOF\n'> <'\t--paginate Z\n'> <'\t--no-pager Z\n'> 
            <'\t--git-dir=\n'> <'\t--bare Z\n'> <'\t--version Z\n'> <'\t--exec-path Z\n'> <'\t--exec-path=\n'> <'\t--html-path Z\n'> 
            <'\t--man-path Z\n'> <'\t--info-path Z\n'> <'\t--work-tree=\n'> <'\t--namespace=\n'> <'\t--no-replace-objects Z\n'> 
            <'\t--help Z\n'> <'\tEOF\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'double dash "git checkout"'>)}
        {
          (SQ <'\n'> <'\ttest_completion "git checkout --" <<-\\EOF\n'> <'\t--quiet Z\n'> 
            <'\t--ours Z\n'> <'\t--theirs Z\n'> <'\t--track Z\n'> <'\t--no-track Z\n'> <'\t--merge Z\n'> <'\t--conflict=\n'> 
            <'\t--orphan Z\n'> <'\t--patch Z\n'> <'\tEOF\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'general options'>)}
        {
          (SQ <'\n'> <'\ttest_completion "git --ver" "--version " &&\n'> 
            <'\ttest_completion "git --hel" "--help " &&\n'> <'\ttest_completion "git --exe" <<-\\EOF &&\n'> <'\t--exec-path Z\n'> <'\t--exec-path=\n'> <'\tEOF\n'> 
            <'\ttest_completion "git --htm" "--html-path " &&\n'> <'\ttest_completion "git --pag" "--paginate " &&\n'> 
            <'\ttest_completion "git --no-p" "--no-pager " &&\n'> <'\ttest_completion "git --git" "--git-dir=" &&\n'> 
            <'\ttest_completion "git --wor" "--work-tree=" &&\n'> <'\ttest_completion "git --nam" "--namespace=" &&\n'> <'\ttest_completion "git --bar" "--bare " &&\n'> 
            <'\ttest_completion "git --inf" "--info-path " &&\n'> <'\ttest_completion "git --no-r" "--no-replace-objects "\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'general options plus command'>)}
        {
          (SQ <'\n'> <'\ttest_completion "git --version check" "checkout " &&\n'> 
            <'\ttest_completion "git --paginate check" "checkout " &&\n'> <'\ttest_completion "git --git-dir=foo check" "checkout " &&\n'> 
            <'\ttest_completion "git --bare check" "checkout " &&\n'> <'\ttest_completion "git --exec-path=foo check" "checkout " &&\n'> 
            <'\ttest_completion "git --html-path check" "checkout " &&\n'> <'\ttest_completion "git --no-pager check" "checkout " &&\n'> 
            <'\ttest_completion "git --work-tree=foo check" "checkout " &&\n'> <'\ttest_completion "git --namespace=foo check" "checkout " &&\n'> 
            <'\ttest_completion "git --paginate check" "checkout " &&\n'> <'\ttest_completion "git --info-path check" "checkout " &&\n'> 
            <'\ttest_completion "git --no-replace-objects check" "checkout "\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'git --help completion'>)}
        {
          (SQ <'\n'> <'\ttest_completion "git --help ad" "add " &&\n'> 
            <'\ttest_completion "git --help core" "core-tutorial "\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'setup for ref completion'>)}
        {
          (SQ <'\n'> <'\techo content >file1 &&\n'> <'\techo more >file2 &&\n'> <'\tgit add . &&\n'> 
            <'\tgit commit -m one &&\n'> <'\tgit branch mybranch &&\n'> <'\tgit tag mytag\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'checkout completes ref names'>)}
        {
          (SQ <'\n'> <'\ttest_completion "git checkout m" <<-\\EOF\n'> <'\tmaster Z\n'> 
            <'\tmybranch Z\n'> <'\tmytag Z\n'> <'\tEOF\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'show completes all refs'>)}
        {
          (SQ <'\n'> <'\ttest_completion "git show m" <<-\\EOF\n'> <'\tmaster Z\n'> <'\tmybranch Z\n'> 
            <'\tmytag Z\n'> <'\tEOF\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'<ref>: completes paths'>)}
        {
          (SQ <'\n'> <'\ttest_completion "git show mytag:f" <<-\\EOF\n'> <'\tfile1 Z\n'> <'\tfile2 Z\n'> 
            <'\tEOF\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'complete tree filename with spaces'>)}
        {
          (SQ <'\n'> <'\techo content >"name with spaces" &&\n'> <'\tgit add . &&\n'> 
            <'\tgit commit -m spaces &&\n'> <'\ttest_completion "git show HEAD:nam" <<-\\EOF\n'> <'\tname with spaces Z\n'> <'\tEOF\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'complete tree filename with metacharacters'>)}
        {
          (SQ <'\n'> <'\techo content >"name with \\${meta}" &&\n'> <'\tgit add . &&\n'> 
            <'\tgit commit -m meta &&\n'> <'\ttest_completion "git show HEAD:nam" <<-\\EOF\n'> <'\tname with ${meta} Z\n'> 
            <'\tname with spaces Z\n'> <'\tEOF\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <send-email>)}
        {
          (SQ <'\n'> <'\ttest_completion "git send-email --cov" "--cover-letter " &&\n'> 
            <'\ttest_completion "git send-email ma" "master "\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'complete files'>)}
        {
          (SQ <'\n'> <'\tgit init tmp && cd tmp &&\n'> 
            <'\ttest_when_finished "cd .. && rm -rf tmp" &&\n'> <'\n'> <'\techo "expected" > .gitignore &&\n'> <'\techo "out" >> .gitignore &&\n'> <'\n'> 
            <'\tgit add .gitignore &&\n'> <'\ttest_completion "git commit " ".gitignore" &&\n'> <'\n'> <'\tgit commit -m ignore &&\n'> <'\n'> 
            <'\ttouch new &&\n'> <'\ttest_completion "git add " "new" &&\n'> <'\n'> <'\tgit add new &&\n'> 
            <'\tgit commit -a -m new &&\n'> <'\ttest_completion "git add " "" &&\n'> <'\n'> <'\tgit mv new modified &&\n'> 
            <'\techo modify > modified &&\n'> <'\ttest_completion "git add " "modified" &&\n'> <'\n'> <'\ttouch untracked &&\n'> <'\n'> 
            <'\t: TODO .gitignore should not be here &&\n'> <'\ttest_completion "git rm " <<-\\EOF &&\n'> <'\t.gitignore\n'> <'\tmodified\n'> <'\tEOF\n'> <'\n'> 
            <'\ttest_completion "git clean " "untracked" &&\n'> <'\n'> <'\t: TODO .gitignore should not be here &&\n'> <'\ttest_completion "git mv " <<-\\EOF &&\n'> 
            <'\t.gitignore\n'> <'\tmodified\n'> <'\tEOF\n'> <'\n'> <'\tmkdir dir &&\n'> <'\ttouch dir/file-in-dir &&\n'> 
            <'\tgit add dir/file-in-dir &&\n'> <'\tgit commit -m dir &&\n'> <'\n'> <'\tmkdir untracked-dir &&\n'> <'\n'> 
            <'\t: TODO .gitignore should not be here &&\n'> <'\ttest_completion "git mv modified " <<-\\EOF &&\n'> <'\t.gitignore\n'> <'\tdir\n'> <'\tmodified\n'> 
            <'\tuntracked\n'> <'\tuntracked-dir\n'> <'\tEOF\n'> <'\n'> <'\ttest_completion "git commit " "modified" &&\n'> <'\n'> 
            <'\t: TODO .gitignore should not be here &&\n'> <'\ttest_completion "git ls-files " <<-\\EOF &&\n'> <'\t.gitignore\n'> <'\tdir\n'> <'\tmodified\n'> 
            <'\tEOF\n'> <'\n'> <'\ttouch momified &&\n'> <'\ttest_completion "git add mom" "momified"\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(DQ <'completion uses <cmd> completion for alias: !sh -c \'git <cmd> ...\''>)}
        {(SQ <'\n'> <'\ttest_config alias.co "!sh -c '>) (DQ <'\''>) (SQ <'git checkout ...'>) 
          (DQ <'\''>) 
          (SQ <'" &&\n'> <'\ttest_completion "git co m" <<-\\EOF\n'> <'\tmaster Z\n'> <'\tmybranch Z\n'> 
            <'\tmytag Z\n'> <'\tEOF\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'completion uses <cmd> completion for alias: !f () { VAR=val git <cmd> ... }'>)}
        {
          (SQ <'\n'> <'\ttest_config alias.co "!f () { VAR=val git checkout ... ; } f" &&\n'> 
            <'\ttest_completion "git co m" <<-\\EOF\n'> <'\tmaster Z\n'> <'\tmybranch Z\n'> <'\tmytag Z\n'> <'\tEOF\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'completion used <cmd> completion for alias: !f() { : git <cmd> ; ... }'>)}
        {
          (SQ <'\n'> <'\ttest_config alias.co "!f() { : git checkout ; if ... } f" &&\n'> 
            <'\ttest_completion "git co m" <<-\\EOF\n'> <'\tmaster Z\n'> <'\tmybranch Z\n'> <'\tmytag Z\n'> <'\tEOF\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_failure>
      more_env: []
      words: [
        {<test_expect_failure>}
        {(SQ <'complete with tilde expansion'>)}
        {
          (SQ <'\n'> <'\tgit init tmp && cd tmp &&\n'> 
            <'\ttest_when_finished "cd .. && rm -rf tmp" &&\n'> <'\n'> <'\ttouch ~/tmp/file &&\n'> <'\n'> <'\ttest_completion "git add ~/tmp/" "~/tmp/file"\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_done>
      more_env: []
      words: [{<test_done>}]
      redirects: []
      do_fork: T
    )
  ]
)