(command.CommandList
  children: [
    (command.Simple blame_tok:<set> more_env:[] words:[{<set>} {<-u>}] redirects:[] do_fork:T)
    (command.ShAssignment
      left: <Id.Lit_VarLike 'returnF='>
      pairs: [
        (AssignPair
          left: <Id.Lit_VarLike 'returnF='>
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'returnF='> name:returnF)
          op: assign_op.Equal
          rhs: 
            {
              (DQ 
                (BracedVarSub
                  left: <Id.Left_DollarBrace '${'>
                  token: <Id.VSub_Name TMPDIR>
                  var_name: TMPDIR
                  suffix_op: 
                    (suffix_op.Unary
                      op: <Id.VTest_ColonHyphen _>
                      arg_word: {<Id.Lit_Slash '/'> <tmp>}
                    )
                  right: <Id.Right_DollarBrace '}'>
                ) <'/return'>
              )
            }
        )
      ]
      redirects: []
    )
    (command.ShAssignment
      left: <Id.Lit_VarLike 'stdoutF='>
      pairs: [
        (AssignPair
          left: <Id.Lit_VarLike 'stdoutF='>
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'stdoutF='> name:stdoutF)
          op: assign_op.Equal
          rhs: 
            {
              (DQ 
                (BracedVarSub
                  left: <Id.Left_DollarBrace '${'>
                  token: <Id.VSub_Name TMPDIR>
                  var_name: TMPDIR
                  suffix_op: 
                    (suffix_op.Unary
                      op: <Id.VTest_ColonHyphen _>
                      arg_word: {<Id.Lit_Slash '/'> <tmp>}
                    )
                  right: <Id.Right_DollarBrace '}'>
                ) <'/STDOUT'>
              )
            }
        )
      ]
      redirects: []
    )
    (command.ShAssignment
      left: <Id.Lit_VarLike 'stderrF='>
      pairs: [
        (AssignPair
          left: <Id.Lit_VarLike 'stderrF='>
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'stderrF='> name:stderrF)
          op: assign_op.Equal
          rhs: 
            {
              (DQ 
                (BracedVarSub
                  left: <Id.Left_DollarBrace '${'>
                  token: <Id.VSub_Name TMPDIR>
                  var_name: TMPDIR
                  suffix_op: 
                    (suffix_op.Unary
                      op: <Id.VTest_ColonHyphen _>
                      arg_word: {<Id.Lit_Slash '/'> <tmp>}
                    )
                  right: <Id.Right_DollarBrace '}'>
                ) <'/STDERR'>
              )
            }
        )
      ]
      redirects: []
    )
    (command.Simple
      blame_tok: <.>
      more_env: []
      words: [{<.>} {<'./shflags_test_helpers'>}]
      redirects: []
      do_fork: T
    )
    (command.ShFunction
      name_tok: <testGetoptStandard>
      name: testGetoptStandard
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.Simple
              blame_tok: <_flags_getoptStandard>
              more_env: []
              words: [{<_flags_getoptStandard>} {(SQ <-b>)}]
              redirects: [
                (Redir
                  op: <Id.Redir_Great '>'>
                  loc: (redir_loc.Fd fd:1)
                  arg: {(DQ (${ Id.VSub_Name stdoutF))}
                )
                (Redir
                  op: <Id.Redir_Great '2>'>
                  loc: (redir_loc.Fd fd:2)
                  arg: {(DQ (${ Id.VSub_Name stderrF))}
                )
              ]
              do_fork: T
            )
            (command.ShAssignment
              left: <Id.Lit_VarLike 'rslt='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'rslt='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'rslt='> name:rslt)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_QMark '?')}
                )
              ]
              redirects: []
            )
            (command.Simple
              blame_tok: <assertTrue>
              more_env: []
              words: [{<assertTrue>} {(DQ <'didn\'t parse valid flag \'b\''>)} {(${ Id.VSub_Name rslt)}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <th_showOutput>
              more_env: []
              words: [
                {<th_showOutput>}
                {(${ Id.VSub_Name rslt)}
                {(DQ (${ Id.VSub_Name stdoutF))}
                {(DQ (${ Id.VSub_Name stderrF))}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <_flags_getoptStandard>
              more_env: []
              words: [{<_flags_getoptStandard>} {(SQ <-x>)}]
              redirects: [
                (Redir
                  op: <Id.Redir_Great '>'>
                  loc: (redir_loc.Fd fd:1)
                  arg: {(DQ (${ Id.VSub_Name stdoutF))}
                )
                (Redir
                  op: <Id.Redir_Great '2>'>
                  loc: (redir_loc.Fd fd:2)
                  arg: {(DQ (${ Id.VSub_Name stderrF))}
                )
              ]
              do_fork: T
            )
            (command.Simple
              blame_tok: <assertFalse>
              more_env: []
              words: [{<assertFalse>} {(DQ <'parsed invalid flag \'x\''>)} {($ Id.VSub_QMark '?')}]
              redirects: []
              do_fork: T
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name_tok: <testGetoptEnhanced>
      name: testGetoptEnhanced
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.AndOr
              children: [
                (command.Simple
                  blame_tok: <flags_getoptIsEnh>
                  more_env: []
                  words: [{<flags_getoptIsEnh>}]
                  redirects: []
                  do_fork: T
                )
                (command.ControlFlow keyword:<Id.ControlFlow_Return return>)
              ]
              ops: [<Id.Op_DPipe _>]
            )
            (command.Simple
              blame_tok: <_flags_getoptEnhanced>
              more_env: []
              words: [{<_flags_getoptEnhanced>} {(SQ <-b>)}]
              redirects: [
                (Redir
                  op: <Id.Redir_Great '>'>
                  loc: (redir_loc.Fd fd:1)
                  arg: {(DQ (${ Id.VSub_Name stdoutF))}
                )
                (Redir
                  op: <Id.Redir_Great '2>'>
                  loc: (redir_loc.Fd fd:2)
                  arg: {(DQ (${ Id.VSub_Name stderrF))}
                )
              ]
              do_fork: T
            )
            (command.Simple
              blame_tok: <assertTrue>
              more_env: []
              words: [{<assertTrue>} {(DQ <'didn\'t parse valid flag \'b\''>)} {($ Id.VSub_QMark '?')}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <_flags_getoptEnhanced>
              more_env: []
              words: [{<_flags_getoptEnhanced>} {(SQ <--bool>)}]
              redirects: [
                (Redir
                  op: <Id.Redir_Great '>'>
                  loc: (redir_loc.Fd fd:1)
                  arg: {(DQ (${ Id.VSub_Name stdoutF))}
                )
                (Redir
                  op: <Id.Redir_Great '2>'>
                  loc: (redir_loc.Fd fd:2)
                  arg: {(DQ (${ Id.VSub_Name stderrF))}
                )
              ]
              do_fork: T
            )
            (command.Simple
              blame_tok: <assertTrue>
              more_env: []
              words: [
                {<assertTrue>}
                {(DQ <'didn\'t parse valid flag \'bool\''>)}
                {($ Id.VSub_QMark '?')}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <_flags_getoptEnhanced>
              more_env: []
              words: [{<_flags_getoptEnhanced>} {(SQ <-x>)}]
              redirects: [
                (Redir
                  op: <Id.Redir_Great '>'>
                  loc: (redir_loc.Fd fd:1)
                  arg: {(DQ (${ Id.VSub_Name stdoutF))}
                )
                (Redir
                  op: <Id.Redir_Great '2>'>
                  loc: (redir_loc.Fd fd:2)
                  arg: {(DQ (${ Id.VSub_Name stderrF))}
                )
              ]
              do_fork: T
            )
            (command.Simple
              blame_tok: <assertFalse>
              more_env: []
              words: [{<assertFalse>} {(DQ <'parsed invalid flag \'x\''>)} {($ Id.VSub_QMark '?')}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <_flags_getoptEnhanced>
              more_env: []
              words: [{<_flags_getoptEnhanced>} {(SQ <--xyz>)}]
              redirects: [
                (Redir
                  op: <Id.Redir_Great '>'>
                  loc: (redir_loc.Fd fd:1)
                  arg: {(DQ (${ Id.VSub_Name stdoutF))}
                )
                (Redir
                  op: <Id.Redir_Great '2>'>
                  loc: (redir_loc.Fd fd:2)
                  arg: {(DQ (${ Id.VSub_Name stderrF))}
                )
              ]
              do_fork: T
            )
            (command.Simple
              blame_tok: <assertFalse>
              more_env: []
              words: [{<assertFalse>} {(DQ <'parsed invalid flag \'xyz\''>)} {($ Id.VSub_QMark '?')}]
              redirects: []
              do_fork: T
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name_tok: <testValidBoolsShort>
      name: testValidBoolsShort
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.Simple
              blame_tok: <FLAGS>
              more_env: []
              words: [{<FLAGS>} {<-b>}]
              redirects: [
                (Redir
                  op: <Id.Redir_Great '>'>
                  loc: (redir_loc.Fd fd:1)
                  arg: {(DQ (${ Id.VSub_Name stdoutF))}
                )
                (Redir
                  op: <Id.Redir_Great '2>'>
                  loc: (redir_loc.Fd fd:2)
                  arg: {(DQ (${ Id.VSub_Name stderrF))}
                )
              ]
              do_fork: T
            )
            (command.ShAssignment
              left: <Id.Lit_VarLike 'r3turn='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'r3turn='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'r3turn='> name:r3turn)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_QMark '?')}
                )
              ]
              redirects: []
            )
            (command.Simple
              blame_tok: <assertTrue>
              more_env: []
              words: [
                {<assertTrue>}
                {(DQ <'-b) FLAGS returned a non-zero result ('> (${ Id.VSub_Name r3turn) <')'>)}
                {(${ Id.VSub_Name r3turn)}
              ]
              redirects: []
              do_fork: T
            )
            (command.ShAssignment
              left: <Id.Lit_VarLike 'value='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'value='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'value='> name:value)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (BracedVarSub
                        left: <Id.Left_DollarBrace '${'>
                        token: <Id.VSub_Name FLAGS_bool>
                        var_name: FLAGS_bool
                        suffix_op: (suffix_op.Unary op:<Id.VTest_ColonHyphen _> arg_word:{})
                        right: <Id.Right_DollarBrace '}'>
                      )
                    }
                )
              ]
              redirects: []
            )
            (command.Simple
              blame_tok: <assertTrue>
              more_env: []
              words: [
                {<assertTrue>}
                {(DQ <'-b) boolean was not true ('> (${ Id.VSub_Name value) <').'>)}
                {(DQ (${ Id.VSub_Name value))}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <assertFalse>
              more_env: []
              words: [
                {<assertFalse>}
                {(SQ <'-b) expected no output to STDERR'>)}
                {(DQ <'[ -s \''> (${ Id.VSub_Name stderrF) <'\' ]'>)}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <test>
              more_env: []
              words: [
                {<test>}
                {(${ Id.VSub_Name r3turn)}
                {<-eq>}
                {(DQ (${ Id.VSub_Name FLAGS_TRUE))}
                {<-a>}
                {<Id.KW_Bang '!'>}
                {<-s>}
                {(DQ (${ Id.VSub_Name stderrF))}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <th_showOutput>
              more_env: []
              words: [
                {<th_showOutput>}
                {($ Id.VSub_QMark '?')}
                {(DQ (${ Id.VSub_Name stdoutF))}
                {(DQ (${ Id.VSub_Name stderrF))}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <DEFINE_boolean>
              more_env: []
              words: [{<DEFINE_boolean>} {<bool2>} {<true>} {(SQ <'2nd boolean'>)} {<B>}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <FLAGS>
              more_env: []
              words: [{<FLAGS>}]
              redirects: [
                (Redir
                  op: <Id.Redir_Great '>'>
                  loc: (redir_loc.Fd fd:1)
                  arg: {(DQ (${ Id.VSub_Name stdoutF))}
                )
                (Redir
                  op: <Id.Redir_Great '2>'>
                  loc: (redir_loc.Fd fd:2)
                  arg: {(DQ (${ Id.VSub_Name stderrF))}
                )
              ]
              do_fork: T
            )
            (command.ShAssignment
              left: <Id.Lit_VarLike 'r3turn='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'r3turn='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'r3turn='> name:r3turn)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_QMark '?')}
                )
              ]
              redirects: []
            )
            (command.Simple
              blame_tok: <assertTrue>
              more_env: []
              words: [
                {<assertTrue>}
                {(DQ <'-B) FLAGS returned a non-zero result ('> (${ Id.VSub_Name r3turn) <')'>)}
                {(${ Id.VSub_Name r3turn)}
              ]
              redirects: []
              do_fork: T
            )
            (command.ShAssignment
              left: <Id.Lit_VarLike 'value='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'value='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'value='> name:value)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (BracedVarSub
                        left: <Id.Left_DollarBrace '${'>
                        token: <Id.VSub_Name FLAGS_bool2>
                        var_name: FLAGS_bool2
                        suffix_op: (suffix_op.Unary op:<Id.VTest_ColonHyphen _> arg_word:{})
                        right: <Id.Right_DollarBrace '}'>
                      )
                    }
                )
              ]
              redirects: []
            )
            (command.Simple
              blame_tok: <assertTrue>
              more_env: []
              words: [
                {<assertTrue>}
                {(DQ <'-B) boolean was not true ('> (${ Id.VSub_Name value) <')'>)}
                {(DQ (${ Id.VSub_Name value))}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <assertFalse>
              more_env: []
              words: [
                {<assertFalse>}
                {(SQ <'-B) expected no output to STDERR'>)}
                {(DQ <'[ -s \''> (${ Id.VSub_Name stderrF) <'\' ]'>)}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <test>
              more_env: []
              words: [
                {<test>}
                {(${ Id.VSub_Name r3turn)}
                {<-eq>}
                {(DQ (${ Id.VSub_Name FLAGS_TRUE))}
                {<-a>}
                {<Id.KW_Bang '!'>}
                {<-s>}
                {(DQ (${ Id.VSub_Name stderrF))}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <th_showOutput>
              more_env: []
              words: [
                {<th_showOutput>}
                {($ Id.VSub_QMark '?')}
                {(DQ (${ Id.VSub_Name stdoutF))}
                {(DQ (${ Id.VSub_Name stderrF))}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <FLAGS>
              more_env: []
              words: [{<FLAGS>} {<-B>}]
              redirects: [
                (Redir
                  op: <Id.Redir_Great '>'>
                  loc: (redir_loc.Fd fd:1)
                  arg: {(DQ (${ Id.VSub_Name stdoutF))}
                )
                (Redir
                  op: <Id.Redir_Great '2>'>
                  loc: (redir_loc.Fd fd:2)
                  arg: {(DQ (${ Id.VSub_Name stderrF))}
                )
              ]
              do_fork: T
            )
            (command.ShAssignment
              left: <Id.Lit_VarLike 'r3turn='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'r3turn='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'r3turn='> name:r3turn)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_QMark '?')}
                )
              ]
              redirects: []
            )
            (command.Simple
              blame_tok: <assertTrue>
              more_env: []
              words: [
                {<assertTrue>}
                {(DQ <'-B) FLAGS returned a non-zero result ('> (${ Id.VSub_Name r3turn) <')'>)}
                {(${ Id.VSub_Name r3turn)}
              ]
              redirects: []
              do_fork: T
            )
            (command.ShAssignment
              left: <Id.Lit_VarLike 'value='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'value='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'value='> name:value)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (BracedVarSub
                        left: <Id.Left_DollarBrace '${'>
                        token: <Id.VSub_Name FLAGS_bool2>
                        var_name: FLAGS_bool2
                        suffix_op: (suffix_op.Unary op:<Id.VTest_ColonHyphen _> arg_word:{})
                        right: <Id.Right_DollarBrace '}'>
                      )
                    }
                )
              ]
              redirects: []
            )
            (command.Simple
              blame_tok: <assertFalse>
              more_env: []
              words: [
                {<assertFalse>}
                {(DQ <'-B) boolean was not false ('> (${ Id.VSub_Name value) <')'>)}
                {(DQ (${ Id.VSub_Name value))}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <assertFalse>
              more_env: []
              words: [
                {<assertFalse>}
                {(SQ <'-B) expected no output to STDERR'>)}
                {(DQ <'[ -s \''> (${ Id.VSub_Name stderrF) <'\' ]'>)}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <test>
              more_env: []
              words: [
                {<test>}
                {(${ Id.VSub_Name r3turn)}
                {<-eq>}
                {(DQ (${ Id.VSub_Name FLAGS_TRUE))}
                {<-a>}
                {<Id.KW_Bang '!'>}
                {<-s>}
                {(DQ (${ Id.VSub_Name stderrF))}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <th_showOutput>
              more_env: []
              words: [
                {<th_showOutput>}
                {($ Id.VSub_QMark '?')}
                {(DQ (${ Id.VSub_Name stdoutF))}
                {(DQ (${ Id.VSub_Name stderrF))}
              ]
              redirects: []
              do_fork: T
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name_tok: <testValidBoolsLong>
      name: testValidBoolsLong
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.AndOr
              children: [
                (command.Simple
                  blame_tok: <flags_getoptIsEnh>
                  more_env: []
                  words: [{<flags_getoptIsEnh>}]
                  redirects: []
                  do_fork: T
                )
                (command.ControlFlow keyword:<Id.ControlFlow_Return return>)
              ]
              ops: [<Id.Op_DPipe _>]
            )
            (command.Simple
              blame_tok: <FLAGS>
              more_env: []
              words: [{<FLAGS>} {<--nobool>}]
              redirects: [
                (Redir
                  op: <Id.Redir_Great '>'>
                  loc: (redir_loc.Fd fd:1)
                  arg: {(DQ (${ Id.VSub_Name stdoutF))}
                )
                (Redir
                  op: <Id.Redir_Great '2>'>
                  loc: (redir_loc.Fd fd:2)
                  arg: {(DQ (${ Id.VSub_Name stderrF))}
                )
              ]
              do_fork: T
            )
            (command.ShAssignment
              left: <Id.Lit_VarLike 'r3turn='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'r3turn='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'r3turn='> name:r3turn)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_QMark '?')}
                )
              ]
              redirects: []
            )
            (command.Simple
              blame_tok: <assertTrue>
              more_env: []
              words: [
                {<assertTrue>}
                {(DQ <'FLAGS returned a non-zero result ('> (${ Id.VSub_Name r3turn) <')'>)}
                {(${ Id.VSub_Name r3turn)}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <assertFalse>
              more_env: []
              words: [
                {<assertFalse>}
                {(SQ <'--noXX flag resulted in true value.'>)}
                {
                  (DQ 
                    (BracedVarSub
                      left: <Id.Left_DollarBrace '${'>
                      token: <Id.VSub_Name FLAGS_bool>
                      var_name: FLAGS_bool
                      suffix_op: (suffix_op.Unary op:<Id.VTest_ColonHyphen _> arg_word:(rhs_word__Empty))
                      right: <Id.Right_DollarBrace '}'>
                    )
                  )
                }
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <assertFalse>
              more_env: []
              words: [
                {<assertFalse>}
                {(SQ <'expected no output to STDERR'>)}
                {(DQ <'[ -s \''> (${ Id.VSub_Name stderrF) <'\' ]'>)}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <th_showOutput>
              more_env: []
              words: [
                {<th_showOutput>}
                {(${ Id.VSub_Name r3turn)}
                {(DQ (${ Id.VSub_Name stdoutF))}
                {(DQ (${ Id.VSub_Name stderrF))}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <FLAGS>
              more_env: []
              words: [{<FLAGS>} {<--bool>}]
              redirects: [
                (Redir
                  op: <Id.Redir_Great '>'>
                  loc: (redir_loc.Fd fd:1)
                  arg: {(DQ (${ Id.VSub_Name stdoutF))}
                )
                (Redir
                  op: <Id.Redir_Great '2>'>
                  loc: (redir_loc.Fd fd:2)
                  arg: {(DQ (${ Id.VSub_Name stderrF))}
                )
              ]
              do_fork: T
            )
            (command.ShAssignment
              left: <Id.Lit_VarLike 'r3turn='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'r3turn='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'r3turn='> name:r3turn)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_QMark '?')}
                )
              ]
              redirects: []
            )
            (command.Simple
              blame_tok: <assertTrue>
              more_env: []
              words: [
                {<assertTrue>}
                {(DQ <'FLAGS returned a non-zero result ('> (${ Id.VSub_Name r3turn) <')'>)}
                {(${ Id.VSub_Name r3turn)}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <assertTrue>
              more_env: []
              words: [
                {<assertTrue>}
                {(SQ <'--XX flag resulted in false value.'>)}
                {
                  (DQ 
                    (BracedVarSub
                      left: <Id.Left_DollarBrace '${'>
                      token: <Id.VSub_Name FLAGS_bool>
                      var_name: FLAGS_bool
                      suffix_op: (suffix_op.Unary op:<Id.VTest_ColonHyphen _> arg_word:(rhs_word__Empty))
                      right: <Id.Right_DollarBrace '}'>
                    )
                  )
                }
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <assertFalse>
              more_env: []
              words: [
                {<assertFalse>}
                {(SQ <'expected no output to STDERR'>)}
                {(DQ <'[ -s \''> (${ Id.VSub_Name stderrF) <'\' ]'>)}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <th_showOutput>
              more_env: []
              words: [
                {<th_showOutput>}
                {(${ Id.VSub_Name r3turn)}
                {(DQ (${ Id.VSub_Name stdoutF))}
                {(DQ (${ Id.VSub_Name stderrF))}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <FLAGS>
              more_env: []
              words: [{<FLAGS>} {<--nobool>}]
              redirects: [
                (Redir
                  op: <Id.Redir_Great '>'>
                  loc: (redir_loc.Fd fd:1)
                  arg: {(DQ (${ Id.VSub_Name stdoutF))}
                )
                (Redir
                  op: <Id.Redir_Great '2>'>
                  loc: (redir_loc.Fd fd:2)
                  arg: {(DQ (${ Id.VSub_Name stderrF))}
                )
              ]
              do_fork: T
            )
            (command.ShAssignment
              left: <Id.Lit_VarLike 'r3turn='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'r3turn='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'r3turn='> name:r3turn)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_QMark '?')}
                )
              ]
              redirects: []
            )
            (command.Simple
              blame_tok: <assertTrue>
              more_env: []
              words: [
                {<assertTrue>}
                {(DQ <'FLAGS returned a non-zero result ('> (${ Id.VSub_Name r3turn) <')'>)}
                {(${ Id.VSub_Name r3turn)}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <assertFalse>
              more_env: []
              words: [
                {<assertFalse>}
                {(SQ <'--noXX flag resulted in true value.'>)}
                {
                  (DQ 
                    (BracedVarSub
                      left: <Id.Left_DollarBrace '${'>
                      token: <Id.VSub_Name FLAGS_bool>
                      var_name: FLAGS_bool
                      suffix_op: (suffix_op.Unary op:<Id.VTest_ColonHyphen _> arg_word:(rhs_word__Empty))
                      right: <Id.Right_DollarBrace '}'>
                    )
                  )
                }
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <assertFalse>
              more_env: []
              words: [
                {<assertFalse>}
                {(SQ <'expected no output to STDERR'>)}
                {(DQ <'[ -s \''> (${ Id.VSub_Name stderrF) <'\' ]'>)}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <th_showOutput>
              more_env: []
              words: [
                {<th_showOutput>}
                {(${ Id.VSub_Name r3turn)}
                {(DQ (${ Id.VSub_Name stdoutF))}
                {(DQ (${ Id.VSub_Name stderrF))}
              ]
              redirects: []
              do_fork: T
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name_tok: <testValidFloats>
      name: testValidFloats
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.Simple
              blame_tok: <_testValidFloats>
              more_env: []
              words: [{<_testValidFloats>} {(SQ <-f>)}]
              redirects: []
              do_fork: T
            )
            (command.AndOr
              children: [
                (command.Simple
                  blame_tok: <flags_getoptIsEnh>
                  more_env: []
                  words: [{<flags_getoptIsEnh>}]
                  redirects: []
                  do_fork: T
                )
                (command.ControlFlow keyword:<Id.ControlFlow_Return return>)
              ]
              ops: [<Id.Op_DPipe _>]
            )
            (command.Simple
              blame_tok: <_testValidFloats>
              more_env: []
              words: [{<_testValidFloats>} {(SQ <--float>)}]
              redirects: []
              do_fork: T
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name_tok: <_testValidFloats>
      name: _testValidFloats
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.ShAssignment
              left: <Id.Lit_VarLike 'flag='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'flag='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'flag='> name:flag)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_Number 1)}
                )
              ]
              redirects: []
            )
            (command.ForEach
              keyword: <Id.KW_For for>
              iter_names: [value]
              iterable: (for_iter.Words words:[{(${ Id.VSub_Name TH_FLOAT_VALID)}])
              semi_tok: <Id.Op_Semi _>
              body: 
                (command.DoGroup
                  left: <Id.KW_Do do>
                  children: [
                    (command.Simple
                      blame_tok: <FLAGS>
                      more_env: []
                      words: [{<FLAGS>} {(DQ (${ Id.VSub_Name flag))} {(DQ (${ Id.VSub_Name value))}]
                      redirects: [
                        (Redir
                          op: <Id.Redir_Great '>'>
                          loc: (redir_loc.Fd fd:1)
                          arg: {(DQ (${ Id.VSub_Name stdoutF))}
                        )
                        (Redir
                          op: <Id.Redir_Great '2>'>
                          loc: (redir_loc.Fd fd:2)
                          arg: {(DQ (${ Id.VSub_Name stderrF))}
                        )
                      ]
                      do_fork: T
                    )
                    (command.ShAssignment
                      left: <Id.Lit_VarLike 'r3turn='>
                      pairs: [
                        (AssignPair
                          left: <Id.Lit_VarLike 'r3turn='>
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'r3turn='> name:r3turn)
                          op: assign_op.Equal
                          rhs: {($ Id.VSub_QMark '?')}
                        )
                      ]
                      redirects: []
                    )
                    (command.Simple
                      blame_tok: <assertTrue>
                      more_env: []
                      words: [
                        {<assertTrue>}
                        {
                          (DQ <'FLAGS '> (${ Id.VSub_Name flag) <' '> (${ Id.VSub_Name value) 
                            <' returned non-zero result ('> (${ Id.VSub_Name r3turn) <')'>
                          )
                        }
                        {(${ Id.VSub_Name r3turn)}
                      ]
                      redirects: []
                      do_fork: T
                    )
                    (command.Simple
                      blame_tok: <assertEquals>
                      more_env: []
                      words: [
                        {<assertEquals>}
                        {
                          (DQ <'float ('> (${ Id.VSub_Name flag) <' '> (${ Id.VSub_Name value) 
                            <') test failed.'>
                          )
                        }
                        {(DQ (${ Id.VSub_Name value))}
                        {(DQ (${ Id.VSub_Name FLAGS_float))}
                      ]
                      redirects: []
                      do_fork: T
                    )
                    (command.Simple
                      blame_tok: <assertFalse>
                      more_env: []
                      words: [
                        {<assertFalse>}
                        {(SQ <'expected no output to STDERR'>)}
                        {(DQ <'[ -s \''> (${ Id.VSub_Name stderrF) <'\' ]'>)}
                      ]
                      redirects: []
                      do_fork: T
                    )
                    (command.Simple
                      blame_tok: <th_showOutput>
                      more_env: []
                      words: [
                        {<th_showOutput>}
                        {(${ Id.VSub_Name r3turn)}
                        {(DQ (${ Id.VSub_Name stdoutF))}
                        {(DQ (${ Id.VSub_Name stderrF))}
                      ]
                      redirects: []
                      do_fork: T
                    )
                  ]
                  right: <Id.KW_Done done>
                )
              redirects: []
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name_tok: <testInvalidFloats>
      name: testInvalidFloats
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.Simple
              blame_tok: <_testInvalidFloats>
              more_env: []
              words: [{<_testInvalidFloats>} {(SQ <-f>)}]
              redirects: []
              do_fork: T
            )
            (command.AndOr
              children: [
                (command.Simple
                  blame_tok: <flags_getoptIsEnh>
                  more_env: []
                  words: [{<flags_getoptIsEnh>}]
                  redirects: []
                  do_fork: T
                )
                (command.ControlFlow keyword:<Id.ControlFlow_Return return>)
              ]
              ops: [<Id.Op_DPipe _>]
            )
            (command.Simple
              blame_tok: <_testInvalidFloats>
              more_env: []
              words: [{<_testInvalidFloats>} {(SQ <--float>)}]
              redirects: []
              do_fork: T
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name_tok: <_testInvalidFloats>
      name: _testInvalidFloats
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.ShAssignment
              left: <Id.Lit_VarLike 'flag='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'flag='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'flag='> name:flag)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_Number 1)}
                )
              ]
              redirects: []
            )
            (command.ForEach
              keyword: <Id.KW_For for>
              iter_names: [value]
              iterable: (for_iter.Words words:[{(${ Id.VSub_Name TH_FLOAT_INVALID)}])
              semi_tok: <Id.Op_Semi _>
              body: 
                (command.DoGroup
                  left: <Id.KW_Do do>
                  children: [
                    (command.Simple
                      blame_tok: <th_clearReturn>
                      more_env: []
                      words: [{<th_clearReturn>}]
                      redirects: []
                      do_fork: T
                    )
                    (command.Subshell
                      left: <Id.Op_LParen _>
                      child: 
                        (command.CommandList
                          children: [
                            (command.Simple
                              blame_tok: <FLAGS>
                              more_env: []
                              words: [
                                {<FLAGS>}
                                {(DQ (${ Id.VSub_Name flag))}
                                {(DQ (${ Id.VSub_Name value))}
                              ]
                              redirects: [
                                (Redir
                                  op: <Id.Redir_Great '>'>
                                  loc: (redir_loc.Fd fd:1)
                                  arg: {(DQ (${ Id.VSub_Name stdoutF))}
                                )
                                (Redir
                                  op: <Id.Redir_Great '2>'>
                                  loc: (redir_loc.Fd fd:2)
                                  arg: {(DQ (${ Id.VSub_Name stderrF))}
                                )
                              ]
                              do_fork: T
                            )
                            (command.Simple
                              blame_tok: <echo>
                              more_env: []
                              words: [{<echo>} {($ Id.VSub_QMark '?')}]
                              redirects: [
                                (Redir
                                  op: <Id.Redir_Great '>'>
                                  loc: (redir_loc.Fd fd:1)
                                  arg: {(DQ (${ Id.VSub_Name returnF))}
                                )
                              ]
                              do_fork: T
                            )
                          ]
                        )
                      right: <Id.Right_Subshell _>
                      redirects: []
                    )
                    (command.Simple
                      blame_tok: <assertFalse>
                      more_env: []
                      words: [
                        {<assertFalse>}
                        {(DQ <'FLAGS ('> (${ Id.VSub_Name value) <') returned a zero result'>)}
                        {
                          (DQ 
                            (CommandSub
                              left_token: <Id.Left_DollarParen '$('>
                              child: 
                                (command.Simple
                                  blame_tok: <th_queryReturn>
                                  more_env: []
                                  words: [{<th_queryReturn>}]
                                  redirects: []
                                  do_fork: T
                                )
                              right: <Id.Eof_RParen _>
                            )
                          )
                        }
                      ]
                      redirects: []
                      do_fork: T
                    )
                    (command.Simple
                      blame_tok: <assertFalse>
                      more_env: []
                      words: [
                        {<assertFalse>}
                        {(SQ <'expected no output to STDOUT'>)}
                        {(DQ <'[ -s \''> (${ Id.VSub_Name stdoutF) <'\' ]'>)}
                      ]
                      redirects: []
                      do_fork: T
                    )
                    (command.Simple
                      blame_tok: <assertTrue>
                      more_env: []
                      words: [
                        {<assertTrue>}
                        {(SQ <'expected output to STDERR'>)}
                        {(DQ <'[ -s \''> (${ Id.VSub_Name stderrF) <'\' ]'>)}
                      ]
                      redirects: []
                      do_fork: T
                    )
                  ]
                  right: <Id.KW_Done done>
                )
              redirects: []
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name_tok: <testValidIntegers>
      name: testValidIntegers
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.Simple
              blame_tok: <_testValidIntegers>
              more_env: []
              words: [{<_testValidIntegers>} {(SQ <-i>)}]
              redirects: []
              do_fork: T
            )
            (command.AndOr
              children: [
                (command.Simple
                  blame_tok: <flags_getoptIsEnh>
                  more_env: []
                  words: [{<flags_getoptIsEnh>}]
                  redirects: []
                  do_fork: T
                )
                (command.ControlFlow keyword:<Id.ControlFlow_Return return>)
              ]
              ops: [<Id.Op_DPipe _>]
            )
            (command.Simple
              blame_tok: <_testValidIntegers>
              more_env: []
              words: [{<_testValidIntegers>} {(SQ <--int>)}]
              redirects: []
              do_fork: T
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name_tok: <_testValidIntegers>
      name: _testValidIntegers
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.ShAssignment
              left: <Id.Lit_VarLike 'flag='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'flag='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'flag='> name:flag)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_Number 1)}
                )
              ]
              redirects: []
            )
            (command.ForEach
              keyword: <Id.KW_For for>
              iter_names: [value]
              iterable: (for_iter.Words words:[{(${ Id.VSub_Name TH_INT_VALID)}])
              semi_tok: <Id.Op_Semi _>
              body: 
                (command.DoGroup
                  left: <Id.KW_Do do>
                  children: [
                    (command.Simple
                      blame_tok: <FLAGS>
                      more_env: []
                      words: [{<FLAGS>} {(DQ (${ Id.VSub_Name flag))} {(DQ (${ Id.VSub_Name value))}]
                      redirects: [
                        (Redir
                          op: <Id.Redir_Great '>'>
                          loc: (redir_loc.Fd fd:1)
                          arg: {(DQ (${ Id.VSub_Name stdoutF))}
                        )
                        (Redir
                          op: <Id.Redir_Great '2>'>
                          loc: (redir_loc.Fd fd:2)
                          arg: {(DQ (${ Id.VSub_Name stderrF))}
                        )
                      ]
                      do_fork: T
                    )
                    (command.ShAssignment
                      left: <Id.Lit_VarLike 'r3turn='>
                      pairs: [
                        (AssignPair
                          left: <Id.Lit_VarLike 'r3turn='>
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'r3turn='> name:r3turn)
                          op: assign_op.Equal
                          rhs: {($ Id.VSub_QMark '?')}
                        )
                      ]
                      redirects: []
                    )
                    (command.Simple
                      blame_tok: <assertTrue>
                      more_env: []
                      words: [
                        {<assertTrue>}
                        {
                          (DQ <'FLAGS ('> (${ Id.VSub_Name value) <') returned a non-zero result ('> 
                            (${ Id.VSub_Name r3turn) <')'>
                          )
                        }
                        {(${ Id.VSub_Name r3turn)}
                      ]
                      redirects: []
                      do_fork: T
                    )
                    (command.Simple
                      blame_tok: <assertEquals>
                      more_env: []
                      words: [
                        {<assertEquals>}
                        {(DQ <'integer ('> (${ Id.VSub_Name value) <') test failed.'>)}
                        {(DQ (${ Id.VSub_Name value))}
                        {(DQ (${ Id.VSub_Name FLAGS_int))}
                      ]
                      redirects: []
                      do_fork: T
                    )
                    (command.Simple
                      blame_tok: <assertFalse>
                      more_env: []
                      words: [
                        {<assertFalse>}
                        {(SQ <'expected no output to STDERR'>)}
                        {(DQ <'[ -s \''> (${ Id.VSub_Name stderrF) <'\' ]'>)}
                      ]
                      redirects: []
                      do_fork: T
                    )
                    (command.Simple
                      blame_tok: <th_showOutput>
                      more_env: []
                      words: [
                        {<th_showOutput>}
                        {(${ Id.VSub_Name r3turn)}
                        {(DQ (${ Id.VSub_Name stdoutF))}
                        {(DQ (${ Id.VSub_Name stderrF))}
                      ]
                      redirects: []
                      do_fork: T
                    )
                  ]
                  right: <Id.KW_Done done>
                )
              redirects: []
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name_tok: <testInvalidIntegers>
      name: testInvalidIntegers
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.Simple
              blame_tok: <_testInvalidIntegers>
              more_env: []
              words: [{<_testInvalidIntegers>} {(SQ <-i>)}]
              redirects: []
              do_fork: T
            )
            (command.AndOr
              children: [
                (command.Simple
                  blame_tok: <flags_getoptIsEnh>
                  more_env: []
                  words: [{<flags_getoptIsEnh>}]
                  redirects: []
                  do_fork: T
                )
                (command.ControlFlow keyword:<Id.ControlFlow_Return return>)
              ]
              ops: [<Id.Op_DPipe _>]
            )
            (command.Simple
              blame_tok: <_testInvalidIntegers>
              more_env: []
              words: [{<_testInvalidIntegers>} {(SQ <--int>)}]
              redirects: []
              do_fork: T
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name_tok: <_testInvalidIntegers>
      name: _testInvalidIntegers
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.ShAssignment
              left: <Id.Lit_VarLike 'flag='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'flag='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'flag='> name:flag)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_Number 1)}
                )
              ]
              redirects: []
            )
            (command.ForEach
              keyword: <Id.KW_For for>
              iter_names: [value]
              iterable: (for_iter.Words words:[{(${ Id.VSub_Name TH_INT_INVALID)}])
              semi_tok: <Id.Op_Semi _>
              body: 
                (command.DoGroup
                  left: <Id.KW_Do do>
                  children: [
                    (command.Simple
                      blame_tok: <th_clearReturn>
                      more_env: []
                      words: [{<th_clearReturn>}]
                      redirects: []
                      do_fork: T
                    )
                    (command.Subshell
                      left: <Id.Op_LParen _>
                      child: 
                        (command.CommandList
                          children: [
                            (command.Simple
                              blame_tok: <FLAGS>
                              more_env: []
                              words: [
                                {<FLAGS>}
                                {(DQ (${ Id.VSub_Name flag))}
                                {(DQ (${ Id.VSub_Name value))}
                              ]
                              redirects: [
                                (Redir
                                  op: <Id.Redir_Great '>'>
                                  loc: (redir_loc.Fd fd:1)
                                  arg: {(DQ (${ Id.VSub_Name stdoutF))}
                                )
                                (Redir
                                  op: <Id.Redir_Great '2>'>
                                  loc: (redir_loc.Fd fd:2)
                                  arg: {(DQ (${ Id.VSub_Name stderrF))}
                                )
                              ]
                              do_fork: T
                            )
                            (command.Simple
                              blame_tok: <echo>
                              more_env: []
                              words: [{<echo>} {($ Id.VSub_QMark '?')}]
                              redirects: [
                                (Redir
                                  op: <Id.Redir_Great '>'>
                                  loc: (redir_loc.Fd fd:1)
                                  arg: {(DQ (${ Id.VSub_Name returnF))}
                                )
                              ]
                              do_fork: T
                            )
                          ]
                        )
                      right: <Id.Right_Subshell _>
                      redirects: []
                    )
                    (command.Simple
                      blame_tok: <assertFalse>
                      more_env: []
                      words: [
                        {<assertFalse>}
                        {
                          (DQ <'invalid integer ('> (${ Id.VSub_Name value) 
                            <') test returned success.'>
                          )
                        }
                        {
                          (DQ 
                            (CommandSub
                              left_token: <Id.Left_DollarParen '$('>
                              child: 
                                (command.Simple
                                  blame_tok: <th_queryReturn>
                                  more_env: []
                                  words: [{<th_queryReturn>}]
                                  redirects: []
                                  do_fork: T
                                )
                              right: <Id.Eof_RParen _>
                            )
                          )
                        }
                      ]
                      redirects: []
                      do_fork: T
                    )
                    (command.Simple
                      blame_tok: <assertFalse>
                      more_env: []
                      words: [
                        {<assertFalse>}
                        {(SQ <'expected no output to STDOUT'>)}
                        {(DQ <'[ -s \''> (${ Id.VSub_Name stdoutF) <'\' ]'>)}
                      ]
                      redirects: []
                      do_fork: T
                    )
                    (command.Simple
                      blame_tok: <assertTrue>
                      more_env: []
                      words: [
                        {<assertTrue>}
                        {(SQ <'expected output to STDERR'>)}
                        {(DQ <'[ -s \''> (${ Id.VSub_Name stderrF) <'\' ]'>)}
                      ]
                      redirects: []
                      do_fork: T
                    )
                  ]
                  right: <Id.KW_Done done>
                )
              redirects: []
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name_tok: <testValidStrings>
      name: testValidStrings
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.Simple
              blame_tok: <_testValidStrings>
              more_env: []
              words: [{<_testValidStrings>} {<-s>} {<single_word>}]
              redirects: []
              do_fork: T
            )
            (command.If
              if_kw: <Id.KW_If if>
              arms: [
                (IfArm
                  keyword: <Id.KW_If if>
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.Simple
                              blame_tok: <flags_getoptIsEnh>
                              more_env: []
                              words: [{<flags_getoptIsEnh>}]
                              redirects: []
                              do_fork: T
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  then_kw: <Id.KW_Then then>
                  action: [
                    (command.Simple
                      blame_tok: <_testValidStrings>
                      more_env: []
                      words: [{<_testValidStrings>} {<--str>} {<single_word>}]
                      redirects: []
                      do_fork: T
                    )
                    (command.Simple
                      blame_tok: <_testValidStrings>
                      more_env: []
                      words: [{<_testValidStrings>} {<--str>} {(SQ <'string with spaces'>)}]
                      redirects: []
                      do_fork: T
                    )
                  ]
                  spids: [1709 1714]
                )
              ]
              else_action: []
              fi_kw: <Id.KW_Fi fi>
              redirects: []
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name_tok: <_testValidStrings>
      name: _testValidStrings
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.ShAssignment
              left: <Id.Lit_VarLike 'flag='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'flag='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'flag='> name:flag)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_Number 1)}
                )
              ]
              redirects: []
            )
            (command.ShAssignment
              left: <Id.Lit_VarLike 'value='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'value='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'value='> name:value)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_Number 2)}
                )
              ]
              redirects: []
            )
            (command.Simple
              blame_tok: <FLAGS>
              more_env: []
              words: [{<FLAGS>} {(DQ (${ Id.VSub_Name flag))} {(DQ (${ Id.VSub_Name value))}]
              redirects: [
                (Redir
                  op: <Id.Redir_Great '>'>
                  loc: (redir_loc.Fd fd:1)
                  arg: {(DQ (${ Id.VSub_Name stdoutF))}
                )
                (Redir
                  op: <Id.Redir_Great '2>'>
                  loc: (redir_loc.Fd fd:2)
                  arg: {(DQ (${ Id.VSub_Name stderrF))}
                )
              ]
              do_fork: T
            )
            (command.ShAssignment
              left: <Id.Lit_VarLike 'r3turn='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'r3turn='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'r3turn='> name:r3turn)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_QMark '?')}
                )
              ]
              redirects: []
            )
            (command.Simple
              blame_tok: <assertTrue>
              more_env: []
              words: [
                {<assertTrue>}
                {
                  (DQ <'\'FLAGS '> (${ Id.VSub_Name flag) <' '> (${ Id.VSub_Name value) 
                    <'\' returned a non-zero result ('> (${ Id.VSub_Name r3turn) <')'>
                  )
                }
                {(${ Id.VSub_Name r3turn)}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <assertEquals>
              more_env: []
              words: [
                {<assertEquals>}
                {(DQ <'string ('> (${ Id.VSub_Name value) <') test failed.'>)}
                {(DQ (${ Id.VSub_Name value))}
                {(DQ (${ Id.VSub_Name FLAGS_str))}
              ]
              redirects: []
              do_fork: T
            )
            (command.If
              if_kw: <Id.KW_If if>
              arms: [
                (IfArm
                  keyword: <Id.KW_If if>
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.Simple
                              blame_tok: <Id.Lit_LBracket '['>
                              more_env: []
                              words: [
                                {<Id.Lit_LBracket '['>}
                                {(${ Id.VSub_Name r3turn)}
                                {<-eq>}
                                {(DQ (${ Id.VSub_Name FLAGS_TRUE))}
                                {<Id.Lit_RBracket ']'>}
                              ]
                              redirects: []
                              do_fork: T
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  then_kw: <Id.KW_Then then>
                  action: [
                    (command.Simple
                      blame_tok: <assertFalse>
                      more_env: []
                      words: [
                        {<assertFalse>}
                        {(SQ <'expected no output to STDERR'>)}
                        {(DQ <'[ -s \''> (${ Id.VSub_Name stderrF) <'\' ]'>)}
                      ]
                      redirects: []
                      do_fork: T
                    )
                  ]
                  spids: [1839 1858]
                )
              ]
              else_kw: <Id.KW_Else else>
              else_action: [
                (command.Simple
                  blame_tok: <assertFatalMsg>
                  more_env: []
                  words: [{<assertFatalMsg>} {(SQ <'.* spaces in options'>)}]
                  redirects: []
                  do_fork: T
                )
              ]
              fi_kw: <Id.KW_Fi fi>
              redirects: []
            )
            (command.Simple
              blame_tok: <th_showOutput>
              more_env: []
              words: [
                {<th_showOutput>}
                {(${ Id.VSub_Name r3turn)}
                {(DQ (${ Id.VSub_Name stdoutF))}
                {(DQ (${ Id.VSub_Name stderrF))}
              ]
              redirects: []
              do_fork: T
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name_tok: <testMultipleFlags>
      name: testMultipleFlags
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.Simple
              blame_tok: <_testMultipleFlags>
              more_env: []
              words: [{<_testMultipleFlags>} {(SQ <-b>)} {(SQ <-i>)} {(SQ <-f>)} {(SQ <-s>)}]
              redirects: []
              do_fork: T
            )
            (command.AndOr
              children: [
                (command.Simple
                  blame_tok: <flags_getoptIsEnh>
                  more_env: []
                  words: [{<flags_getoptIsEnh>}]
                  redirects: []
                  do_fork: T
                )
                (command.ControlFlow keyword:<Id.ControlFlow_Return return>)
              ]
              ops: [<Id.Op_DPipe _>]
            )
            (command.Simple
              blame_tok: <_testMultipleFlags>
              more_env: []
              words: [{<_testMultipleFlags>} {(SQ <--bool>)} {(SQ <--int>)} {(SQ <--float>)} {(SQ <--str>)}]
              redirects: []
              do_fork: T
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name_tok: <_testMultipleFlags>
      name: _testMultipleFlags
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.ShAssignment
              left: <Id.Lit_VarLike 'boolFlag='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'boolFlag='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'boolFlag='> name:boolFlag)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_Number 1)}
                )
              ]
              redirects: []
            )
            (command.ShAssignment
              left: <Id.Lit_VarLike 'intFlag='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'intFlag='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'intFlag='> name:intFlag)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_Number 2)}
                )
              ]
              redirects: []
            )
            (command.ShAssignment
              left: <Id.Lit_VarLike 'floatFlag='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'floatFlag='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'floatFlag='> name:floatFlag)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_Number 3)}
                )
              ]
              redirects: []
            )
            (command.ShAssignment
              left: <Id.Lit_VarLike 'strFlag='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'strFlag='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'strFlag='> name:strFlag)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_Number 4)}
                )
              ]
              redirects: []
            )
            (command.Simple
              blame_tok: <FLAGS>
              more_env: []
              words: [
                {<FLAGS>}
                {(DQ (${ Id.VSub_Name boolFlag))}
                {(DQ (${ Id.VSub_Name intFlag))}
                {<567>}
                {(DQ (${ Id.VSub_Name floatFlag))}
                {<123.45678>}
                {(DQ (${ Id.VSub_Name strFlag))}
                {(SQ <some_string>)}
              ]
              redirects: [
                (Redir
                  op: <Id.Redir_Great '>'>
                  loc: (redir_loc.Fd fd:1)
                  arg: {(DQ (${ Id.VSub_Name stdoutF))}
                )
                (Redir
                  op: <Id.Redir_Great '2>'>
                  loc: (redir_loc.Fd fd:2)
                  arg: {(DQ (${ Id.VSub_Name stderrF))}
                )
              ]
              do_fork: T
            )
            (command.ShAssignment
              left: <Id.Lit_VarLike 'r3turn='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'r3turn='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'r3turn='> name:r3turn)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_QMark '?')}
                )
              ]
              redirects: []
            )
            (command.Simple
              blame_tok: <assertTrue>
              more_env: []
              words: [
                {<assertTrue>}
                {(DQ <'use of multiple flags returned a non-zero result'>)}
                {(${ Id.VSub_Name r3turn)}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <assertTrue>
              more_env: []
              words: [{<assertTrue>} {(SQ <'boolean test failed.'>)} {(DQ (${ Id.VSub_Name FLAGS_bool))}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <assertNotSame>
              more_env: []
              words: [
                {<assertNotSame>}
                {(SQ <'float test failed.'>)}
                {<0>}
                {(DQ (${ Id.VSub_Name FLAGS_float))}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <assertNotSame>
              more_env: []
              words: [
                {<assertNotSame>}
                {(SQ <'integer test failed.'>)}
                {<0>}
                {(DQ (${ Id.VSub_Name FLAGS_int))}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <assertNotSame>
              more_env: []
              words: [
                {<assertNotSame>}
                {(SQ <'string test failed.'>)}
                {(SQ )}
                {(DQ (${ Id.VSub_Name FLAGS_str))}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <assertFalse>
              more_env: []
              words: [
                {<assertFalse>}
                {(SQ <'expected no output to STDERR'>)}
                {(DQ <'[ -s \''> (${ Id.VSub_Name stderrF) <'\' ]'>)}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <th_showOutput>
              more_env: []
              words: [
                {<th_showOutput>}
                {(${ Id.VSub_Name r3turn)}
                {(DQ (${ Id.VSub_Name stdoutF))}
                {(DQ (${ Id.VSub_Name stderrF))}
              ]
              redirects: []
              do_fork: T
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name_tok: <_testNonFlagArgs>
      name: _testNonFlagArgs
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.ShAssignment
              left: <Id.Lit_VarLike 'argc='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'argc='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'argc='> name:argc)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_Number 1)}
                )
              ]
              redirects: []
            )
            (command.Simple
              blame_tok: <shift>
              more_env: []
              words: [{<shift>}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <FLAGS>
              more_env: []
              words: [{<FLAGS>} {(DQ ($ Id.VSub_At '@'))}]
              redirects: [
                (Redir
                  op: <Id.Redir_Great '>'>
                  loc: (redir_loc.Fd fd:1)
                  arg: {(DQ (${ Id.VSub_Name stdoutF))}
                )
                (Redir
                  op: <Id.Redir_Great '2>'>
                  loc: (redir_loc.Fd fd:2)
                  arg: {(DQ (${ Id.VSub_Name stderrF))}
                )
              ]
              do_fork: T
            )
            (command.ShAssignment
              left: <Id.Lit_VarLike 'r3turn='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'r3turn='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'r3turn='> name:r3turn)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_QMark '?')}
                )
              ]
              redirects: []
            )
            (command.Simple
              blame_tok: <assertTrue>
              more_env: []
              words: [
                {<assertTrue>}
                {(SQ <'parse returned non-zero value.'>)}
                {(${ Id.VSub_Name r3turn)}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <th_showOutput>
              more_env: []
              words: [
                {<th_showOutput>}
                {(${ Id.VSub_Name r3turn)}
                {(DQ (${ Id.VSub_Name stdoutF))}
                {(DQ (${ Id.VSub_Name stderrF))}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <eval>
              more_env: []
              words: [{<eval>} {<set>} {<-->} {(DQ (${ Id.VSub_Name FLAGS_ARGV))}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <assertEquals>
              more_env: []
              words: [
                {<assertEquals>}
                {(SQ <'wrong count of argv arguments returned.'>)}
                {(DQ (${ Id.VSub_Name argc))}
                {($ Id.VSub_Pound '#')}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <assertEquals>
              more_env: []
              words: [
                {<assertEquals>}
                {(SQ <'wrong count of argc arguments returned.'>)}
                {<0>}
                {(DQ (${ Id.VSub_Name FLAGS_ARGC))}
              ]
              redirects: []
              do_fork: T
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name_tok: <testSingleNonFlagArg>
      name: testSingleNonFlagArg
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.Simple
              blame_tok: <_testNonFlagArgs>
              more_env: []
              words: [{<_testNonFlagArgs>} {<1>} {<argOne>}]
              redirects: []
              do_fork: T
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name_tok: <testMultipleNonFlagArgs>
      name: testMultipleNonFlagArgs
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.Simple
              blame_tok: <_testNonFlagArgs>
              more_env: []
              words: [{<_testNonFlagArgs>} {<3>} {<argOne>} {<argTwo>} {<arg3>}]
              redirects: []
              do_fork: T
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name_tok: <testMultipleNonFlagStringArgsWithSpaces>
      name: testMultipleNonFlagStringArgsWithSpaces
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.AndOr
              children: [
                (command.Simple
                  blame_tok: <flags_getoptIsEnh>
                  more_env: []
                  words: [{<flags_getoptIsEnh>}]
                  redirects: []
                  do_fork: T
                )
                (command.ControlFlow keyword:<Id.ControlFlow_Return return>)
              ]
              ops: [<Id.Op_DPipe _>]
            )
            (command.Simple
              blame_tok: <_testNonFlagArgs>
              more_env: []
              words: [{<_testNonFlagArgs>} {<3>} {<argOne>} {(SQ <'arg two'>)} {<arg3>}]
              redirects: []
              do_fork: T
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name_tok: <testFlagsWithEquals>
      name: testFlagsWithEquals
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.AndOr
              children: [
                (command.Simple
                  blame_tok: <flags_getoptIsEnh>
                  more_env: []
                  words: [{<flags_getoptIsEnh>}]
                  redirects: []
                  do_fork: T
                )
                (command.ControlFlow keyword:<Id.ControlFlow_Return return>)
              ]
              ops: [<Id.Op_DPipe _>]
            )
            (command.Simple
              blame_tok: <FLAGS>
              more_env: []
              words: [{<FLAGS>} {<--str> <Id.Lit_Equals '='> (SQ <str_flag>)} {(SQ <non_flag>)}]
              redirects: [
                (Redir
                  op: <Id.Redir_Great '>'>
                  loc: (redir_loc.Fd fd:1)
                  arg: {(DQ (${ Id.VSub_Name stdoutF))}
                )
                (Redir
                  op: <Id.Redir_Great '2>'>
                  loc: (redir_loc.Fd fd:2)
                  arg: {(DQ (${ Id.VSub_Name stderrF))}
                )
              ]
              do_fork: T
            )
            (command.Simple
              blame_tok: <assertTrue>
              more_env: []
              words: [{<assertTrue>} {(SQ <'FLAGS returned a non-zero result'>)} {($ Id.VSub_QMark '?')}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <assertEquals>
              more_env: []
              words: [
                {<assertEquals>}
                {(SQ <'string flag not set properly'>)}
                {(SQ <str_flag>)}
                {(DQ (${ Id.VSub_Name FLAGS_str))}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <th_showOutput>
              more_env: []
              words: [
                {<th_showOutput>}
                {(${ Id.VSub_Name r3turn)}
                {(DQ (${ Id.VSub_Name stdoutF))}
                {(DQ (${ Id.VSub_Name stderrF))}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <eval>
              more_env: []
              words: [{<eval>} {<set>} {<-->} {(DQ (${ Id.VSub_Name FLAGS_ARGV))}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <assertEquals>
              more_env: []
              words: [
                {<assertEquals>}
                {(SQ <'wrong count of argv arguments returned.'>)}
                {<1>}
                {($ Id.VSub_Pound '#')}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <assertEquals>
              more_env: []
              words: [
                {<assertEquals>}
                {(SQ <'wrong count of argc arguments returned.'>)}
                {<1>}
                {(DQ (${ Id.VSub_Name FLAGS_ARGC))}
              ]
              redirects: []
              do_fork: T
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name_tok: <testComplicatedCommandLineStandard>
      name: testComplicatedCommandLineStandard
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.AndOr
              children: [
                (command.Simple
                  blame_tok: <flags_getoptIsEnh>
                  more_env: []
                  words: [{<flags_getoptIsEnh>}]
                  redirects: []
                  do_fork: T
                )
                (command.ControlFlow keyword:<Id.ControlFlow_Return return>)
              ]
              ops: [<Id.Op_DAmp _>]
            )
            (command.Simple
              blame_tok: <FLAGS>
              more_env: []
              words: [
                {<FLAGS>}
                {<-i>}
                {<1>}
                {<non_flag_1>}
                {<-s>}
                {(SQ <two>)}
                {<non_flag_2>}
                {<-f>}
                {<3>}
                {<non_flag_3>}
              ]
              redirects: [
                (Redir
                  op: <Id.Redir_Great '>'>
                  loc: (redir_loc.Fd fd:1)
                  arg: {(DQ (${ Id.VSub_Name stdoutF))}
                )
                (Redir
                  op: <Id.Redir_Great '2>'>
                  loc: (redir_loc.Fd fd:2)
                  arg: {(DQ (${ Id.VSub_Name stderrF))}
                )
              ]
              do_fork: T
            )
            (command.ShAssignment
              left: <Id.Lit_VarLike 'r3turn='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'r3turn='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'r3turn='> name:r3turn)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_QMark '?')}
                )
              ]
              redirects: []
            )
            (command.Simple
              blame_tok: <assertTrue>
              more_env: []
              words: [
                {<assertTrue>}
                {(SQ <'FLAGS returned a non-zero result'>)}
                {(${ Id.VSub_Name r3turn)}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <assertEquals>
              more_env: []
              words: [{<assertEquals>} {(SQ <'failed int test'>)} {<1>} {(DQ (${ Id.VSub_Name FLAGS_int))}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <th_showOutput>
              more_env: []
              words: [
                {<th_showOutput>}
                {(${ Id.VSub_Name r3turn)}
                {(DQ (${ Id.VSub_Name stdoutF))}
                {(DQ (${ Id.VSub_Name stderrF))}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <eval>
              more_env: []
              words: [{<eval>} {<set>} {<-->} {(DQ (${ Id.VSub_Name FLAGS_ARGV))}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <assertEquals>
              more_env: []
              words: [
                {<assertEquals>}
                {(SQ <'incorrect number of argv values'>)}
                {<7>}
                {($ Id.VSub_Pound '#')}
              ]
              redirects: []
              do_fork: T
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name_tok: <testComplicatedCommandLineEnhanced>
      name: testComplicatedCommandLineEnhanced
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.AndOr
              children: [
                (command.Simple
                  blame_tok: <flags_getoptIsEnh>
                  more_env: []
                  words: [{<flags_getoptIsEnh>}]
                  redirects: []
                  do_fork: T
                )
                (command.ControlFlow keyword:<Id.ControlFlow_Return return>)
              ]
              ops: [<Id.Op_DPipe _>]
            )
            (command.Simple
              blame_tok: <FLAGS>
              more_env: []
              words: [
                {<FLAGS>}
                {<-i>}
                {<1>}
                {<non_flag_1>}
                {<--str> <Id.Lit_Equals '='> (SQ <two>)}
                {<non_flag_2>}
                {<--float>}
                {<3>}
                {(SQ <'non flag 3'>)}
              ]
              redirects: [
                (Redir
                  op: <Id.Redir_Great '>'>
                  loc: (redir_loc.Fd fd:1)
                  arg: {(DQ (${ Id.VSub_Name stdoutF))}
                )
                (Redir
                  op: <Id.Redir_Great '2>'>
                  loc: (redir_loc.Fd fd:2)
                  arg: {(DQ (${ Id.VSub_Name stderrF))}
                )
              ]
              do_fork: T
            )
            (command.ShAssignment
              left: <Id.Lit_VarLike 'r3turn='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'r3turn='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'r3turn='> name:r3turn)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_QMark '?')}
                )
              ]
              redirects: []
            )
            (command.Simple
              blame_tok: <assertTrue>
              more_env: []
              words: [
                {<assertTrue>}
                {(SQ <'FLAGS returned a non-zero result'>)}
                {(${ Id.VSub_Name r3turn)}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <assertEquals>
              more_env: []
              words: [{<assertEquals>} {(SQ <'failed int test'>)} {<1>} {(DQ (${ Id.VSub_Name FLAGS_int))}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <assertEquals>
              more_env: []
              words: [
                {<assertEquals>}
                {(SQ <'failed str test'>)}
                {(SQ <two>)}
                {(DQ (${ Id.VSub_Name FLAGS_str))}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <assertEquals>
              more_env: []
              words: [
                {<assertEquals>}
                {(SQ <'failed float test'>)}
                {<3>}
                {(DQ (${ Id.VSub_Name FLAGS_float))}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <th_showOutput>
              more_env: []
              words: [
                {<th_showOutput>}
                {(${ Id.VSub_Name r3turn)}
                {(DQ (${ Id.VSub_Name stdoutF))}
                {(DQ (${ Id.VSub_Name stderrF))}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <eval>
              more_env: []
              words: [{<eval>} {<set>} {<-->} {(DQ (${ Id.VSub_Name FLAGS_ARGV))}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <assertEquals>
              more_env: []
              words: [
                {<assertEquals>}
                {(SQ <'incorrect number of argv values'>)}
                {<3>}
                {($ Id.VSub_Pound '#')}
              ]
              redirects: []
              do_fork: T
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name_tok: <oneTimeSetUp>
      name: oneTimeSetUp
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.Simple
              blame_tok: <th_oneTimeSetUp>
              more_env: []
              words: [{<th_oneTimeSetUp>}]
              redirects: []
              do_fork: T
            )
            (command.If
              if_kw: <Id.KW_If if>
              arms: [
                (IfArm
                  keyword: <Id.KW_If if>
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.Simple
                              blame_tok: <flags_getoptIsStd>
                              more_env: []
                              words: [{<flags_getoptIsStd>}]
                              redirects: []
                              do_fork: T
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  then_kw: <Id.KW_Then then>
                  action: [
                    (command.Simple
                      blame_tok: <th_warn>
                      more_env: []
                      words: [
                        {<th_warn>}
                        {(SQ <'Standard version of getopt found. Enhanced tests will be skipped.'>)}
                      ]
                      redirects: []
                      do_fork: T
                    )
                  ]
                  spids: [2784 2789]
                )
              ]
              else_kw: <Id.KW_Else else>
              else_action: [
                (command.Simple
                  blame_tok: <th_warn>
                  more_env: []
                  words: [
                    {<th_warn>}
                    {(SQ <'Enhanced version of getopt found. Standard tests will be skipped.'>)}
                  ]
                  redirects: []
                  do_fork: T
                )
              ]
              fi_kw: <Id.KW_Fi fi>
              redirects: []
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name_tok: <setUp>
      name: setUp
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.Simple
              blame_tok: <DEFINE_boolean>
              more_env: []
              words: [{<DEFINE_boolean>} {<bool>} {<false>} {(SQ <'boolean test'>)} {(SQ <b>)}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <DEFINE_float>
              more_env: []
              words: [{<DEFINE_float>} {<float>} {<0.0>} {(SQ <'float test'>)} {(SQ <f>)}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <DEFINE_integer>
              more_env: []
              words: [{<DEFINE_integer>} {<int>} {<0>} {(SQ <'integer test'>)} {(SQ <i>)}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <DEFINE_string>
              more_env: []
              words: [{<DEFINE_string>} {<str>} {(SQ )} {(SQ <'string test'>)} {(SQ <s>)}]
              redirects: []
              do_fork: T
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name_tok: <tearDown>
      name: tearDown
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.Simple
              blame_tok: <flags_reset>
              more_env: []
              words: [{<flags_reset>}]
              redirects: []
              do_fork: T
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.AndOr
      children: [
        (command.Simple
          blame_tok: <Id.Lit_LBracket '['>
          more_env: []
          words: [
            {<Id.Lit_LBracket '['>}
            {<-n>}
            {
              (DQ 
                (BracedVarSub
                  left: <Id.Left_DollarBrace '${'>
                  token: <Id.VSub_Name ZSH_VERSION>
                  var_name: ZSH_VERSION
                  suffix_op: (suffix_op.Unary op:<Id.VTest_ColonHyphen _> arg_word:(rhs_word__Empty))
                  right: <Id.Right_DollarBrace '}'>
                )
              )
            }
            {<Id.Lit_RBracket ']'>}
          ]
          redirects: []
          do_fork: T
        )
        (command.ShAssignment
          left: <Id.Lit_VarLike 'SHUNIT_PARENT='>
          pairs: [
            (AssignPair
              left: <Id.Lit_VarLike 'SHUNIT_PARENT='>
              lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'SHUNIT_PARENT='> name:SHUNIT_PARENT)
              op: assign_op.Equal
              rhs: {($ Id.VSub_Number 0)}
            )
          ]
          redirects: []
        )
      ]
      ops: [<Id.Op_DAmp _>]
    )
    (command.Simple
      blame_tok: <.>
      more_env: []
      words: [{<.>} {(DQ (${ Id.VSub_Name TH_SHUNIT))}]
      redirects: []
      do_fork: T
    )
  ]
)