(command.CommandList
  children: [
    (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: <testFlagsDefine>
      name: testFlagsDefine
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.Simple
              blame_tok: <_flags_define>
              more_env: []
              words: [{<_flags_define>}]
              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>}
                {(SQ <'_flags_define() with no arguments should have failed.'>)}
                {($ Id.VSub_QMark '?')}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <assertErrorMsg>
              more_env: []
              words: [{<assertErrorMsg>} {(SQ )} {(SQ <'no arguments'>)}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <_flags_define>
              more_env: []
              words: [{<_flags_define>} {<arg1>}]
              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>}
                {(SQ <'_flags_define() call with one argument should fail'>)}
                {($ Id.VSub_QMark '?')}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <assertErrorMsg>
              more_env: []
              words: [{<assertErrorMsg>} {(SQ )} {(SQ <'one argument'>)}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <_flags_define>
              more_env: []
              words: [{<_flags_define>} {<arg1>} {<arg2>}]
              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>}
                {(SQ <'_flags_define() call with two arguments should fail'>)}
                {($ Id.VSub_QMark '?')}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <assertErrorMsg>
              more_env: []
              words: [{<assertErrorMsg>} {(SQ )} {(SQ <'two arguments'>)}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <_flags_define>
              more_env: []
              words: [{<_flags_define>} {<arg1>} {<arg2>} {<arg3>}]
              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>}
                {(SQ <'_flags_define() call with three arguments should fail'>)}
                {($ Id.VSub_QMark '?')}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <assertErrorMsg>
              more_env: []
              words: [{<assertErrorMsg>} {(SQ )} {(SQ <'three arguments'>)}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <_flags_define>
              more_env: []
              words: [
                {<_flags_define>}
                {(DQ (${ Id.VSub_Name __FLAGS_TYPE_BOOLEAN))}
                {<multiDefBool>}
                {<true>}
                {(SQ <'multi def #1'>)}
                {<m>}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <_flags_define>
              more_env: []
              words: [
                {<_flags_define>}
                {(DQ (${ Id.VSub_Name __FLAGS_TYPE_BOOLEAN))}
                {<multiDefBool>}
                {<false>}
                {(SQ <'multi def #2'>)}
                {<m>}
              ]
              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>}
                {(SQ <'_flags_define() with existing flag name should fail'>)}
                {($ Id.VSub_QMark '?')}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <assertTrue>
              more_env: []
              words: [
                {<assertTrue>}
                {(SQ <'_flags_define() should not overwrite previously defined default.'>)}
                {
                  (DQ 
                    (BracedVarSub
                      left: <Id.Left_DollarBrace '${'>
                      token: <Id.VSub_Name FLAGS_multiDefBool>
                      var_name: FLAGS_multiDefBool
                      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: <assertWarnMsg>
              more_env: []
              words: [{<assertWarnMsg>} {(SQ )} {(SQ <'existing flag'>)}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <_flags_define>
              more_env: []
              words: [
                {<_flags_define>}
                {(DQ (${ Id.VSub_Name __FLAGS_TYPE_STRING))}
                {<long-name>}
                {(SQ <foo>)}
                {(SQ <'dashed name'>)}
                {<l>}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <_flags_define>
              more_env: []
              words: [
                {<_flags_define>}
                {(DQ (${ Id.VSub_Name __FLAGS_TYPE_STRING))}
                {<long_name>}
                {(SQ <bar>)}
                {(SQ <'underscored name'>)}
                {<l>}
              ]
              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>}
                {(SQ <'_flags_define() with existing flag name should fail'>)}
                {($ Id.VSub_QMark '?')}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <assertEquals>
              more_env: []
              words: [
                {<assertEquals>}
                {(SQ <'_flags_define() should not overwrite previously defined default.'>)}
                {(DQ (${ Id.VSub_Name FLAGS_long_name))}
                {(SQ <foo>)}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <assertWarnMsg>
              more_env: []
              words: [{<assertWarnMsg>} {(SQ )} {(SQ <'already exists'>)}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <_flags_define>
              more_env: []
              words: [{<_flags_define>} {<invalid>} {<arg2>} {<arg3>} {<arg4>} {<i>}]
              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>}
                {(SQ <'_flags_define() with "invalid" type should have failed.'>)}
                {($ Id.VSub_QMark '?')}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <assertErrorMsg>
              more_env: []
              words: [{<assertErrorMsg>} {(SQ <'unrecognized flag type'>)} {(SQ <'invalid type'>)}]
              redirects: []
              do_fork: T
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name_tok: <testBoolean>
      name: testBoolean
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.ForEach
              keyword: <Id.KW_For for>
              iter_names: [default]
              iterable: (for_iter.Words words:[{(SQ <true>)} {(SQ <t>)} {<0>}])
              semi_tok: <Id.Op_Semi _>
              body: 
                (command.DoGroup
                  left: <Id.KW_Do do>
                  children: [
                    (command.Simple
                      blame_tok: <flags_reset>
                      more_env: []
                      words: [{<flags_reset>}]
                      redirects: []
                      do_fork: T
                    )
                    (command.Simple
                      blame_tok: <DEFINE_boolean>
                      more_env: []
                      words: [
                        {<DEFINE_boolean>}
                        {<boolVal>}
                        {(DQ (${ Id.VSub_Name default))}
                        {(SQ <'my boolean'>)}
                        {<b>}
                      ]
                      redirects: []
                      do_fork: T
                    )
                    (command.ShAssignment
                      left: <Id.Lit_VarLike 'rtrn='>
                      pairs: [
                        (AssignPair
                          left: <Id.Lit_VarLike 'rtrn='>
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'rtrn='> name:rtrn)
                          op: assign_op.Equal
                          rhs: {($ Id.VSub_QMark '?')}
                        )
                      ]
                      redirects: []
                    )
                    (command.Simple
                      blame_tok: <assertTrue>
                      more_env: []
                      words: [
                        {<assertTrue>}
                        {
                          (DQ <'DEFINE_boolean() call with default of \''> (${ Id.VSub_Name default) 
                            <'\' failed.'>
                          )
                        }
                        {
                          (DQ 
                            (BracedVarSub
                              left: <Id.Left_DollarBrace '${'>
                              token: <Id.VSub_Name FLAGS_boolVal>
                              var_name: FLAGS_boolVal
                              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: <assertTrue>
                      more_env: []
                      words: [
                        {<assertTrue>}
                        {
                          (DQ <'DEFINE_boolean() call with default of \''> (${ Id.VSub_Name default) 
                            <'\' returned failure.'>
                          )
                        }
                        {(${ Id.VSub_Name rtrn)}
                      ]
                      redirects: []
                      do_fork: T
                    )
                  ]
                  right: <Id.KW_Done done>
                )
              redirects: []
            )
            (command.ForEach
              keyword: <Id.KW_For for>
              iter_names: [default]
              iterable: (for_iter.Words words:[{(SQ <false>)} {(SQ <f>)} {<1>}])
              semi_tok: <Id.Op_Semi _>
              body: 
                (command.DoGroup
                  left: <Id.KW_Do do>
                  children: [
                    (command.Simple
                      blame_tok: <flags_reset>
                      more_env: []
                      words: [{<flags_reset>}]
                      redirects: []
                      do_fork: T
                    )
                    (command.Simple
                      blame_tok: <DEFINE_boolean>
                      more_env: []
                      words: [
                        {<DEFINE_boolean>}
                        {<boolVal>}
                        {(DQ (${ Id.VSub_Name default))}
                        {(SQ <'my boolean'>)}
                        {<b>}
                      ]
                      redirects: []
                      do_fork: T
                    )
                    (command.ShAssignment
                      left: <Id.Lit_VarLike 'rtrn='>
                      pairs: [
                        (AssignPair
                          left: <Id.Lit_VarLike 'rtrn='>
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'rtrn='> name:rtrn)
                          op: assign_op.Equal
                          rhs: {($ Id.VSub_QMark '?')}
                        )
                      ]
                      redirects: []
                    )
                    (command.Simple
                      blame_tok: <assertFalse>
                      more_env: []
                      words: [
                        {<assertFalse>}
                        {
                          (DQ <'DEFINE_boolean() call with default of \''> (${ Id.VSub_Name default) 
                            <'\' failed.'>
                          )
                        }
                        {
                          (DQ 
                            (BracedVarSub
                              left: <Id.Left_DollarBrace '${'>
                              token: <Id.VSub_Name FLAGS_boolVal>
                              var_name: FLAGS_boolVal
                              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: <assertTrue>
                      more_env: []
                      words: [
                        {<assertTrue>}
                        {
                          (DQ <'DEFINE_boolean() call with default of \''> (${ Id.VSub_Name default) 
                            <'\' returned failure.'>
                          )
                        }
                        {(${ Id.VSub_Name rtrn)}
                      ]
                      redirects: []
                      do_fork: T
                    )
                  ]
                  right: <Id.KW_Done done>
                )
              redirects: []
            )
            (command.Simple
              blame_tok: <flags_reset>
              more_env: []
              words: [{<flags_reset>}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <DEFINE_boolean>
              more_env: []
              words: [{<DEFINE_boolean>} {<boolVal>} {(SQ <invalid>)} {(SQ <'my boolean'>)} {<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: <assertFalse>
              more_env: []
              words: [
                {<assertFalse>}
                {(SQ <'DEFINE_boolean() call with invalid default did not fail.'>)}
                {($ Id.VSub_QMark '?')}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <assertErrorMsg>
              more_env: []
              words: [{<assertErrorMsg>}]
              redirects: []
              do_fork: T
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name_tok: <testFloat>
      name: testFloat
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.ForEach
              keyword: <Id.KW_For for>
              iter_names: [default]
              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_reset>
                      more_env: []
                      words: [{<flags_reset>}]
                      redirects: []
                      do_fork: T
                    )
                    (command.Simple
                      blame_tok: <DEFINE_float>
                      more_env: []
                      words: [
                        {<DEFINE_float>}
                        {<floatVal>}
                        {(DQ (${ Id.VSub_Name default))}
                        {(DQ <'float: '> (${ Id.VSub_Name default))}
                        {<f>}
                      ]
                      redirects: []
                      do_fork: T
                    )
                    (command.ShAssignment
                      left: <Id.Lit_VarLike 'rtrn='>
                      pairs: [
                        (AssignPair
                          left: <Id.Lit_VarLike 'rtrn='>
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'rtrn='> name:rtrn)
                          op: assign_op.Equal
                          rhs: {($ Id.VSub_QMark '?')}
                        )
                      ]
                      redirects: []
                    )
                    (command.Simple
                      blame_tok: <assertSame>
                      more_env: []
                      words: [
                        {<assertSame>}
                        {(DQ <'DEFINE_float() call with valid default failed.'>)}
                        {(DQ (${ Id.VSub_Name default))}
                        {
                          (DQ 
                            (BracedVarSub
                              left: <Id.Left_DollarBrace '${'>
                              token: <Id.VSub_Name FLAGS_floatVal>
                              var_name: FLAGS_floatVal
                              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: <assertTrue>
                      more_env: []
                      words: [
                        {<assertTrue>}
                        {
                          (DQ <'DEFINE_float() call with valid default of \''> 
                            (${ Id.VSub_Name default) <'\' returned failure.'>
                          )
                        }
                        {(${ Id.VSub_Name rtrn)}
                      ]
                      redirects: []
                      do_fork: T
                    )
                  ]
                  right: <Id.KW_Done done>
                )
              redirects: []
            )
            (command.Simple
              blame_tok: <flags_reset>
              more_env: []
              words: [{<flags_reset>}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <DEFINE_float>
              more_env: []
              words: [
                {<DEFINE_float>}
                {<floatVal>}
                {(SQ <invalid>)}
                {(SQ <'invalid float: string'>)}
                {<f>}
              ]
              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>}
                {(SQ <'DEFINE_float() call with string value default did not fail.'>)}
                {($ Id.VSub_QMark '?')}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <assertErrorMsg>
              more_env: []
              words: [{<assertErrorMsg>}]
              redirects: []
              do_fork: T
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name_tok: <testInteger>
      name: testInteger
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.ForEach
              keyword: <Id.KW_For for>
              iter_names: [default]
              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_reset>
                      more_env: []
                      words: [{<flags_reset>}]
                      redirects: []
                      do_fork: T
                    )
                    (command.Simple
                      blame_tok: <DEFINE_integer>
                      more_env: []
                      words: [
                        {<DEFINE_integer>}
                        {<intVal>}
                        {(DQ (${ Id.VSub_Name default))}
                        {(DQ <'integer: '> (${ Id.VSub_Name default))}
                        {<i>}
                      ]
                      redirects: []
                      do_fork: T
                    )
                    (command.ShAssignment
                      left: <Id.Lit_VarLike 'rtrn='>
                      pairs: [
                        (AssignPair
                          left: <Id.Lit_VarLike 'rtrn='>
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'rtrn='> name:rtrn)
                          op: assign_op.Equal
                          rhs: {($ Id.VSub_QMark '?')}
                        )
                      ]
                      redirects: []
                    )
                    (command.Simple
                      blame_tok: <assertSame>
                      more_env: []
                      words: [
                        {<assertSame>}
                        {(DQ <'DEFINE_integer() call with valid default failed.'>)}
                        {(DQ (${ Id.VSub_Name default))}
                        {
                          (DQ 
                            (BracedVarSub
                              left: <Id.Left_DollarBrace '${'>
                              token: <Id.VSub_Name FLAGS_intVal>
                              var_name: FLAGS_intVal
                              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: <assertTrue>
                      more_env: []
                      words: [
                        {<assertTrue>}
                        {
                          (DQ <'DEFINE_integer() call with valid default of \''> 
                            (${ Id.VSub_Name default) <'\' returned failure.'>
                          )
                        }
                        {(${ Id.VSub_Name rtrn)}
                      ]
                      redirects: []
                      do_fork: T
                    )
                  ]
                  right: <Id.KW_Done done>
                )
              redirects: []
            )
            (command.Simple
              blame_tok: <flags_reset>
              more_env: []
              words: [{<flags_reset>}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <DEFINE_integer>
              more_env: []
              words: [{<DEFINE_integer>} {<intVal>} {<1.234>} {(SQ <'invalid integer: float'>)} {<i>}]
              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>}
                {(SQ <'DEFINE_integer() call with float value default did not fail.'>)}
                {($ Id.VSub_QMark '?')}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <assertErrorMsg>
              more_env: []
              words: [{<assertErrorMsg>} {(SQ <'invalid default'>)} {(SQ <'float default'>)}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <DEFINE_integer>
              more_env: []
              words: [
                {<DEFINE_integer>}
                {<intVal>}
                {<-1.234>}
                {(SQ <'invalid integer: negative float'>)}
                {<i>}
              ]
              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>}
                {(SQ <'DEFINE_integer() call with negative float value default did not fail.'>)}
                {($ Id.VSub_QMark '?')}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <assertErrorMsg>
              more_env: []
              words: [{<assertErrorMsg>} {(SQ <'invalid default'>)} {(SQ <'negative float default'>)}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <DEFINE_integer>
              more_env: []
              words: [
                {<DEFINE_integer>}
                {<intVal>}
                {(SQ <invalid>)}
                {(SQ <'invalid integer: string'>)}
                {<i>}
              ]
              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>}
                {(SQ <'DEFINE_integer() call with string value default did not fail.'>)}
                {($ Id.VSub_QMark '?')}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <assertErrorMsg>
              more_env: []
              words: [{<assertErrorMsg>} {(SQ <'invalid default'>)} {(SQ <'string default'>)}]
              redirects: []
              do_fork: T
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name_tok: <testString>
      name: testString
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.ForEach
              keyword: <Id.KW_For for>
              iter_names: [default]
              iterable: 
                (for_iter.Words
                  words: [
                    {(${ Id.VSub_Name TH_BOOL_VALID)}
                    {(${ Id.VSub_Name TH_FLOAT_VALID)}
                    {(${ Id.VSub_Name TH_INT_VALID)}
                    {(SQ <'also valid'>)}
                  ]
                )
              body: 
                (command.DoGroup
                  left: <Id.KW_Do do>
                  children: [
                    (command.Simple
                      blame_tok: <flags_reset>
                      more_env: []
                      words: [{<flags_reset>}]
                      redirects: []
                      do_fork: T
                    )
                    (command.Simple
                      blame_tok: <DEFINE_string>
                      more_env: []
                      words: [
                        {<DEFINE_string>}
                        {<strVal>}
                        {(DQ (${ Id.VSub_Name default))}
                        {(DQ <'string: '> (${ Id.VSub_Name default))}
                        {<s>}
                      ]
                      redirects: []
                      do_fork: T
                    )
                    (command.ShAssignment
                      left: <Id.Lit_VarLike 'rtrn='>
                      pairs: [
                        (AssignPair
                          left: <Id.Lit_VarLike 'rtrn='>
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'rtrn='> name:rtrn)
                          op: assign_op.Equal
                          rhs: {($ Id.VSub_QMark '?')}
                        )
                      ]
                      redirects: []
                    )
                    (command.Simple
                      blame_tok: <assertSame>
                      more_env: []
                      words: [
                        {<assertSame>}
                        {(DQ <'DEFINE_string() call with valid default failed.'>)}
                        {(DQ (${ Id.VSub_Name default))}
                        {
                          (DQ 
                            (BracedVarSub
                              left: <Id.Left_DollarBrace '${'>
                              token: <Id.VSub_Name FLAGS_strVal>
                              var_name: FLAGS_strVal
                              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: <assertTrue>
                      more_env: []
                      words: [
                        {<assertTrue>}
                        {
                          (DQ <'DEFINE_string() call with valid default of \''> 
                            (${ Id.VSub_Name default) <'\' returned failure.'>
                          )
                        }
                        {(${ Id.VSub_Name rtrn)}
                      ]
                      redirects: []
                      do_fork: T
                    )
                  ]
                  right: <Id.KW_Done done>
                )
              redirects: []
            )
            (command.Simple
              blame_tok: <flags_reset>
              more_env: []
              words: [{<flags_reset>}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <DEFINE_string>
              more_env: []
              words: [{<DEFINE_string>} {<str>} {(SQ )} {(DQ <'string: empty single quotes'>)} {<s>}]
              redirects: []
              do_fork: T
            )
            (command.ShAssignment
              left: <Id.Lit_VarLike 'rtrn='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'rtrn='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'rtrn='> name:rtrn)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_QMark '?')}
                )
              ]
              redirects: []
            )
            (command.Simple
              blame_tok: <assertSame>
              more_env: []
              words: [
                {<assertSame>}
                {(DQ <'DEFINE_string() call with valid default failed.'>)}
                {(SQ )}
                {
                  (DQ 
                    (BracedVarSub
                      left: <Id.Left_DollarBrace '${'>
                      token: <Id.VSub_Name FLAGS_str>
                      var_name: FLAGS_str
                      suffix_op: (suffix_op.Unary op:<Id.VTest_ColonHyphen _> arg_word:(rhs_word__Empty))
                      right: <Id.Right_DollarBrace '}'>
                    )
                  )
                }
              ]
              redirects: []
              do_fork: T
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name_tok: <testShortNameLength>
      name: testShortNameLength
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.Simple
              blame_tok: <Id.Lit_Colon ':'>
              more_env: []
              words: [{<Id.Lit_Colon ':'>}]
              redirects: []
              do_fork: T
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name_tok: <testFlagNameIsReserved>
      name: testFlagNameIsReserved
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.Subshell
              left: <Id.Op_LParen _>
              child: 
                (command.Simple
                  blame_tok: <DEFINE_string>
                  more_env: []
                  words: [{<DEFINE_string>} {<TRUE>} {(SQ )} {(SQ <'true is a reserved flag name'>)} {<t>}]
                  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
                )
              right: <Id.Right_Subshell _>
              redirects: []
            )
            (command.ShAssignment
              left: <Id.Lit_VarLike 'rtrn='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'rtrn='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'rtrn='> name:rtrn)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_QMark '?')}
                )
              ]
              redirects: []
            )
            (command.Simple
              blame_tok: <assertEquals>
              more_env: []
              words: [{<assertEquals>} {(DQ (${ Id.VSub_Name FLAGS_ERROR))} {(DQ (${ Id.VSub_Name rtrn))}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <assertErrorMsg>
              more_env: []
              words: [{<assertErrorMsg>} {(SQ <'flag name (TRUE) is reserved'>)}]
              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
            )
          ]
          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
    )
  ]
)