(command.CommandList
  children: [
    (command.Simple
      blame_tok: <Id.Lit_Colon ':'>
      more_env: []
      words: [
        {<Id.Lit_Colon ':'>}
        {
          (BracedVarSub
            left: <Id.Left_DollarBrace '${'>
            token: <Id.VSub_Name TEST_SH>
            var_name: TEST_SH
            suffix_op: (suffix_op.Unary op:<Id.VTest_ColonEquals _> arg_word:{(DQ <'/bin/sh'>)})
            right: <Id.Right_DollarBrace '}'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.ShAssignment
      left: <Id.Lit_VarLike 'nl='>
      pairs: [
        (AssignPair
          left: <Id.Lit_VarLike 'nl='>
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'nl='> name:nl)
          op: assign_op.Equal
          rhs: {(SQ <'\n'>)}
        )
      ]
      redirects: []
    )
    (command.ShFunction
      name_tok: <check>
      name: check
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.ShAssignment
              left: <Id.Lit_VarLike 'TEST='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'TEST='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'TEST='> name:TEST)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (word_part.ArithSub
                        left: <Id.Left_DollarDParen '$(('>
                        anode: 
                          (arith_expr.Binary
                            op_id: Id.Arith_Plus
                            left: {(${ Id.VSub_Name TEST)}
                            right: {<Id.Lit_Digits 1>}
                          )
                        right: <Id.Right_DollarDParen _>
                      )
                    }
                )
              ]
              redirects: []
            )
            (command.Case
              case_kw: <Id.KW_Case case>
              to_match: (case_arg.Word w:{(DQ ($ Id.VSub_Pound '#'))})
              arms_start: <Id.KW_In in>
              arms: [
                (CaseArm
                  left: <Id.Op_LParen _>
                  pattern: (pat.Words words:[{<2>}])
                  middle: <Id.Right_CasePat _>
                  action: []
                  right: <Id.Op_DSemi _>
                )
                (CaseArm
                  left: <Id.Op_LParen _>
                  pattern: (pat.Words words:[{<Id.Lit_Star '*'>}])
                  middle: <Id.Right_CasePat _>
                  action: [
                    (command.Simple
                      blame_tok: <atf_fail>
                      more_env: []
                      words: [
                        {<atf_fail>}
                        {
                          (DQ <'Internal test error, '> ($ Id.VSub_Pound '#') <' args to check test '> 
                            (${ Id.VSub_Name TEST)
                          )
                        }
                      ]
                      redirects: []
                      do_fork: T
                    )
                  ]
                  right: <Id.Op_DSemi _>
                )
              ]
              arms_end: <Id.KW_Esac esac>
              redirects: []
            )
            (command.ShAssignment
              left: <Id.Lit_VarLike 'result='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'result='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'result='> name:result)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (CommandSub
                        left_token: <Id.Left_DollarParen '$('>
                        child: 
                          (command.Simple
                            blame_tok: <Id.Left_DollarBrace '${'>
                            more_env: []
                            words: [
                              {(${ Id.VSub_Name TEST_SH)}
                              {<-c>}
                              {(DQ <'unset x; '> ($ Id.VSub_Number 1))}
                            ]
                            redirects: []
                            do_fork: T
                          )
                        right: <Id.Eof_RParen _>
                      )
                    }
                )
              ]
              redirects: []
            )
            (command.ShAssignment
              left: <Id.Lit_VarLike 'STATUS='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'STATUS='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'STATUS='> name:STATUS)
                  op: assign_op.Equal
                  rhs: {(DQ ($ Id.VSub_QMark '?'))}
                )
              ]
              redirects: []
            )
            (command.ShAssignment
              left: <Id.Lit_VarLike 'oifs='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'oifs='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'oifs='> name:oifs)
                  op: assign_op.Equal
                  rhs: {(DQ ($ Id.VSub_DollarName IFS))}
                )
              ]
              redirects: []
            )
            (command.ShAssignment
              left: <Id.Lit_VarLike 'IFS='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'IFS='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'IFS='> name:IFS)
                  op: assign_op.Equal
                  rhs: {(DQ ($ Id.VSub_DollarName nl))}
                )
              ]
              redirects: []
            )
            (command.ShAssignment
              left: <Id.Lit_VarLike 'result='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'result='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'result='> name:result)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (DQ 
                        (CommandSub
                          left_token: <Id.Left_DollarParen '$('>
                          child: 
                            (command.Simple
                              blame_tok: <echo>
                              more_env: []
                              words: [{<echo>} {($ Id.VSub_DollarName result)}]
                              redirects: []
                              do_fork: T
                            )
                          right: <Id.Eof_RParen _>
                        )
                      )
                    }
                )
              ]
              redirects: []
            )
            (command.ShAssignment
              left: <Id.Lit_VarLike 'IFS='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'IFS='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'IFS='> name:IFS)
                  op: assign_op.Equal
                  rhs: {(DQ ($ Id.VSub_DollarName oifs))}
                )
              ]
              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.Lit_QMark '?'>
                  pattern: 
                    (pat.Words
                      words: [
                        {<Id.Lit_QMark '?'> <Id.Lit_QMark '?'> <Id.Lit_QMark '?'> <Id.Lit_QMark '?'> 
                          <Id.Lit_QMark '?'> <Id.Lit_QMark '?'> <Id.Lit_QMark '?'> <Id.Lit_QMark '?'> <Id.Lit_QMark '?'> <Id.Lit_QMark '?'> 
                          <Id.Lit_QMark '?'> <Id.Lit_QMark '?'> <Id.Lit_QMark '?'> <Id.Lit_QMark '?'> <Id.Lit_QMark '?'> <Id.Lit_QMark '?'> 
                          <Id.Lit_Star '*'>
                        }
                      ]
                    )
                  middle: <Id.Right_CasePat _>
                  action: [
                    (command.Simple
                      blame_tok: <set>
                      more_env: []
                      words: [
                        {<set>}
                        {<-->}
                        {
                          (DQ 
                            (CommandSub
                              left_token: <Id.Left_DollarParen '$('>
                              child: 
                                (command.Simple
                                  blame_tok: <expr>
                                  more_env: []
                                  words: [
                                    {<expr>}
                                    {(DQ ($ Id.VSub_Number 1))}
                                    {<Id.Lit_Colon ':'>}
                                    {(SQ <'\\(............\\).*'>)}
                                  ]
                                  redirects: []
                                  do_fork: T
                                )
                              right: <Id.Eof_RParen _>
                            ) <...>
                          )
                        }
                        {(DQ ($ Id.VSub_Number 2))}
                      ]
                      redirects: []
                      do_fork: T
                    )
                  ]
                  right: <Id.Op_DSemi _>
                )
              ]
              arms_end: <Id.KW_Esac esac>
              redirects: []
            )
            (command.If
              if_kw: <Id.KW_If if>
              arms: [
                (IfArm
                  keyword: <Id.KW_If if>
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Simple
                          blame_tok: <Id.Lit_LBracket '['>
                          more_env: []
                          words: [
                            {<Id.Lit_LBracket '['>}
                            {(DQ ($ Id.VSub_Number 2))}
                            {<Id.KW_Bang '!'> <Id.Lit_Equals '='>}
                            {(DQ ($ Id.VSub_DollarName result))}
                            {<Id.Lit_RBracket ']'>}
                          ]
                          redirects: []
                          do_fork: T
                        )
                      ]
                    )
                  then_kw: <Id.KW_Then then>
                  action: [
                    (command.If
                      if_kw: <Id.KW_If if>
                      arms: [
                        (IfArm
                          keyword: <Id.KW_If if>
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Simple
                                  blame_tok: <Id.Lit_LBracket '['>
                                  more_env: []
                                  words: [
                                    {<Id.Lit_LBracket '['>}
                                    {(DQ (${ Id.VSub_Name STATUS))}
                                    {<Id.Lit_Equals '='>}
                                    {(DQ <0>)}
                                    {<Id.Lit_RBracket ']'>}
                                  ]
                                  redirects: []
                                  do_fork: T
                                )
                              ]
                            )
                          then_kw: <Id.KW_Then then>
                          action: [
                            (command.Simple
                              blame_tok: <atf_fail>
                              more_env: []
                              words: [
                                {<atf_fail>}
                                {
                                  (DQ <'Test '> (${ Id.VSub_Name TEST) <' \''> ($ Id.VSub_Number 1) 
                                    <'\': expected ['> ($ Id.VSub_Number 2) <'], found ['> ($ Id.VSub_DollarName result) <']'>
                                  )
                                }
                              ]
                              redirects: []
                              do_fork: T
                            )
                          ]
                          spids: [331 350]
                        )
                      ]
                      else_kw: <Id.KW_Else else>
                      else_action: [
                        (command.Simple
                          blame_tok: <atf_fail>
                          more_env: []
                          words: [
                            {<atf_fail>}
                            {
                              (DQ <'TEST '> (${ Id.VSub_Name TEST) <' \''> ($ Id.VSub_Number 1) 
                                <'\' failed ('> ($ Id.VSub_DollarName STATUS) <'): expected ['> ($ Id.VSub_Number 2) <'], found ['> 
                                ($ Id.VSub_DollarName result) <']'>
                              )
                            }
                          ]
                          redirects: []
                          do_fork: T
                        )
                      ]
                      fi_kw: <Id.KW_Fi fi>
                      redirects: []
                    )
                  ]
                  spids: [310 328]
                )
                (IfArm
                  keyword: <Id.KW_Elif elif>
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Simple
                          blame_tok: <Id.Lit_LBracket '['>
                          more_env: []
                          words: [
                            {<Id.Lit_LBracket '['>}
                            {(DQ (${ Id.VSub_Name STATUS))}
                            {<Id.KW_Bang '!'> <Id.Lit_Equals '='>}
                            {<0>}
                            {<Id.Lit_RBracket ']'>}
                          ]
                          redirects: []
                          do_fork: T
                        )
                      ]
                    )
                  then_kw: <Id.KW_Then then>
                  action: [
                    (command.Simple
                      blame_tok: <atf_fail>
                      more_env: []
                      words: [
                        {<atf_fail>}
                        {
                          (DQ <'TEST '> (${ Id.VSub_Name TEST) <' \''> ($ Id.VSub_Number 1) 
                            <'\' failed ('> ($ Id.VSub_DollarName STATUS) <')'>
                          )
                        }
                      ]
                      redirects: []
                      do_fork: T
                    )
                  ]
                  spids: [397 415]
                )
              ]
              else_action: []
              fi_kw: <Id.KW_Fi fi>
              redirects: []
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.Simple
      blame_tok: <atf_test_case>
      more_env: []
      words: [{<atf_test_case>} {<Id.KW_For for>}]
      redirects: []
      do_fork: T
    )
    (command.ShFunction
      name_tok: <for_head>
      name: for_head
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.Simple
              blame_tok: <atf_set>
              more_env: []
              words: [{<atf_set>} {(DQ <descr>)} {(DQ <'Checks field splitting in for loops'>)}]
              redirects: []
              do_fork: T
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name_tok: <for_body>
      name: for_body
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.Simple
              blame_tok: <unset>
              more_env: []
              words: [{<unset>} {<x>}]
              redirects: []
              do_fork: T
            )
            (command.ShAssignment
              left: <Id.Lit_VarLike 'TEST='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'TEST='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'TEST='> name:TEST)
                  op: assign_op.Equal
                  rhs: {<0>}
                )
              ]
              redirects: []
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [{<check>} {(SQ <'for f in $x; do echo x${f}y; done'>)} {(SQ )}]
              redirects: []
              do_fork: T
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.Simple
      blame_tok: <atf_test_case>
      more_env: []
      words: [{<atf_test_case>} {<default_val>}]
      redirects: []
      do_fork: T
    )
    (command.ShFunction
      name_tok: <default_val_head>
      name: default_val_head
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.Simple
              blame_tok: <atf_set>
              more_env: []
              words: [
                {<atf_set>}
                {(DQ <descr>)}
                {(DQ <'Checks field splitting in variable default values'>)}
              ]
              redirects: []
              do_fork: T
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name_tok: <default_val_body>
      name: default_val_body
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.ShAssignment
              left: <Id.Lit_VarLike 'TEST='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'TEST='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'TEST='> name:TEST)
                  op: assign_op.Equal
                  rhs: {<0>}
                )
              ]
              redirects: []
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [{<check>} {(SQ <'set -- ${x-a b c};   echo $#'>)} {<3>}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [{<check>} {(SQ <'set -- ${x-"a b" c}; echo $#'>)} {<2>}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [{<check>} {(SQ <'set -- ${x-a "b c"}; echo $#'>)} {<2>}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [{<check>} {(SQ <'set -- ${x-"a b c"}; echo $#'>)} {<1>}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [
                {<check>}
                {
                  (DQ <'set -- '> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'> ch:'$') 
                    <'{x-\'a b\' c}; echo '> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'> ch:'$') <'#'>
                  )
                }
                {<2>}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [
                {<check>}
                {
                  (DQ <'set -- '> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'> ch:'$') 
                    <'{x-a \'b c\'}; echo '> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'> ch:'$') <'#'>
                  )
                }
                {<2>}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [
                {<check>}
                {
                  (DQ <'set -- '> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'> ch:'$') 
                    <'{x-\'a b c\'}; echo '> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'> ch:'$') <'#'>
                  )
                }
                {<1>}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [{<check>} {(SQ <'set -- ${x-a\\ b c};  echo $#'>)} {<2>}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [{<check>} {(SQ <'set -- ${x-a b\\ c};  echo $#'>)} {<2>}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [{<check>} {(SQ <'set -- ${x-a\\ b\\ c}; echo $#'>)} {<1>}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [{<check>} {(SQ <'set -- ${x};        echo $#'>)} {<0>}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [{<check>} {(SQ <'set -- ${x-};       echo $#'>)} {<0>}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [{<check>} {(SQ <'set -- ${x-""};     echo $#'>)} {<1>}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [{<check>} {(SQ <'set -- ""${x};      echo $#'>)} {<1>}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [{<check>} {(SQ <'set -- ""${x-};     echo $#'>)} {<1>}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [{<check>} {(SQ <'set -- ""${x-""};   echo $#'>)} {<1>}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [{<check>} {(SQ <'set -- ${x}"";      echo $#'>)} {<1>}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [{<check>} {(SQ <'set -- ${x-}"";     echo $#'>)} {<1>}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [{<check>} {(SQ <'set -- ${x-""}"";   echo $#'>)} {<1>}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [{<check>} {(SQ <'set -- ""${x}"";    echo $#'>)} {<1>}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [{<check>} {(SQ <'set -- ""${x-}"";   echo $#'>)} {<1>}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [{<check>} {(SQ <'set -- ""${x-""}""; echo $#'>)} {<1>}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [
                {<check>}
                {(SQ <'for i in ${x-a b c};            do echo "z${i}z"; done'>)}
                {(SQ <'zaz zbz zcz'>)}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [
                {<check>}
                {(SQ <'for i in ${x-"a b" c};          do echo "z${i}z"; done'>)}
                {(SQ <'za bz zcz'>)}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [
                {<check>}
                {(SQ <'for i in ${x-"a ${x-b c}" d};   do echo "z${i}z"; done'>)}
                {(SQ <'za b cz zdz'>)}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [
                {<check>}
                {(SQ <'for i in ${x-a ${x-b c} d};     do echo "z${i}z"; done'>)}
                {(SQ <'zaz zbz zcz zdz'>)}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [
                {<check>}
                {(SQ <'for i in ${x-"a ${x-"b c"}" d}; do echo "z${i}z"; done'>)}
                {(SQ <'za b cz zdz'>)}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [
                {<check>}
                {(SQ <'for i in ${x-a ${x-"b c"} d};   do echo "z${i}z"; done'>)}
                {(SQ <'zaz zb cz zdz'>)}
              ]
              redirects: []
              do_fork: T
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.Simple
      blame_tok: <atf_test_case>
      more_env: []
      words: [{<atf_test_case>} {<replacement_val>}]
      redirects: []
      do_fork: T
    )
    (command.ShFunction
      name_tok: <replacement_val_head>
      name: replacement_val_head
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.Simple
              blame_tok: <atf_set>
              more_env: []
              words: [
                {<atf_set>}
                {(DQ <descr>)}
                {(DQ <'Checks field splitting in variable replacement values'>)}
              ]
              redirects: []
              do_fork: T
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name_tok: <replacement_val_body>
      name: replacement_val_body
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.ShAssignment
              left: <Id.Lit_VarLike 'TEST='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'TEST='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'TEST='> name:TEST)
                  op: assign_op.Equal
                  rhs: {<0>}
                )
              ]
              redirects: []
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [{<check>} {(SQ <'x=BOGUS; set -- ${x+a b c};   echo $#'>)} {<3>}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [{<check>} {(SQ <'x=BOGUS; set -- ${x+"a b" c}; echo $#'>)} {<2>}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [{<check>} {(SQ <'x=BOGUS; set -- ${x+a "b c"}; echo $#'>)} {<2>}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [{<check>} {(SQ <'x=BOGUS; set -- ${x+"a b c"}; echo $#'>)} {<1>}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [
                {<check>}
                {
                  (DQ <'x=BOGUS; set -- '> 
                    (word_part.EscapedLiteral
                      token: <Id.Lit_EscapedChar '\\$'>
                      ch: '$'
                    ) <'{x+\'a b\' c}; echo '> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'> ch:'$') <'#'>
                  )
                }
                {<2>}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [
                {<check>}
                {
                  (DQ <'x=BOGUS; set -- '> 
                    (word_part.EscapedLiteral
                      token: <Id.Lit_EscapedChar '\\$'>
                      ch: '$'
                    ) <'{x+a \'b c\'}; echo '> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'> ch:'$') <'#'>
                  )
                }
                {<2>}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [
                {<check>}
                {
                  (DQ <'x=BOGUS; set -- '> 
                    (word_part.EscapedLiteral
                      token: <Id.Lit_EscapedChar '\\$'>
                      ch: '$'
                    ) <'{x+\'a b c\'}; echo '> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'> ch:'$') <'#'>
                  )
                }
                {<1>}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [{<check>} {(SQ <'x=BOGUS; set -- ${x+a\\ b c};  echo $#'>)} {<2>}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [{<check>} {(SQ <'x=BOGUS; set -- ${x+a b\\ c};  echo $#'>)} {<2>}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [{<check>} {(SQ <'x=BOGUS; set -- ${x+a\\ b\\ c}; echo $#'>)} {<1>}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [{<check>} {(SQ <'x=BOGUS; set -- ${x+};       echo $#'>)} {<0>}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [{<check>} {(SQ <'x=BOGUS; set -- ${x+""};     echo $#'>)} {<1>}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [{<check>} {(SQ <'x=BOGUS; set -- ""${x+};     echo $#'>)} {<1>}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [{<check>} {(SQ <'x=BOGUS; set -- ""${x+""};   echo $#'>)} {<1>}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [{<check>} {(SQ <'x=BOGUS; set -- ${x+}"";     echo $#'>)} {<1>}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [{<check>} {(SQ <'x=BOGUS; set -- ${x+""}"";   echo $#'>)} {<1>}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [{<check>} {(SQ <'x=BOGUS; set -- ""${x+}"";   echo $#'>)} {<1>}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [{<check>} {(SQ <'x=BOGUS; set -- ""${x+""}""; echo $#'>)} {<1>}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [{<check>} {(SQ <'x=BOGUS; set -- ${x+};       echo X$1'>)} {<X>}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [{<check>} {(SQ <'x=BOGUS; set -- ${x+""};     echo X$1'>)} {<X>}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [{<check>} {(SQ <'x=BOGUS; set -- ""${x+};     echo X$1'>)} {<X>}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [{<check>} {(SQ <'x=BOGUS; set -- ""${x+""};   echo X$1'>)} {<X>}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [{<check>} {(SQ <'x=BOGUS; set -- ${x+}"";     echo X$1'>)} {<X>}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [{<check>} {(SQ <'x=BOGUS; set -- ${x+""}"";   echo X$1'>)} {<X>}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [{<check>} {(SQ <'x=BOGUS; set -- ""${x+}"";   echo X$1'>)} {<X>}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [{<check>} {(SQ <'x=BOGUS; set -- ""${x+""}""; echo X$1'>)} {<X>}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [
                {<check>}
                {(SQ <'x=BOGUS; set -- ${x+};       echo X${1-:}X'>)}
                {<X> <Id.Lit_Colon ':'> <X>}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [{<check>} {(SQ <'x=BOGUS; set -- ${x+""};     echo X${1-:}X'>)} {<XX>}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [{<check>} {(SQ <'x=BOGUS; set -- ""${x+};     echo X${1-:}X'>)} {<XX>}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [{<check>} {(SQ <'x=BOGUS; set -- ""${x+""};   echo X${1-:}X'>)} {<XX>}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [{<check>} {(SQ <'x=BOGUS; set -- ${x+}"";     echo X${1-:}X'>)} {<XX>}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [{<check>} {(SQ <'x=BOGUS; set -- ${x+""}"";   echo X${1-:}X'>)} {<XX>}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [{<check>} {(SQ <'x=BOGUS; set -- ""${x+}"";   echo X${1-:}X'>)} {<XX>}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [{<check>} {(SQ <'x=BOGUS; set -- ""${x+""}""; echo X${1-:}X'>)} {<XX>}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [
                {<check>}
                {(SQ <'x=BOGUS; for i in ${x+a b c};            do echo "z${i}z"; done'>)}
                {(SQ <'zaz zbz zcz'>)}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [
                {<check>}
                {(SQ <'x=BOGUS; for i in ${x+"a b" c};          do echo "z${i}z"; done'>)}
                {(SQ <'za bz zcz'>)}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [
                {<check>}
                {(SQ <'x=BOGUS; for i in ${x+"a ${x+b c}" d};   do echo "z${i}z"; done'>)}
                {(SQ <'za b cz zdz'>)}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [
                {<check>}
                {(SQ <'x=BOGUS; for i in ${x+"a ${x+"b c"}" d}; do echo "z${i}z"; done'>)}
                {(SQ <'za b cz zdz'>)}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [
                {<check>}
                {(SQ <'x=BOGUS; for i in ${x+a ${x+"b c"} d};   do echo "z${i}z"; done'>)}
                {(SQ <'zaz zb cz zdz'>)}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [
                {<check>}
                {(SQ <'x=BOGUS; for i in ${x+a ${x+b c} d};     do echo "z${i}z"; done'>)}
                {(SQ <'zaz zbz zcz zdz'>)}
              ]
              redirects: []
              do_fork: T
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.Simple
      blame_tok: <atf_test_case>
      more_env: []
      words: [{<atf_test_case>} {<ifs_alpha>}]
      redirects: []
      do_fork: T
    )
    (command.ShFunction
      name_tok: <ifs_alpha_head>
      name: ifs_alpha_head
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.Simple
              blame_tok: <atf_set>
              more_env: []
              words: [
                {<atf_set>}
                {(DQ <descr>)}
                {(DQ <'Checks that field splitting works with alphabetic'>)}
                {(DQ <characters>)}
              ]
              redirects: []
              do_fork: T
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name_tok: <ifs_alpha_body>
      name: ifs_alpha_body
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.Simple
              blame_tok: <unset>
              more_env: []
              words: [{<unset>} {<x>}]
              redirects: []
              do_fork: T
            )
            (command.ShAssignment
              left: <Id.Lit_VarLike 'TEST='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'TEST='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'TEST='> name:TEST)
                  op: assign_op.Equal
                  rhs: {<0>}
                )
              ]
              redirects: []
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [{<check>} {(SQ <'IFS=q; set ${x-aqbqc}; echo $#'>)} {<3>}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [
                {<check>}
                {(SQ <'IFS=q; for i in ${x-aqbqc};            do echo "z${i}z"; done'>)}
                {(SQ <'zaz zbz zcz'>)}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [
                {<check>}
                {(SQ <'IFS=q; for i in ${x-"aqb"qc};          do echo "z${i}z"; done'>)}
                {(SQ <'zaqbz zcz'>)}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [
                {<check>}
                {(SQ <'IFS=q; for i in ${x-"aq${x-bqc}"qd};   do echo "z${i}z"; done'>)}
                {(SQ <'zaqbqcz zdz'>)}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [
                {<check>}
                {(SQ <'IFS=q; for i in ${x-"aq${x-"bqc"}"qd}; do echo "z${i}z"; done'>)}
                {(SQ <'zaqbqcz zdz'>)}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [
                {<check>}
                {(SQ <'IFS=q; for i in ${x-aq${x-"bqc"}qd};  do echo "z${i}z"; done'>)}
                {(SQ <'zaz zbqcz zdz'>)}
              ]
              redirects: []
              do_fork: T
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.Simple
      blame_tok: <atf_test_case>
      more_env: []
      words: [{<atf_test_case>} {<quote>}]
      redirects: []
      do_fork: T
    )
    (command.ShFunction
      name_tok: <quote_head>
      name: quote_head
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.Simple
              blame_tok: <atf_set>
              more_env: []
              words: [
                {<atf_set>}
                {(DQ <descr>)}
                {(DQ <'Checks that field splitting works with multi-word'>)}
                {(DQ <fields>)}
              ]
              redirects: []
              do_fork: T
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name_tok: <quote_body>
      name: quote_body
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.Simple
              blame_tok: <unset>
              more_env: []
              words: [{<unset>} {<x>}]
              redirects: []
              do_fork: T
            )
            (command.ShAssignment
              left: <Id.Lit_VarLike 'TEST='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'TEST='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'TEST='> name:TEST)
                  op: assign_op.Equal
                  rhs: {<0>}
                )
              ]
              redirects: []
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [{<check>} {(SQ <'set "${x-a b c}";   echo $#'>)} {<1>}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [{<check>} {(SQ <'set "${x-"a b" c}"; echo $1'>)} {(SQ <'a b c'>)}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [
                {<check>}
                {(SQ <'for i in "${x-a b c}"; do echo "z${i}z"; done'>)}
                {(SQ <'za b cz'>)}
              ]
              redirects: []
              do_fork: T
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.Simple
      blame_tok: <atf_test_case>
      more_env: []
      words: [{<atf_test_case>} {<dollar_at>}]
      redirects: []
      do_fork: T
    )
    (command.ShFunction
      name_tok: <dollar_at_head>
      name: dollar_at_head
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.Simple
              blame_tok: <atf_set>
              more_env: []
              words: [
                {<atf_set>}
                {(DQ <descr>)}
                {(DQ <'Checks that field splitting works when expanding'>)}
                {(DQ (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'> ch:'$') <'@'>)}
              ]
              redirects: []
              do_fork: T
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name_tok: <dollar_at_body>
      name: dollar_at_body
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.Simple
              blame_tok: <unset>
              more_env: []
              words: [{<unset>} {<x>}]
              redirects: []
              do_fork: T
            )
            (command.ShAssignment
              left: <Id.Lit_VarLike 'TEST='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'TEST='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'TEST='> name:TEST)
                  op: assign_op.Equal
                  rhs: {<0>}
                )
              ]
              redirects: []
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [
                {<check>}
                {(SQ <'set --;        for i in x"$@"x;  do echo "z${i}z"; done'>)}
                {(SQ <zxxz>)}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [
                {<check>}
                {(SQ <'set a;         for i in x"$@"x;  do echo "z${i}z"; done'>)}
                {(SQ <zxaxz>)}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [
                {<check>}
                {(SQ <'set a b;       for i in x"$@"x;  do echo "z${i}z"; done'>)}
                {(SQ <'zxaz zbxz'>)}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [{<check>} {(SQ <'set --;        for i;            do echo "z${i}z"; done'>)} {(SQ )}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [{<check>} {(SQ <'set --;        for i in $@;      do echo "z${i}z"; done'>)} {(SQ )}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [{<check>} {(SQ <'set --;        for i in "$@";    do echo "z${i}z"; done'>)} {(SQ )}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [
                {<check>}
                {(SQ <'set --;        for i in ""$@;    do echo "z${i}z"; done'>)}
                {(SQ <zz>)}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [
                {<check>}
                {(SQ <'set --;        for i in $@"";    do echo "z${i}z"; done'>)}
                {(SQ <zz>)}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [
                {<check>}
                {(SQ <'set --;        for i in ""$@"";  do echo "z${i}z"; done'>)}
                {(SQ <zz>)}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [
                {<check>}
                {(SQ <'set --;        for i in """$@";  do echo "z${i}z"; done'>)}
                {(SQ <zz>)}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [
                {<check>}
                {(SQ <'set --;        for i in "$@""";  do echo "z${i}z"; done'>)}
                {(SQ <zz>)}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [
                {<check>}
                {(SQ <'set --;        for i in """$@""";do echo "z${i}z"; done'>)}
                {(SQ <zz>)}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [
                {<check>}
                {(SQ <'set "";        for i;            do echo "z${i}z"; done'>)}
                {(SQ <zz>)}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [
                {<check>}
                {(SQ <'set "";        for i in "$@";    do echo "z${i}z"; done'>)}
                {(SQ <zz>)}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [
                {<check>}
                {(SQ <'set "" "";     for i;            do echo "z${i}z"; done'>)}
                {(SQ <'zz zz'>)}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [
                {<check>}
                {(SQ <'set "" "";     for i in "$@";    do echo "z${i}z"; done'>)}
                {(SQ <'zz zz'>)}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [{<check>} {(SQ <'set "" "";     for i in $@;      do echo "z${i}z"; done'>)} {(SQ )}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [
                {<check>}
                {(SQ <'set "a b" c;   for i;            do echo "z${i}z"; done'>)}
                {(SQ <'za bz zcz'>)}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [
                {<check>}
                {(SQ <'set "a b" c;   for i in "$@";    do echo "z${i}z"; done'>)}
                {(SQ <'za bz zcz'>)}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [
                {<check>}
                {(SQ <'set "a b" c;   for i in $@;      do echo "z${i}z"; done'>)}
                {(SQ <'zaz zbz zcz'>)}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [
                {<check>}
                {(SQ <'set " a b " c; for i in "$@";    do echo "z${i}z"; done'>)}
                {(SQ <'z a b z zcz'>)}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [
                {<check>}
                {(SQ <'set a b c;     for i in "$@$@";  do echo "z${i}z"; done'>)}
                {(SQ <'zaz zbz zcaz zbz zcz'>)}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [
                {<check>}
                {(SQ <'set a b c;     for i in "$@""$@";do echo "z${i}z"; done'>)}
                {(SQ <'zaz zbz zcaz zbz zcz'>)}
              ]
              redirects: []
              do_fork: T
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.Simple
      blame_tok: <atf_test_case>
      more_env: []
      words: [{<atf_test_case>} {<ifs>}]
      redirects: []
      do_fork: T
    )
    (command.ShFunction
      name_tok: <ifs_head>
      name: ifs_head
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.Simple
              blame_tok: <atf_set>
              more_env: []
              words: [
                {<atf_set>}
                {(DQ <descr>)}
                {(DQ <'Checks that IFS correctly configures field'>)}
                {(DQ <'splitting behavior'>)}
              ]
              redirects: []
              do_fork: T
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name_tok: <ifs_body>
      name: ifs_body
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.Simple
              blame_tok: <unset>
              more_env: []
              words: [{<unset>} {<x>}]
              redirects: []
              do_fork: T
            )
            (command.ShAssignment
              left: <Id.Lit_VarLike 'TEST='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'TEST='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'TEST='> name:TEST)
                  op: assign_op.Equal
                  rhs: {<0>}
                )
              ]
              redirects: []
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [
                {<check>}
                {(SQ <'t="-- ";    IFS=" ";  set $t; IFS=":"; r="$*"; IFS=; echo $# $r'>)}
                {(SQ <0>)}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [
                {<check>}
                {(SQ <'t=" x";     IFS=" x"; set $t; IFS=":"; r="$*"; IFS=; echo $# $r'>)}
                {(SQ <1>)}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [
                {<check>}
                {(SQ <'t=" x ";    IFS=" x"; set $t; IFS=":"; r="$*"; IFS=; echo $# $r'>)}
                {(SQ <1>)}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [
                {<check>}
                {(SQ <'t=axb;      IFS="x";  set $t; IFS=":"; r="$*"; IFS=; echo $# $r'>)}
                {(SQ <'2 a:b'>)}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [
                {<check>}
                {(SQ <'t="a x b";  IFS="x";  set $t; IFS=":"; r="$*"; IFS=; echo $# $r'>)}
                {(SQ <'2 a : b'>)}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [
                {<check>}
                {(SQ <'t="a xx b"; IFS="x";  set $t; IFS=":"; r="$*"; IFS=; echo $# $r'>)}
                {(SQ <'3 a :: b'>)}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [
                {<check>}
                {(SQ <'t="a xx b"; IFS="x "; set $t; IFS=":"; r="$*"; IFS=; echo $# $r'>)}
                {(SQ <'3 a::b'>)}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [
                {<check>}
                {(SQ <'t="xax";  IFS="x";     set $t; IFS=":"; r="$*"; IFS=; echo $# $r'>)}
                {(SQ <'2 :a'>)}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [
                {<check>}
                {(SQ <'t="xax "; IFS="x ";   set $t; IFS=":"; r="$*"; IFS=; echo $# $r'>)}
                {(SQ <'2 :a'>)}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [
                {<check>}
                {(SQ <'IFS="x";             set axb; IFS=":"; r="$*"; IFS=; echo $# $r'>)}
                {(SQ <'1 axb'>)}
              ]
              redirects: []
              do_fork: T
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.Simple
      blame_tok: <atf_test_case>
      more_env: []
      words: [{<atf_test_case>} {<var_length>}]
      redirects: []
      do_fork: T
    )
    (command.ShFunction
      name_tok: <var_length_head>
      name: var_length_head
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.Simple
              blame_tok: <atf_set>
              more_env: []
              words: [
                {<atf_set>}
                {(DQ <descr>)}
                {(DQ <'Checks that field splitting works when expanding'>)}
                {(DQ <'a variable\'s length'>)}
              ]
              redirects: []
              do_fork: T
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name_tok: <var_length_body>
      name: var_length_body
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.ShAssignment
              left: <Id.Lit_VarLike 'TEST='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'TEST='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'TEST='> name:TEST)
                  op: assign_op.Equal
                  rhs: {<0>}
                )
              ]
              redirects: []
            )
            (command.ShAssignment
              left: <Id.Lit_VarLike 'long='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'long='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'long='> name:long)
                  op: assign_op.Equal
                  rhs: {<12345678123456781234567812345678>}
                )
              ]
              redirects: []
            )
            (command.ShAssignment
              left: <Id.Lit_VarLike 'long='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'long='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'long='> name:long)
                  op: assign_op.Equal
                  rhs: 
                    {($ Id.VSub_DollarName long) ($ Id.VSub_DollarName long) 
                      ($ Id.VSub_DollarName long) ($ Id.VSub_DollarName long)
                    }
                )
              ]
              redirects: []
            )
            (command.Simple
              blame_tok: <export>
              more_env: []
              words: [{<export>} {<long>}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [{<check>} {(SQ <'set -u; : ${long}; echo ${#long}'>)} {(SQ <128>)}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [
                {<check>}
                {(SQ <'echo ${#long}; IFS=2; echo ${#long}; set 1 ${#long};echo $#'>)}
                {(SQ <'128 1 8 3'>)}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [
                {<check>}
                {(SQ <'IFS=2; set ${x-${#long}};   IFS=" "; echo $* $#'>)}
                {(SQ <'1 8 2'>)}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <check>
              more_env: []
              words: [
                {<check>}
                {(SQ <'IFS=2; set ${x-"${#long}"}; IFS=" "; echo $* $#'>)}
                {(SQ <'128 1'>)}
              ]
              redirects: []
              do_fork: T
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name_tok: <atf_init_test_cases>
      name: atf_init_test_cases
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.Simple
              blame_tok: <atf_add_test_case>
              more_env: []
              words: [{<atf_add_test_case>} {<Id.KW_For for>}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <atf_add_test_case>
              more_env: []
              words: [{<atf_add_test_case>} {<default_val>}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <atf_add_test_case>
              more_env: []
              words: [{<atf_add_test_case>} {<replacement_val>}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <atf_add_test_case>
              more_env: []
              words: [{<atf_add_test_case>} {<ifs_alpha>}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <atf_add_test_case>
              more_env: []
              words: [{<atf_add_test_case>} {<quote>}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <atf_add_test_case>
              more_env: []
              words: [{<atf_add_test_case>} {<dollar_at>}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <atf_add_test_case>
              more_env: []
              words: [{<atf_add_test_case>} {<ifs>}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <atf_add_test_case>
              more_env: []
              words: [{<atf_add_test_case>} {<var_length>}]
              redirects: []
              do_fork: T
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
  ]
)