(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 <'core.whitespace rules and git apply'>)}
        )
      ]
      redirects: []
    )
    (command.Simple
      blame_tok: <.>
      more_env: []
      words: [{<.>} {<'./test-lib.sh'>}]
      redirects: []
      do_fork: T
    )
    (command.ShFunction
      name_tok: <prepare_test_file>
      name: prepare_test_file
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.Simple
              blame_tok: <sed>
              more_env: []
              words: [{<sed>} {<-e>} {(DQ <'s/_/ /g'>)} {<-e>} {(DQ <'s/>/\t/'>)}]
              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: [
                        <'An_SP in an ordinary line>and a HT.\n'>
                        <'>A HT (%).\n'>
                        <'_>A SP and a HT (@%).\n'>
                        <'_>_A SP, a HT and a SP (@%).\n'>
                        <'_______Seven SP.\n'>
                        <'________Eight SP (#).\n'>
                        <'_______>Seven SP and a HT (@%).\n'>
                        <'________>Eight SP and a HT (@#%).\n'>
                        <'_______>_Seven SP, a HT and a SP (@%).\n'>
                        <'________>_Eight SP, a HT and a SP (@#%).\n'>
                        <'_______________Fifteen SP (#).\n'>
                        <'_______________>Fifteen SP and a HT (@#%).\n'>
                        <'________________Sixteen SP (#=).\n'>
                        <'________________>Sixteen SP and a HT (@#%=).\n'>
                        <'_____a__Five SP, a non WS, two SP.\n'>
                        <'A line with a (!) trailing SP_\n'>
                        <'A line with a (!) trailing HT>\n'>
                      ]
                    )
                )
              ]
              do_fork: T
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name_tok: <apply_patch>
      name: apply_patch
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.AndOr
              children: [
                (command.Simple
                  blame_tok: <Id.Redir_Great '>'>
                  more_env: []
                  words: []
                  redirects: [(Redir op:<Id.Redir_Great '>'> loc:(redir_loc.Fd fd:1) arg:{<target>})]
                  do_fork: F
                )
                (command.Pipeline
                  children: [
                    (command.Simple
                      blame_tok: <sed>
                      more_env: []
                      words: [
                        {<sed>}
                        {<-e>}
                        {
                          (DQ <'s|'> <Id.Lit_BadBackslash '\\'> <'([ab]'> <Id.Lit_BadBackslash '\\'> 
                            <')/file|'> <Id.Lit_BadBackslash '\\'> <'1/target|'>
                          )
                        }
                      ]
                      redirects: [(Redir op:<Id.Redir_Less '<'> loc:(redir_loc.Fd fd:0) arg:{<patch>})]
                      do_fork: T
                    )
                    (command.Simple
                      blame_tok: <git>
                      more_env: []
                      words: [{<git>} {<apply>} {(DQ ($ Id.VSub_At '@'))}]
                      redirects: []
                      do_fork: T
                    )
                  ]
                  ops: [<Id.Op_Pipe _>]
                )
              ]
              ops: [<Id.Op_DAmp _>]
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name_tok: <test_fix>
      name: test_fix
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.AndOr
              children: [
                (command.Simple
                  blame_tok: <apply_patch>
                  more_env: []
                  words: [{<apply_patch>} {<--whitespace> <Id.Lit_Equals '='> <fix>}]
                  redirects: []
                  do_fork: T
                )
                (command.ControlFlow
                  keyword: <Id.ControlFlow_Return return>
                  arg_word: {<1>}
                )
              ]
              ops: [<Id.Op_DPipe _>]
            )
            (command.Pipeline
              children: [
                (command.Simple
                  blame_tok: <Id.VSub_DollarName '$DIFF'>
                  more_env: []
                  words: [{($ Id.VSub_DollarName DIFF)} {<file>} {<target>}]
                  redirects: []
                  do_fork: T
                )
                (command.Simple
                  blame_tok: <sed>
                  more_env: []
                  words: [{<sed>} {<-n>} {<-e>} {(DQ <'s/^> //p'>)}]
                  redirects: [(Redir op:<Id.Redir_Great '>'> loc:(redir_loc.Fd fd:1) arg:{<fixed>})]
                  do_fork: T
                )
              ]
              ops: [<Id.Op_Pipe _>]
            )
            (command.ShAssignment
              left: <Id.Lit_VarLike 'fixed_cnt='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'fixed_cnt='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'fixed_cnt='> name:fixed_cnt)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (CommandSub
                        left_token: <Id.Left_DollarParen '$('>
                        child: 
                          (command.Simple
                            blame_tok: <wc>
                            more_env: []
                            words: [{<wc>} {<-l>}]
                            redirects: [
                              (Redir
                                op: <Id.Redir_Less '<'>
                                loc: (redir_loc.Fd fd:0)
                                arg: {<fixed>}
                              )
                            ]
                            do_fork: T
                          )
                        right: <Id.Eof_RParen _>
                      )
                    }
                )
              ]
              redirects: []
            )
            (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: <Id.Left_SingleQuote '\''>
                  pattern: (pat.Words words:[{(SQ )}])
                  middle: <Id.Right_CasePat _>
                  action: [
                    (command.ShAssignment
                      left: <Id.Lit_VarLike 'expect_cnt='>
                      pairs: [
                        (AssignPair
                          left: <Id.Lit_VarLike 'expect_cnt='>
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'expect_cnt='> name:expect_cnt)
                          op: assign_op.Equal
                          rhs: {($ Id.VSub_DollarName fixed_cnt)}
                        )
                      ]
                      redirects: []
                    )
                  ]
                  right: <Id.Op_DSemi _>
                )
                (CaseArm
                  left: <Id.Lit_QMark '?'>
                  pattern: (pat.Words words:[{<Id.Lit_QMark '?'> <Id.Lit_Star '*'>}])
                  middle: <Id.Right_CasePat _>
                  action: [
                    (command.ShAssignment
                      left: <Id.Lit_VarLike 'expect_cnt='>
                      pairs: [
                        (AssignPair
                          left: <Id.Lit_VarLike 'expect_cnt='>
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'expect_cnt='> name:expect_cnt)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (CommandSub
                                left_token: <Id.Left_DollarParen '$('>
                                child: 
                                  (command.Pipeline
                                    children: [
                                      (command.Simple
                                        blame_tok: <grep>
                                        more_env: []
                                        words: [{<grep>} {(DQ <'['> ($ Id.VSub_Number 1) <']'>)}]
                                        redirects: [
                                          (Redir
                                            op: <Id.Redir_Less '<'>
                                            loc: (redir_loc.Fd fd:0)
                                            arg: {<fixed>}
                                          )
                                        ]
                                        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: []
                    )
                  ]
                  right: <Id.Op_DSemi _>
                )
              ]
              arms_end: <Id.KW_Esac esac>
              redirects: []
            )
            (command.AndOr
              children: [
                (command.Simple
                  blame_tok: <test>
                  more_env: []
                  words: [
                    {<test>}
                    {($ Id.VSub_DollarName fixed_cnt)}
                    {<-eq>}
                    {($ Id.VSub_DollarName expect_cnt)}
                  ]
                  redirects: []
                  do_fork: T
                )
                (command.ControlFlow
                  keyword: <Id.ControlFlow_Return return>
                  arg_word: {<1>}
                )
              ]
              ops: [<Id.Op_DPipe _>]
            )
            (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: <Id.Left_SingleQuote '\''>
                  pattern: (pat.Words words:[{(SQ )}])
                  middle: <Id.Right_CasePat _>
                  action: [
                    (command.ShAssignment
                      left: <Id.Lit_VarLike 'expect_cnt='>
                      pairs: [
                        (AssignPair
                          left: <Id.Lit_VarLike 'expect_cnt='>
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'expect_cnt='> name:expect_cnt)
                          op: assign_op.Equal
                          rhs: {<0>}
                        )
                      ]
                      redirects: []
                    )
                  ]
                  right: <Id.Op_DSemi _>
                )
                (CaseArm
                  left: <Id.Lit_QMark '?'>
                  pattern: (pat.Words words:[{<Id.Lit_QMark '?'> <Id.Lit_Star '*'>}])
                  middle: <Id.Right_CasePat _>
                  action: [
                    (command.ShAssignment
                      left: <Id.Lit_VarLike 'expect_cnt='>
                      pairs: [
                        (AssignPair
                          left: <Id.Lit_VarLike 'expect_cnt='>
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'expect_cnt='> name:expect_cnt)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (CommandSub
                                left_token: <Id.Left_DollarParen '$('>
                                child: 
                                  (command.Pipeline
                                    children: [
                                      (command.Simple
                                        blame_tok: <grep>
                                        more_env: []
                                        words: [{<grep>} {(DQ <'['> ($ Id.VSub_Number 1) <']'>)}]
                                        redirects: [
                                          (Redir
                                            op: <Id.Redir_Less '<'>
                                            loc: (redir_loc.Fd fd:0)
                                            arg: {<file>}
                                          )
                                        ]
                                        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: []
                    )
                  ]
                  right: <Id.Op_DSemi _>
                )
              ]
              arms_end: <Id.KW_Esac esac>
              redirects: []
            )
            (command.AndOr
              children: [
                (command.Simple
                  blame_tok: <test>
                  more_env: []
                  words: [
                    {<test>}
                    {($ Id.VSub_DollarName fixed_cnt)}
                    {<-eq>}
                    {($ Id.VSub_DollarName expect_cnt)}
                  ]
                  redirects: []
                  do_fork: T
                )
                (command.ControlFlow
                  keyword: <Id.ControlFlow_Return return>
                  arg_word: {<1>}
                )
              ]
              ops: [<Id.Op_DPipe _>]
            )
            (command.Simple
              blame_tok: <git>
              more_env: []
              words: [{<git>} {<diff-files>} {<-p>} {<target>}]
              redirects: [(Redir op:<Id.Redir_Great '>'> loc:(redir_loc.Fd fd:1) arg:{<fixed-patch>})]
              do_fork: T
            )
            (command.AndOr
              children: [
                (command.Simple
                  blame_tok: <test>
                  more_env: []
                  words: [{<test>} {<-s>} {<fixed-patch>}]
                  redirects: []
                  do_fork: T
                )
                (command.ControlFlow
                  keyword: <Id.ControlFlow_Return return>
                  arg_word: {<0>}
                )
              ]
              ops: [<Id.Op_DAmp _>]
            )
            (command.Simple
              blame_tok: <Id.Redir_Great '>'>
              more_env: []
              words: []
              redirects: [(Redir op:<Id.Redir_Great '>'> loc:(redir_loc.Fd fd:1) arg:{<target>})]
              do_fork: F
            )
            (command.Simple
              blame_tok: <git>
              more_env: []
              words: [{<git>} {<apply>} {<--whitespace> <Id.Lit_Equals '='> <error-all>}]
              redirects: [(Redir op:<Id.Redir_Less '<'> loc:(redir_loc.Fd fd:0) arg:{<fixed-patch>})]
              do_fork: T
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {<setup>}
        {
          (SQ <'\n'> <'\n'> <'\t>file &&\n'> <'\tgit add file &&\n'> <'\tprepare_test_file >file &&\n'> 
            <'\tgit diff-files -p >patch &&\n'> <'\t>target &&\n'> <'\tgit add target\n'> <'\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'whitespace=nowarn, default rule'>)}
        {
          (SQ <'\n'> <'\n'> <'\tapply_patch --whitespace=nowarn &&\n'> <'\ttest_cmp file target\n'> 
            <'\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'whitespace=warn, default rule'>)}
        {
          (SQ <'\n'> <'\n'> <'\tapply_patch --whitespace=warn &&\n'> <'\ttest_cmp file target\n'> <'\n'>)
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'whitespace=error-all, default rule'>)}
        {
          (SQ <'\n'> <'\n'> <'\ttest_must_fail apply_patch --whitespace=error-all &&\n'> 
            <'\t! test -s target\n'> <'\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'whitespace=error-all, no rule'>)}
        {
          (SQ <'\n'> <'\n'> <'\tgit config core.whitespace -trailing,-space-before,-indent &&\n'> 
            <'\tapply_patch --whitespace=error-all &&\n'> <'\ttest_cmp file target\n'> <'\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'whitespace=error-all, no rule (attribute)'>)}
        {
          (SQ <'\n'> <'\n'> <'\tgit config --unset core.whitespace &&\n'> 
            <'\techo "target -whitespace" >.gitattributes &&\n'> <'\tapply_patch --whitespace=error-all &&\n'> <'\ttest_cmp file target\n'> <'\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'spaces inserted by tab-in-indent'>)}
        {
          (SQ <'\n'> <'\n'> <'\tgit config core.whitespace -trailing,-space,-indent,tab &&\n'> 
            <'\trm -f .gitattributes &&\n'> <'\ttest_fix % &&\n'> <'\tsed -e "s/_/ /g" -e "s/>/\t/" <<-\\EOF >expect &&\n'> 
            <'\t\tAn_SP in an ordinary line>and a HT.\n'> <'\t\t________A HT (%).\n'> <'\t\t________A SP and a HT (@%).\n'> 
            <'\t\t_________A SP, a HT and a SP (@%).\n'> <'\t\t_______Seven SP.\n'> <'\t\t________Eight SP (#).\n'> <'\t\t________Seven SP and a HT (@%).\n'> 
            <'\t\t________________Eight SP and a HT (@#%).\n'> <'\t\t_________Seven SP, a HT and a SP (@%).\n'> 
            <'\t\t_________________Eight SP, a HT and a SP (@#%).\n'> <'\t\t_______________Fifteen SP (#).\n'> <'\t\t________________Fifteen SP and a HT (@#%).\n'> 
            <'\t\t________________Sixteen SP (#=).\n'> <'\t\t________________________Sixteen SP and a HT (@#%=).\n'> 
            <'\t\t_____a__Five SP, a non WS, two SP.\n'> <'\t\tA line with a (!) trailing SP_\n'> <'\t\tA line with a (!) trailing HT>\n'> <'\tEOF\n'> 
            <'\ttest_cmp expect target\n'> <'\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.ForEach
      keyword: <Id.KW_For for>
      iter_names: [t]
      iterable: (for_iter.Words words:[{<->} {(SQ )}])
      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_DollarName t))})
              arms_start: <Id.KW_In in>
              arms: [
                (CaseArm
                  left: <Id.Left_SingleQuote '\''>
                  pattern: (pat.Words words:[{(SQ )}])
                  middle: <Id.Right_CasePat _>
                  action: [
                    (command.ShAssignment
                      left: <Id.Lit_VarLike 'tt='>
                      pairs: [
                        (AssignPair
                          left: <Id.Lit_VarLike 'tt='>
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'tt='> name:tt)
                          op: assign_op.Equal
                          rhs: {(SQ <'!'>)}
                        )
                      ]
                      redirects: []
                    )
                  ]
                  right: <Id.Op_DSemi _>
                )
                (CaseArm
                  left: <Id.Lit_Star '*'>
                  pattern: (pat.Words words:[{<Id.Lit_Star '*'>}])
                  middle: <Id.Right_CasePat _>
                  action: [
                    (command.ShAssignment
                      left: <Id.Lit_VarLike 'tt='>
                      pairs: [
                        (AssignPair
                          left: <Id.Lit_VarLike 'tt='>
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'tt='> name:tt)
                          op: assign_op.Equal
                          rhs: (rhs_word__Empty)
                        )
                      ]
                      redirects: []
                    )
                  ]
                  right: <Id.Op_DSemi _>
                )
              ]
              arms_end: <Id.KW_Esac esac>
              redirects: []
            )
            (command.ForEach
              keyword: <Id.KW_For for>
              iter_names: [s]
              iterable: (for_iter.Words words:[{<->} {(SQ )}])
              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_DollarName s))})
                      arms_start: <Id.KW_In in>
                      arms: [
                        (CaseArm
                          left: <Id.Left_SingleQuote '\''>
                          pattern: (pat.Words words:[{(SQ )}])
                          middle: <Id.Right_CasePat _>
                          action: [
                            (command.ShAssignment
                              left: <Id.Lit_VarLike 'ts='>
                              pairs: [
                                (AssignPair
                                  left: <Id.Lit_VarLike 'ts='>
                                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'ts='> name:ts)
                                  op: assign_op.Equal
                                  rhs: {(SQ <'@'>)}
                                )
                              ]
                              redirects: []
                            )
                          ]
                          right: <Id.Op_DSemi _>
                        )
                        (CaseArm
                          left: <Id.Lit_Star '*'>
                          pattern: (pat.Words words:[{<Id.Lit_Star '*'>}])
                          middle: <Id.Right_CasePat _>
                          action: [
                            (command.ShAssignment
                              left: <Id.Lit_VarLike 'ts='>
                              pairs: [
                                (AssignPair
                                  left: <Id.Lit_VarLike 'ts='>
                                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'ts='> name:ts)
                                  op: assign_op.Equal
                                  rhs: (rhs_word__Empty)
                                )
                              ]
                              redirects: []
                            )
                          ]
                          right: <Id.Op_DSemi _>
                        )
                      ]
                      arms_end: <Id.KW_Esac esac>
                      redirects: []
                    )
                    (command.ForEach
                      keyword: <Id.KW_For for>
                      iter_names: [i]
                      iterable: (for_iter.Words words:[{<->} {(SQ )}])
                      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_DollarName i))})
                              arms_start: <Id.KW_In in>
                              arms: [
                                (CaseArm
                                  left: <Id.Left_SingleQuote '\''>
                                  pattern: (pat.Words words:[{(SQ )}])
                                  middle: <Id.Right_CasePat _>
                                  action: [
                                    (command.ShAssignment
                                      left: <Id.Lit_VarLike 'ti='>
                                      pairs: [
                                        (AssignPair
                                          left: <Id.Lit_VarLike 'ti='>
                                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'ti='> name:ti)
                                          op: assign_op.Equal
                                          rhs: {(SQ <'#'>)}
                                        )
                                        (AssignPair
                                          left: <Id.Lit_VarLike 'ti16='>
                                          lhs: 
                                            (sh_lhs_expr.Name
                                              left: <Id.Lit_VarLike 'ti16='>
                                              name: ti16
                                            )
                                          op: assign_op.Equal
                                          rhs: {(SQ <'='>)}
                                        )
                                      ]
                                      redirects: []
                                    )
                                  ]
                                  right: <Id.Op_DSemi _>
                                )
                                (CaseArm
                                  left: <Id.Lit_Star '*'>
                                  pattern: (pat.Words words:[{<Id.Lit_Star '*'>}])
                                  middle: <Id.Right_CasePat _>
                                  action: [
                                    (command.ShAssignment
                                      left: <Id.Lit_VarLike 'ti='>
                                      pairs: [
                                        (AssignPair
                                          left: <Id.Lit_VarLike 'ti='>
                                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'ti='> name:ti)
                                          op: assign_op.Equal
                                          rhs: (rhs_word__Empty)
                                        )
                                        (AssignPair
                                          left: <Id.Lit_VarLike 'ti16='>
                                          lhs: 
                                            (sh_lhs_expr.Name
                                              left: <Id.Lit_VarLike 'ti16='>
                                              name: ti16
                                            )
                                          op: assign_op.Equal
                                          rhs: (rhs_word__Empty)
                                        )
                                      ]
                                      redirects: []
                                    )
                                  ]
                                  right: <Id.Op_DSemi _>
                                )
                              ]
                              arms_end: <Id.KW_Esac esac>
                              redirects: []
                            )
                            (command.ForEach
                              keyword: <Id.KW_For for>
                              iter_names: [h]
                              iterable: (for_iter.Words words:[{<->} {(SQ )}])
                              body: 
                                (command.DoGroup
                                  left: <Id.KW_Do do>
                                  children: [
                                    (command.AndOr
                                      children: [
                                        (command.Simple
                                          blame_tok: <Id.Lit_LBracket '['>
                                          more_env: []
                                          words: [
                                            {<Id.Lit_LBracket '['>}
                                            {<-z>}
                                            {(DQ ($ Id.VSub_DollarName h) ($ Id.VSub_DollarName i))}
                                            {<Id.Lit_RBracket ']'>}
                                          ]
                                          redirects: []
                                          do_fork: T
                                        )
                                        (command.ControlFlow
                                          keyword: <Id.ControlFlow_Continue continue>
                                        )
                                      ]
                                      ops: [<Id.Op_DAmp _>]
                                    )
                                    (command.Case
                                      case_kw: <Id.KW_Case case>
                                      to_match: (case_arg.Word w:{(DQ ($ Id.VSub_DollarName h))})
                                      arms_start: <Id.KW_In in>
                                      arms: [
                                        (CaseArm
                                          left: <Id.Left_SingleQuote '\''>
                                          pattern: (pat.Words words:[{(SQ )}])
                                          middle: <Id.Right_CasePat _>
                                          action: [
                                            (command.ShAssignment
                                              left: <Id.Lit_VarLike 'th='>
                                              pairs: [
                                                (AssignPair
                                                  left: <Id.Lit_VarLike 'th='>
                                                  lhs: 
                                                    (sh_lhs_expr.Name
                                                      left: <Id.Lit_VarLike 'th='>
                                                      name: th
                                                    )
                                                  op: assign_op.Equal
                                                  rhs: {(SQ <'%'>)}
                                                )
                                              ]
                                              redirects: []
                                            )
                                          ]
                                          right: <Id.Op_DSemi _>
                                        )
                                        (CaseArm
                                          left: <Id.Lit_Star '*'>
                                          pattern: (pat.Words words:[{<Id.Lit_Star '*'>}])
                                          middle: <Id.Right_CasePat _>
                                          action: [
                                            (command.ShAssignment
                                              left: <Id.Lit_VarLike 'th='>
                                              pairs: [
                                                (AssignPair
                                                  left: <Id.Lit_VarLike 'th='>
                                                  lhs: 
                                                    (sh_lhs_expr.Name
                                                      left: <Id.Lit_VarLike 'th='>
                                                      name: th
                                                    )
                                                  op: assign_op.Equal
                                                  rhs: (rhs_word__Empty)
                                                )
                                              ]
                                              redirects: []
                                            )
                                          ]
                                          right: <Id.Op_DSemi _>
                                        )
                                      ]
                                      arms_end: <Id.KW_Esac esac>
                                      redirects: []
                                    )
                                    (command.ShAssignment
                                      left: <Id.Lit_VarLike 'rule='>
                                      pairs: [
                                        (AssignPair
                                          left: <Id.Lit_VarLike 'rule='>
                                          lhs: 
                                            (sh_lhs_expr.Name
                                              left: <Id.Lit_VarLike 'rule='>
                                              name: rule
                                            )
                                          op: assign_op.Equal
                                          rhs: 
                                            {(${ Id.VSub_Name t) <trailing> <Id.Lit_Comma ','> 
                                              (${ Id.VSub_Name s) <space> <Id.Lit_Comma ','> (${ Id.VSub_Name i) <indent> <Id.Lit_Comma ','> (${ Id.VSub_Name h) <tab>
                                            }
                                        )
                                      ]
                                      redirects: []
                                    )
                                    (command.Simple
                                      blame_tok: <rm>
                                      more_env: []
                                      words: [{<rm>} {<-f>} {<.gitattributes>}]
                                      redirects: []
                                      do_fork: T
                                    )
                                    (command.Simple
                                      blame_tok: <test_expect_success>
                                      more_env: []
                                      words: [
                                        {<test_expect_success>}
                                        {(DQ <'rule='> ($ Id.VSub_DollarName rule))}
                                        {
                                          (SQ <'\n'> 
                                            <'\t\t\t\t\tgit config core.whitespace "$rule" &&\n'> <'\t\t\t\t\ttest_fix "$tt$ts$ti$th"\n'> <'\t\t\t\t'>
                                          )
                                        }
                                      ]
                                      redirects: []
                                      do_fork: T
                                    )
                                    (command.Simple
                                      blame_tok: <test_expect_success>
                                      more_env: []
                                      words: [
                                        {<test_expect_success>}
                                        {(DQ <'rule='> ($ Id.VSub_DollarName rule) <',tabwidth=16'>)}
                                        {
                                          (SQ <'\n'> 
                                            <
'\t\t\t\t\tgit config core.whitespace "$rule,tabwidth=16" &&\n'
                                            > <'\t\t\t\t\ttest_fix "$tt$ts$ti16$th"\n'> <'\t\t\t\t'>
                                          )
                                        }
                                      ]
                                      redirects: []
                                      do_fork: T
                                    )
                                    (command.Simple
                                      blame_tok: <test_expect_success>
                                      more_env: []
                                      words: [
                                        {<test_expect_success>}
                                        {(DQ <'rule='> ($ Id.VSub_DollarName rule) <' (attributes)'>)}
                                        {
                                          (SQ <'\n'> 
                                            <'\t\t\t\t\tgit config --unset core.whitespace &&\n'> <'\t\t\t\t\techo "target whitespace=$rule" >.gitattributes &&\n'> 
                                            <'\t\t\t\t\ttest_fix "$tt$ts$ti$th"\n'> <'\t\t\t\t'>
                                          )
                                        }
                                      ]
                                      redirects: []
                                      do_fork: T
                                    )
                                    (command.Simple
                                      blame_tok: <test_expect_success>
                                      more_env: []
                                      words: [
                                        {<test_expect_success>}
                                        {
                                          (DQ <'rule='> ($ Id.VSub_DollarName rule) 
                                            <',tabwidth=16 (attributes)'>
                                          )
                                        }
                                        {
                                          (SQ <'\n'> 
                                            <
'\t\t\t\t\techo "target whitespace=$rule,tabwidth=16" >.gitattributes &&\n'
                                            > <'\t\t\t\t\ttest_fix "$tt$ts$ti16$th"\n'> <'\t\t\t\t'>
                                          )
                                        }
                                      ]
                                      redirects: []
                                      do_fork: T
                                    )
                                  ]
                                  right: <Id.KW_Done done>
                                )
                              redirects: []
                            )
                          ]
                          right: <Id.KW_Done done>
                        )
                      redirects: []
                    )
                  ]
                  right: <Id.KW_Done done>
                )
              redirects: []
            )
          ]
          right: <Id.KW_Done done>
        )
      redirects: []
    )
    (command.ShFunction
      name_tok: <create_patch>
      name: create_patch
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.Simple
              blame_tok: <sed>
              more_env: []
              words: [{<sed>} {<-e>} {(DQ <'s/_/ /'>)}]
              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: [
                        <'diff --git a/target b/target\n'>
                        <'index e69de29..8bd6648 100644\n'>
                        <'--- a/target\n'>
                        <'+++ b/target\n'>
                        <'@@ -0,0 +1,3 @@\n'>
                        <'+An empty line follows\n'>
                        <'+\n'>
                        <'+A line with trailing whitespace and no newline_\n'>
                        <'\\ No newline at end of file\n'>
                      ]
                    )
                )
              ]
              do_fork: T
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'trailing whitespace & no newline at the end of file'>)}
        {
          (SQ <'\n'> <'\t>target &&\n'> <'\tcreate_patch >patch-file &&\n'> 
            <'\tgit apply --whitespace=fix patch-file &&\n'> <'\tgrep "newline$" target &&\n'> <'\tgrep "^$" target\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'blank at EOF with --whitespace=fix (1)'>)}
        {
          (SQ <'\n'> <'\ttest_might_fail git config --unset core.whitespace &&\n'> 
            <'\trm -f .gitattributes &&\n'> <'\n'> <'\t{ echo a; echo b; echo c; } >one &&\n'> <'\tgit add one &&\n'> 
            <'\t{ echo a; echo b; echo c; } >expect &&\n'> <'\t{ cat expect; echo; } >one &&\n'> <'\tgit diff -- one >patch &&\n'> <'\n'> 
            <'\tgit checkout one &&\n'> <'\tgit apply --whitespace=fix patch &&\n'> <'\ttest_cmp expect one\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'blank at EOF with --whitespace=fix (2)'>)}
        {
          (SQ <'\n'> <'\t{ echo a; echo b; echo c; } >one &&\n'> <'\tgit add one &&\n'> 
            <'\t{ echo a; echo c; } >expect &&\n'> <'\t{ cat expect; echo; echo; } >one &&\n'> <'\tgit diff -- one >patch &&\n'> <'\n'> 
            <'\tgit checkout one &&\n'> <'\tgit apply --whitespace=fix patch &&\n'> <'\ttest_cmp expect one\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'blank at EOF with --whitespace=fix (3)'>)}
        {
          (SQ <'\n'> <'\t{ echo a; echo b; echo; } >one &&\n'> <'\tgit add one &&\n'> 
            <'\t{ echo a; echo c; echo; } >expect &&\n'> <'\t{ cat expect; echo; echo; } >one &&\n'> <'\tgit diff -- one >patch &&\n'> <'\n'> 
            <'\tgit checkout one &&\n'> <'\tgit apply --whitespace=fix patch &&\n'> <'\ttest_cmp expect one\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'blank at end of hunk, not at EOF with --whitespace=fix'>)}
        {
          (SQ <'\n'> <'\t{ echo a; echo b; echo; echo; echo; echo; echo; echo d; } >one &&\n'> 
            <'\tgit add one &&\n'> <'\t{ echo a; echo c; echo; echo; echo; echo; echo; echo; echo d; } >expect &&\n'> 
            <'\tcp expect one &&\n'> <'\tgit diff -- one >patch &&\n'> <'\n'> <'\tgit checkout one &&\n'> 
            <'\tgit apply --whitespace=fix patch &&\n'> <'\ttest_cmp expect one\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'blank at EOF with --whitespace=warn'>)}
        {
          (SQ <'\n'> <'\t{ echo a; echo b; echo c; } >one &&\n'> <'\tgit add one &&\n'> 
            <'\techo >>one &&\n'> <'\tcat one >expect &&\n'> <'\tgit diff -- one >patch &&\n'> <'\n'> <'\tgit checkout one &&\n'> 
            <'\tgit apply --whitespace=warn patch 2>error &&\n'> <'\ttest_cmp expect one &&\n'> <'\tgrep "new blank line at EOF" error\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'blank at EOF with --whitespace=error'>)}
        {
          (SQ <'\n'> <'\t{ echo a; echo b; echo c; } >one &&\n'> <'\tgit add one &&\n'> 
            <'\tcat one >expect &&\n'> <'\techo >>one &&\n'> <'\tgit diff -- one >patch &&\n'> <'\n'> <'\tgit checkout one &&\n'> 
            <'\ttest_must_fail git apply --whitespace=error patch 2>error &&\n'> <'\ttest_cmp expect one &&\n'> <'\tgrep "new blank line at EOF" error\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'blank but not empty at EOF'>)}
        {
          (SQ <'\n'> <'\t{ echo a; echo b; echo c; } >one &&\n'> <'\tgit add one &&\n'> 
            <'\techo "   " >>one &&\n'> <'\tcat one >expect &&\n'> <'\tgit diff -- one >patch &&\n'> <'\n'> <'\tgit checkout one &&\n'> 
            <'\tgit apply --whitespace=warn patch 2>error &&\n'> <'\ttest_cmp expect one &&\n'> <'\tgrep "new blank line at EOF" error\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'applying beyond EOF requires one non-blank context line'>)}
        {
          (SQ <'\n'> <'\t{ echo; echo; echo; echo; } >one &&\n'> <'\tgit add one &&\n'> 
            <'\t{ echo b; } >>one &&\n'> <'\tgit diff -- one >patch &&\n'> <'\n'> <'\tgit checkout one &&\n'> <'\t{ echo a; echo; } >one &&\n'> 
            <'\tcp one expect &&\n'> <'\ttest_must_fail git apply --whitespace=fix patch &&\n'> <'\ttest_cmp one expect &&\n'> 
            <'\ttest_must_fail git apply --ignore-space-change --whitespace=fix patch &&\n'> <'\ttest_cmp one expect\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'tons of blanks at EOF should not apply'>)}
        {
          (SQ <'\n'> <'\tfor i in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16; do\n'> 
            <'\t\techo; echo; echo; echo;\n'> <'\tdone >one &&\n'> <'\tgit add one &&\n'> <'\techo a >>one &&\n'> <'\tgit diff -- one >patch &&\n'> 
            <'\n'> <'\t>one &&\n'> <'\ttest_must_fail git apply --whitespace=fix patch &&\n'> 
            <'\ttest_must_fail git apply --ignore-space-change --whitespace=fix patch\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'missing blank line at end with --whitespace=fix'>)}
        {
          (SQ <'\n'> <'\techo a >one &&\n'> <'\techo >>one &&\n'> <'\tgit add one &&\n'> 
            <'\techo b >>one &&\n'> <'\tcp one expect &&\n'> <'\tgit diff -- one >patch &&\n'> <'\techo a >one &&\n'> 
            <'\tcp one saved-one &&\n'> <'\ttest_must_fail git apply patch &&\n'> <'\tgit apply --whitespace=fix patch &&\n'> 
            <'\ttest_cmp one expect &&\n'> <'\tmv saved-one one &&\n'> <'\tgit apply --ignore-space-change --whitespace=fix patch &&\n'> 
            <'\ttest_cmp one expect\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'two missing blank lines at end with --whitespace=fix'>)}
        {
          (SQ <'\n'> <'\t{ echo a; echo; echo b; echo c; } >one &&\n'> <'\tcp one no-blank-lines &&\n'> 
            <'\t{ echo; echo; } >>one &&\n'> <'\tgit add one &&\n'> <'\techo d >>one &&\n'> <'\tcp one expect &&\n'> <'\techo >>one &&\n'> 
            <'\tgit diff -- one >patch &&\n'> <'\tcp no-blank-lines one &&\n'> <'\ttest_must_fail git apply patch &&\n'> 
            <'\tgit apply --whitespace=fix patch &&\n'> <'\ttest_cmp one expect &&\n'> <'\tmv no-blank-lines one &&\n'> 
            <'\ttest_must_fail git apply patch &&\n'> <'\tgit apply --ignore-space-change --whitespace=fix patch &&\n'> <'\ttest_cmp one expect\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'missing blank line at end, insert before end, --whitespace=fix'>)}
        {
          (SQ <'\n'> <'\t{ echo a; echo; } >one &&\n'> <'\tgit add one &&\n'> 
            <'\t{ echo b; echo a; echo; } >one &&\n'> <'\tcp one expect &&\n'> <'\tgit diff -- one >patch &&\n'> <'\techo a >one &&\n'> 
            <'\ttest_must_fail git apply patch &&\n'> <'\tgit apply --whitespace=fix patch &&\n'> <'\ttest_cmp one expect\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'shrink file with tons of missing blanks at end of file'>)}
        {
          (SQ <'\n'> <'\t{ echo a; echo b; echo c; } >one &&\n'> <'\tcp one no-blank-lines &&\n'> 
            <'\tfor i in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16; do\n'> <'\t\techo; echo; echo; echo;\n'> <'\tdone >>one &&\n'> <'\tgit add one &&\n'> <'\techo a >one &&\n'> 
            <'\tcp one expect &&\n'> <'\tgit diff -- one >patch &&\n'> <'\tcp no-blank-lines one &&\n'> 
            <'\ttest_must_fail git apply patch &&\n'> <'\tgit apply --whitespace=fix patch &&\n'> <'\ttest_cmp one expect &&\n'> 
            <'\tmv no-blank-lines one &&\n'> <'\tgit apply --ignore-space-change --whitespace=fix patch &&\n'> <'\ttest_cmp one expect\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'missing blanks at EOF must only match blank lines'>)}
        {
          (SQ <'\n'> <'\t{ echo a; echo b; } >one &&\n'> <'\tgit add one &&\n'> 
            <'\t{ echo c; echo d; } >>one &&\n'> <'\tgit diff -- one >patch &&\n'> <'\n'> <'\techo a >one &&\n'> 
            <'\ttest_must_fail git apply patch &&\n'> <'\ttest_must_fail git apply --whitespace=fix patch &&\n'> 
            <'\ttest_must_fail git apply --ignore-space-change --whitespace=fix patch\n'>
          )
        }
      ]
      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:{<one>})
        (Redir
          op: <Id.Redir_DLess '<<'>
          loc: (redir_loc.Fd fd:0)
          arg: 
            (redir_param.HereDoc
              here_begin: {<EOF>}
              here_end_tok: <Id.Undefined_Tok ''>
              stdin_parts: [<'a\n'> <'b\n'> <'c\n'> <'\t\t      Z\n'>]
            )
        )
      ]
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'missing blank line should match context line with spaces'>)}
        {
          (SQ <'\n'> <'\tgit add one &&\n'> <'\techo d >>one &&\n'> <'\tgit diff -- one >patch &&\n'> 
            <'\t{ echo a; echo b; echo c; } >one &&\n'> <'\tcp one expect &&\n'> <'\t{ echo; echo d; } >>expect &&\n'> <'\tgit add one &&\n'> <'\n'> 
            <'\tgit apply --whitespace=fix patch &&\n'> <'\ttest_cmp one expect\n'>
          )
        }
      ]
      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:{<one>})
        (Redir
          op: <Id.Redir_DLess '<<'>
          loc: (redir_loc.Fd fd:0)
          arg: 
            (redir_param.HereDoc
              here_begin: {<EOF>}
              here_end_tok: <Id.Undefined_Tok ''>
              stdin_parts: [<'a\n'> <'b\n'> <'c\n'> <'\t\t      Z\n'>]
            )
        )
      ]
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'same, but with the --ignore-space-option'>)}
        {
          (SQ <'\n'> <'\tgit add one &&\n'> <'\techo d >>one &&\n'> <'\tcp one expect &&\n'> 
            <'\tgit diff -- one >patch &&\n'> <'\t{ echo a; echo b; echo c; } >one &&\n'> <'\tgit add one &&\n'> <'\n'> 
            <'\tgit checkout-index -f one &&\n'> <'\tgit apply --ignore-space-change --whitespace=fix patch &&\n'> <'\ttest_cmp one expect\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'same, but with CR-LF line endings && cr-at-eol set'>)}
        {
          (SQ <'\n'> <'\tgit config core.whitespace cr-at-eol &&\n'> <'\tprintf "a\\r\\n" >one &&\n'> 
            <'\tprintf "b\\r\\n" >>one &&\n'> <'\tprintf "c\\r\\n" >>one &&\n'> <'\tcp one save-one &&\n'> 
            <'\tprintf "                 \\r\\n" >>one &&\n'> <'\tgit add one &&\n'> <'\tprintf "d\\r\\n" >>one &&\n'> <'\tcp one expect &&\n'> 
            <'\tgit diff -- one >patch &&\n'> <'\tmv save-one one &&\n'> <'\n'> <'\tgit apply --ignore-space-change --whitespace=fix patch &&\n'> 
            <'\ttest_cmp one expect\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'same, but with CR-LF line endings && cr-at-eol unset'>)}
        {
          (SQ <'\n'> <'\tgit config --unset core.whitespace &&\n'> <'\tprintf "a\\r\\n" >one &&\n'> 
            <'\tprintf "b\\r\\n" >>one &&\n'> <'\tprintf "c\\r\\n" >>one &&\n'> <'\tcp one save-one &&\n'> 
            <'\tprintf "                 \\r\\n" >>one &&\n'> <'\tgit add one &&\n'> <'\tcp one expect &&\n'> <'\tprintf "d\\r\\n" >>one &&\n'> 
            <'\tgit diff -- one >patch &&\n'> <'\tmv save-one one &&\n'> <'\techo d >>expect &&\n'> <'\n'> 
            <'\tgit apply --ignore-space-change --whitespace=fix patch &&\n'> <'\ttest_cmp one expect\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'whitespace=fix to expand'>)}
        {
          (SQ <'\n'> <'\tqz_to_tab_space >preimage <<-\\EOF &&\n'> <'\tQQa\n'> <'\tQQb\n'> <'\tQQc\n'> 
            <'\tZZZZZZZZZZZZZZZZd\n'> <'\tQQe\n'> <'\tQQf\n'> <'\tQQg\n'> <'\tEOF\n'> <'\tqz_to_tab_space >patch <<-\\EOF &&\n'> 
            <'\tdiff --git a/preimage b/preimage\n'> <'\t--- a/preimage\n'> <'\t+++ b/preimage\n'> <'\t@@ -1,7 +1,6 @@\n'> <'\t QQa\n'> <'\t QQb\n'> 
            <'\t QQc\n'> <'\t-QQd\n'> <'\t QQe\n'> <'\t QQf\n'> <'\t QQg\n'> <'\tEOF\n'> 
            <'\tgit -c core.whitespace=tab-in-indent apply --whitespace=fix patch\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'whitespace check skipped for excluded paths'>)}
        {
          (SQ <'\n'> <'\tgit config core.whitespace blank-at-eol &&\n'> <'\t>used &&\n'> 
            <'\t>unused &&\n'> <'\tgit add used unused &&\n'> <'\techo "used" >used &&\n'> <'\techo "unused " >unused &&\n'> 
            <'\tgit diff-files -p used unused >patch &&\n'> <'\tgit apply --include=used --stat --whitespace=error <patch\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_done>
      more_env: []
      words: [{<test_done>}]
      redirects: []
      do_fork: T
    )
  ]
)