(command.CommandList
  children: [
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:stdoutF)
          op: assign_op.Equal
          rhs: 
            {
              (DQ 
                (braced_var_sub
                  token: <Id.VSub_Name TMPDIR>
                  suffix_op: 
                    (suffix_op.Unary
                      op_id: Id.VTest_ColonHyphen
                      arg_word: {<Id.Lit_Slash /> <tmp>}
                    )
                ) </STDOUT>
              )
            }
          spids: [46]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:stderrF)
          op: assign_op.Equal
          rhs: 
            {
              (DQ 
                (braced_var_sub
                  token: <Id.VSub_Name TMPDIR>
                  suffix_op: 
                    (suffix_op.Unary
                      op_id: Id.VTest_ColonHyphen
                      arg_word: {<Id.Lit_Slash /> <tmp>}
                    )
                ) </STDERR>
              )
            }
          spids: [57]
        )
      ]
    )
    (C {<.>} {<./shflags_test_helpers>})
    (command.ShFunction
      name: testFlagsDefine
      body: 
        (command.BraceGroup
          children: [
            (command.Simple
              words: [{<_flags_define>}]
              redirects: [
                (redir.Redir
                  op: <Id.Redir_Great '>'>
                  fd: -1
                  arg_word: {(DQ (${ Id.VSub_Name stdoutF))}
                )
                (redir.Redir
                  op: <Id.Redir_Great '2>'>
                  fd: 2
                  arg_word: {(DQ (${ Id.VSub_Name stderrF))}
                )
              ]
            )
            (C {<assertFalse>} {(SQ <'_flags_define() with no arguments should have failed.'>)} 
              {($ Id.VSub_QMark '$?')}
            )
            (C {<assertErrorMsg>} {(SQ )} {(SQ <'no arguments'>)})
            (command.Simple
              words: [{<_flags_define>} {<arg1>}]
              redirects: [
                (redir.Redir
                  op: <Id.Redir_Great '>'>
                  fd: -1
                  arg_word: {(DQ (${ Id.VSub_Name stdoutF))}
                )
                (redir.Redir
                  op: <Id.Redir_Great '2>'>
                  fd: 2
                  arg_word: {(DQ (${ Id.VSub_Name stderrF))}
                )
              ]
            )
            (C {<assertFalse>} {(SQ <'_flags_define() call with one argument should fail'>)} 
              {($ Id.VSub_QMark '$?')}
            )
            (C {<assertErrorMsg>} {(SQ )} {(SQ <'one argument'>)})
            (command.Simple
              words: [{<_flags_define>} {<arg1>} {<arg2>}]
              redirects: [
                (redir.Redir
                  op: <Id.Redir_Great '>'>
                  fd: -1
                  arg_word: {(DQ (${ Id.VSub_Name stdoutF))}
                )
                (redir.Redir
                  op: <Id.Redir_Great '2>'>
                  fd: 2
                  arg_word: {(DQ (${ Id.VSub_Name stderrF))}
                )
              ]
            )
            (C {<assertFalse>} {(SQ <'_flags_define() call with two arguments should fail'>)} 
              {($ Id.VSub_QMark '$?')}
            )
            (C {<assertErrorMsg>} {(SQ )} {(SQ <'two arguments'>)})
            (command.Simple
              words: [{<_flags_define>} {<arg1>} {<arg2>} {<arg3>}]
              redirects: [
                (redir.Redir
                  op: <Id.Redir_Great '>'>
                  fd: -1
                  arg_word: {(DQ (${ Id.VSub_Name stdoutF))}
                )
                (redir.Redir
                  op: <Id.Redir_Great '2>'>
                  fd: 2
                  arg_word: {(DQ (${ Id.VSub_Name stderrF))}
                )
              ]
            )
            (C {<assertFalse>} {(SQ <'_flags_define() call with three arguments should fail'>)} 
              {($ Id.VSub_QMark '$?')}
            )
            (C {<assertErrorMsg>} {(SQ )} {(SQ <'three arguments'>)})
            (C {<_flags_define>} {(DQ (${ Id.VSub_Name __FLAGS_TYPE_BOOLEAN))} {<multiDefBool>} {<true>} 
              {(SQ <'multi def #1'>)} {<m>}
            )
            (command.Simple
              words: [
                {<_flags_define>}
                {(DQ (${ Id.VSub_Name __FLAGS_TYPE_BOOLEAN))}
                {<multiDefBool>}
                {<false>}
                {(SQ <'multi def #2'>)}
                {<m>}
              ]
              redirects: [
                (redir.Redir
                  op: <Id.Redir_Great '>'>
                  fd: -1
                  arg_word: {(DQ (${ Id.VSub_Name stdoutF))}
                )
                (redir.Redir
                  op: <Id.Redir_Great '2>'>
                  fd: 2
                  arg_word: {(DQ (${ Id.VSub_Name stderrF))}
                )
              ]
            )
            (C {<assertFalse>} {(SQ <'_flags_define() with existing flag name should fail'>)} 
              {($ Id.VSub_QMark '$?')}
            )
            (C {<assertTrue>} 
              {(SQ <'_flags_define() should not overwrite previously defined default.'>)} 
              {
                (DQ 
                  (braced_var_sub
                    token: <Id.VSub_Name FLAGS_multiDefBool>
                    suffix_op: (suffix_op.Unary op_id:Id.VTest_ColonHyphen arg_word:(word.Empty))
                  )
                )
              }
            )
            (C {<assertWarnMsg>} {(SQ )} {(SQ <'existing flag'>)})
            (C {<_flags_define>} {(DQ (${ Id.VSub_Name __FLAGS_TYPE_STRING))} {<long-name>} {(SQ <foo>)} 
              {(SQ <'dashed name'>)} {<l>}
            )
            (command.Simple
              words: [
                {<_flags_define>}
                {(DQ (${ Id.VSub_Name __FLAGS_TYPE_STRING))}
                {<long_name>}
                {(SQ <bar>)}
                {(SQ <'underscored name'>)}
                {<l>}
              ]
              redirects: [
                (redir.Redir
                  op: <Id.Redir_Great '>'>
                  fd: -1
                  arg_word: {(DQ (${ Id.VSub_Name stdoutF))}
                )
                (redir.Redir
                  op: <Id.Redir_Great '2>'>
                  fd: 2
                  arg_word: {(DQ (${ Id.VSub_Name stderrF))}
                )
              ]
            )
            (C {<assertFalse>} {(SQ <'_flags_define() with existing flag name should fail'>)} 
              {($ Id.VSub_QMark '$?')}
            )
            (C {<assertEquals>} 
              {(SQ <'_flags_define() should not overwrite previously defined default.'>)} {(DQ (${ Id.VSub_Name FLAGS_long_name))} {(SQ <foo>)}
            )
            (C {<assertWarnMsg>} {(SQ )} {(SQ <'already exists'>)})
            (command.Simple
              words: [{<_flags_define>} {<invalid>} {<arg2>} {<arg3>} {<arg4>} {<i>}]
              redirects: [
                (redir.Redir
                  op: <Id.Redir_Great '>'>
                  fd: -1
                  arg_word: {(DQ (${ Id.VSub_Name stdoutF))}
                )
                (redir.Redir
                  op: <Id.Redir_Great '2>'>
                  fd: 2
                  arg_word: {(DQ (${ Id.VSub_Name stderrF))}
                )
              ]
            )
            (C {<assertFalse>} {(SQ <'_flags_define() with "invalid" type should have failed.'>)} 
              {($ Id.VSub_QMark '$?')}
            )
            (C {<assertErrorMsg>} {(SQ <'unrecognized flag type'>)} {(SQ <'invalid type'>)})
          ]
        )
    )
    (command.ShFunction
      name: testBoolean
      body: 
        (command.BraceGroup
          children: [
            (command.ForEach
              iter_name: default
              iter_words: [{(SQ <true>)} {(SQ <t>)} {<0>}]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (C {<flags_reset>})
                    (C {<DEFINE_boolean>} {<boolVal>} {(DQ (${ Id.VSub_Name default))} 
                      {(SQ <'my boolean'>)} {<b>}
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:rtrn)
                          op: assign_op.Equal
                          rhs: {($ Id.VSub_QMark '$?')}
                          spids: [572]
                        )
                      ]
                    )
                    (C {<assertTrue>} 
                      {
                        (DQ <"DEFINE_boolean() call with default of '"> (${ Id.VSub_Name default) 
                          <"' failed.">
                        )
                      } 
                      {
                        (DQ 
                          (braced_var_sub
                            token: <Id.VSub_Name FLAGS_boolVal>
                            suffix_op: (suffix_op.Unary op_id:Id.VTest_ColonHyphen arg_word:(word.Empty))
                          )
                        )
                      }
                    )
                    (C {<assertTrue>} 
                      {
                        (DQ <"DEFINE_boolean() call with default of '"> (${ Id.VSub_Name default) 
                          <"' returned failure.">
                        )
                      } {(${ Id.VSub_Name rtrn)}
                    )
                  ]
                )
            )
            (command.ForEach
              iter_name: default
              iter_words: [{(SQ <false>)} {(SQ <f>)} {<1>}]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (C {<flags_reset>})
                    (C {<DEFINE_boolean>} {<boolVal>} {(DQ (${ Id.VSub_Name default))} 
                      {(SQ <'my boolean'>)} {<b>}
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:rtrn)
                          op: assign_op.Equal
                          rhs: {($ Id.VSub_QMark '$?')}
                          spids: [665]
                        )
                      ]
                    )
                    (C {<assertFalse>} 
                      {
                        (DQ <"DEFINE_boolean() call with default of '"> (${ Id.VSub_Name default) 
                          <"' failed.">
                        )
                      } 
                      {
                        (DQ 
                          (braced_var_sub
                            token: <Id.VSub_Name FLAGS_boolVal>
                            suffix_op: (suffix_op.Unary op_id:Id.VTest_ColonHyphen arg_word:(word.Empty))
                          )
                        )
                      }
                    )
                    (C {<assertTrue>} 
                      {
                        (DQ <"DEFINE_boolean() call with default of '"> (${ Id.VSub_Name default) 
                          <"' returned failure.">
                        )
                      } {(${ Id.VSub_Name rtrn)}
                    )
                  ]
                )
            )
            (C {<flags_reset>})
            (command.Simple
              words: [{<DEFINE_boolean>} {<boolVal>} {(SQ <invalid>)} {(SQ <'my boolean'>)} {<b>}]
              redirects: [
                (redir.Redir
                  op: <Id.Redir_Great '>'>
                  fd: -1
                  arg_word: {(DQ (${ Id.VSub_Name stdoutF))}
                )
                (redir.Redir
                  op: <Id.Redir_Great '2>'>
                  fd: 2
                  arg_word: {(DQ (${ Id.VSub_Name stderrF))}
                )
              ]
            )
            (C {<assertFalse>} {(SQ <'DEFINE_boolean() call with invalid default did not fail.'>)} 
              {($ Id.VSub_QMark '$?')}
            )
            (C {<assertErrorMsg>})
          ]
        )
    )
    (command.ShFunction
      name: testFloat
      body: 
        (command.BraceGroup
          children: [
            (command.ForEach
              iter_name: default
              iter_words: [{(${ Id.VSub_Name TH_FLOAT_VALID)}]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (C {<flags_reset>})
                    (C {<DEFINE_float>} {<floatVal>} {(DQ (${ Id.VSub_Name default))} 
                      {(DQ <'float: '> (${ Id.VSub_Name default))} {<f>}
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:rtrn)
                          op: assign_op.Equal
                          rhs: {($ Id.VSub_QMark '$?')}
                          spids: [812]
                        )
                      ]
                    )
                    (C {<assertSame>} {(DQ <'DEFINE_float() call with valid default failed.'>)} 
                      {(DQ (${ Id.VSub_Name default))} 
                      {
                        (DQ 
                          (braced_var_sub
                            token: <Id.VSub_Name FLAGS_floatVal>
                            suffix_op: (suffix_op.Unary op_id:Id.VTest_ColonHyphen arg_word:(word.Empty))
                          )
                        )
                      }
                    )
                    (C {<assertTrue>} 
                      {
                        (DQ <"DEFINE_float() call with valid default of '"> (${ Id.VSub_Name default) 
                          <"' returned failure.">
                        )
                      } {(${ Id.VSub_Name rtrn)}
                    )
                  ]
                )
            )
            (C {<flags_reset>})
            (command.Simple
              words: [
                {<DEFINE_float>}
                {<floatVal>}
                {(SQ <invalid>)}
                {(SQ <'invalid float: string'>)}
                {<f>}
              ]
              redirects: [
                (redir.Redir
                  op: <Id.Redir_Great '>'>
                  fd: -1
                  arg_word: {(DQ (${ Id.VSub_Name stdoutF))}
                )
                (redir.Redir
                  op: <Id.Redir_Great '2>'>
                  fd: 2
                  arg_word: {(DQ (${ Id.VSub_Name stderrF))}
                )
              ]
            )
            (C {<assertFalse>} {(SQ <'DEFINE_float() call with string value default did not fail.'>)} 
              {($ Id.VSub_QMark '$?')}
            )
            (C {<assertErrorMsg>})
          ]
        )
    )
    (command.ShFunction
      name: testInteger
      body: 
        (command.BraceGroup
          children: [
            (command.ForEach
              iter_name: default
              iter_words: [{(${ Id.VSub_Name TH_INT_VALID)}]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (C {<flags_reset>})
                    (C {<DEFINE_integer>} {<intVal>} {(DQ (${ Id.VSub_Name default))} 
                      {(DQ <'integer: '> (${ Id.VSub_Name default))} {<i>}
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:rtrn)
                          op: assign_op.Equal
                          rhs: {($ Id.VSub_QMark '$?')}
                          spids: [961]
                        )
                      ]
                    )
                    (C {<assertSame>} {(DQ <'DEFINE_integer() call with valid default failed.'>)} 
                      {(DQ (${ Id.VSub_Name default))} 
                      {
                        (DQ 
                          (braced_var_sub
                            token: <Id.VSub_Name FLAGS_intVal>
                            suffix_op: (suffix_op.Unary op_id:Id.VTest_ColonHyphen arg_word:(word.Empty))
                          )
                        )
                      }
                    )
                    (C {<assertTrue>} 
                      {
                        (DQ <"DEFINE_integer() call with valid default of '"> 
                          (${ Id.VSub_Name default) <"' returned failure.">
                        )
                      } {(${ Id.VSub_Name rtrn)}
                    )
                  ]
                )
            )
            (C {<flags_reset>})
            (command.Simple
              words: [{<DEFINE_integer>} {<intVal>} {<1.234>} {(SQ <'invalid integer: float'>)} {<i>}]
              redirects: [
                (redir.Redir
                  op: <Id.Redir_Great '>'>
                  fd: -1
                  arg_word: {(DQ (${ Id.VSub_Name stdoutF))}
                )
                (redir.Redir
                  op: <Id.Redir_Great '2>'>
                  fd: 2
                  arg_word: {(DQ (${ Id.VSub_Name stderrF))}
                )
              ]
            )
            (C {<assertFalse>} {(SQ <'DEFINE_integer() call with float value default did not fail.'>)} 
              {($ Id.VSub_QMark '$?')}
            )
            (C {<assertErrorMsg>} {(SQ <'invalid default'>)} {(SQ <'float default'>)})
            (command.Simple
              words: [
                {<DEFINE_integer>}
                {<intVal>}
                {<-1.234>}
                {(SQ <'invalid integer: negative float'>)}
                {<i>}
              ]
              redirects: [
                (redir.Redir
                  op: <Id.Redir_Great '>'>
                  fd: -1
                  arg_word: {(DQ (${ Id.VSub_Name stdoutF))}
                )
                (redir.Redir
                  op: <Id.Redir_Great '2>'>
                  fd: 2
                  arg_word: {(DQ (${ Id.VSub_Name stderrF))}
                )
              ]
            )
            (C {<assertFalse>} 
              {(SQ <'DEFINE_integer() call with negative float value default did not fail.'>)} {($ Id.VSub_QMark '$?')}
            )
            (C {<assertErrorMsg>} {(SQ <'invalid default'>)} {(SQ <'negative float default'>)})
            (command.Simple
              words: [
                {<DEFINE_integer>}
                {<intVal>}
                {(SQ <invalid>)}
                {(SQ <'invalid integer: string'>)}
                {<i>}
              ]
              redirects: [
                (redir.Redir
                  op: <Id.Redir_Great '>'>
                  fd: -1
                  arg_word: {(DQ (${ Id.VSub_Name stdoutF))}
                )
                (redir.Redir
                  op: <Id.Redir_Great '2>'>
                  fd: 2
                  arg_word: {(DQ (${ Id.VSub_Name stderrF))}
                )
              ]
            )
            (C {<assertFalse>} {(SQ <'DEFINE_integer() call with string value default did not fail.'>)} 
              {($ Id.VSub_QMark '$?')}
            )
            (C {<assertErrorMsg>} {(SQ <'invalid default'>)} {(SQ <'string default'>)})
          ]
        )
    )
    (command.ShFunction
      name: testString
      body: 
        (command.BraceGroup
          children: [
            (command.ForEach
              iter_name: default
              iter_words: [
                {(${ Id.VSub_Name TH_BOOL_VALID)}
                {(${ Id.VSub_Name TH_FLOAT_VALID)}
                {(${ Id.VSub_Name TH_INT_VALID)}
                {(SQ <'also valid'>)}
              ]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (C {<flags_reset>})
                    (C {<DEFINE_string>} {<strVal>} {(DQ (${ Id.VSub_Name default))} 
                      {(DQ <'string: '> (${ Id.VSub_Name default))} {<s>}
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:rtrn)
                          op: assign_op.Equal
                          rhs: {($ Id.VSub_QMark '$?')}
                          spids: [1248]
                        )
                      ]
                    )
                    (C {<assertSame>} {(DQ <'DEFINE_string() call with valid default failed.'>)} 
                      {(DQ (${ Id.VSub_Name default))} 
                      {
                        (DQ 
                          (braced_var_sub
                            token: <Id.VSub_Name FLAGS_strVal>
                            suffix_op: (suffix_op.Unary op_id:Id.VTest_ColonHyphen arg_word:(word.Empty))
                          )
                        )
                      }
                    )
                    (C {<assertTrue>} 
                      {
                        (DQ <"DEFINE_string() call with valid default of '"> (${ Id.VSub_Name default) 
                          <"' returned failure.">
                        )
                      } {(${ Id.VSub_Name rtrn)}
                    )
                  ]
                )
            )
            (C {<flags_reset>})
            (C {<DEFINE_string>} {<str>} {(SQ )} {(DQ <'string: empty single quotes'>)} {<s>})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:rtrn)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_QMark '$?')}
                  spids: [1320]
                )
              ]
            )
            (C {<assertSame>} {(DQ <'DEFINE_string() call with valid default failed.'>)} {(SQ )} 
              {
                (DQ 
                  (braced_var_sub
                    token: <Id.VSub_Name FLAGS_str>
                    suffix_op: (suffix_op.Unary op_id:Id.VTest_ColonHyphen arg_word:(word.Empty))
                  )
                )
              }
            )
          ]
        )
    )
    (command.ShFunction
      name: testShortNameLength
      body: (command.BraceGroup children:[(C {<Id.Lit_Other ':'>})])
    )
    (command.ShFunction
      name: testFlagNameIsReserved
      body: 
        (command.BraceGroup
          children: [
            (command.Subshell
              command_list: 
                (command.CommandList
                  children: [
                    (command.Simple
                      words: [
                        {<DEFINE_string>}
                        {<TRUE>}
                        {(SQ )}
                        {(SQ <'true is a reserved flag name'>)}
                        {<t>}
                      ]
                      redirects: [
                        (redir.Redir
                          op: <Id.Redir_Great '>'>
                          fd: -1
                          arg_word: {(DQ (${ Id.VSub_Name stdoutF))}
                        )
                        (redir.Redir
                          op: <Id.Redir_Great '2>'>
                          fd: 2
                          arg_word: {(DQ (${ Id.VSub_Name stderrF))}
                        )
                      ]
                    )
                  ]
                )
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:rtrn)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_QMark '$?')}
                  spids: [1404]
                )
              ]
            )
            (C {<assertEquals>} {(DQ (${ Id.VSub_Name FLAGS_ERROR))} {(DQ (${ Id.VSub_Name rtrn))})
            (C {<assertErrorMsg>} {(SQ <'flag name (TRUE) is reserved'>)})
          ]
        )
    )
    (command.ShFunction
      name: oneTimeSetUp
      body: (command.BraceGroup children:[(C {<th_oneTimeSetUp>})])
    )
    (command.ShFunction name:tearDown body:(command.BraceGroup children:[(C {<flags_reset>})]))
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (C {<Id.Lit_LBracket '['>} {<-n>} 
          {
            (DQ 
              (braced_var_sub
                token: <Id.VSub_Name ZSH_VERSION>
                suffix_op: (suffix_op.Unary op_id:Id.VTest_ColonHyphen arg_word:(word.Empty))
              )
            )
          } {<Id.Lit_RBracket ']'>}
        )
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:SHUNIT_PARENT)
              op: assign_op.Equal
              rhs: {($ Id.VSub_Number '$0')}
              spids: [1477]
            )
          ]
        )
      ]
    )
    (C {<.>} {(DQ (${ Id.VSub_Name TH_SHUNIT))})
  ]
)