(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: (Token id:Id.VSub_Name val:TMPDIR span_id:49)
                  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: (Token id:Id.VSub_Name val:TMPDIR span_id:60)
                  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: (Token id:Id.Redir_Great val:'>' span_id:90)
                  fd: -1
                  arg_word: {(DQ (${ Id.VSub_Name stdoutF))}
                )
                (redir.Redir
                  op: (Token id:Id.Redir_Great val:'2>' span_id:97)
                  fd: 2
                  arg_word: {(DQ (${ Id.VSub_Name stderrF))}
                )
              ]
            )
            (C {(assertFalse)} 
              {
                (SQ 
                  (Token
                    id: Id.Lit_Chars
                    val: '_flags_define() with no arguments should have failed.'
                    span_id: 108
                  )
                )
              } {($ Id.VSub_QMark '$?')}
            )
            (C {(assertErrorMsg)} {(SQ )} {(SQ (Token id:Id.Lit_Chars val:'no arguments' span_id:120))})
            (command.Simple
              words: [{(_flags_define)} {(arg1)}]
              redirects: [
                (redir.Redir
                  op: (Token id:Id.Redir_Great val:'>' span_id:133)
                  fd: -1
                  arg_word: {(DQ (${ Id.VSub_Name stdoutF))}
                )
                (redir.Redir
                  op: (Token id:Id.Redir_Great val:'2>' span_id:140)
                  fd: 2
                  arg_word: {(DQ (${ Id.VSub_Name stderrF))}
                )
              ]
            )
            (C {(assertFalse)} 
              {
                (SQ 
                  (Token
                    id: Id.Lit_Chars
                    val: '_flags_define() call with one argument should fail'
                    span_id: 151
                  )
                )
              } {($ Id.VSub_QMark '$?')}
            )
            (C {(assertErrorMsg)} {(SQ )} {(SQ (Token id:Id.Lit_Chars val:'one argument' span_id:163))})
            (command.Simple
              words: [{(_flags_define)} {(arg1)} {(arg2)}]
              redirects: [
                (redir.Redir
                  op: (Token id:Id.Redir_Great val:'>' span_id:178)
                  fd: -1
                  arg_word: {(DQ (${ Id.VSub_Name stdoutF))}
                )
                (redir.Redir
                  op: (Token id:Id.Redir_Great val:'2>' span_id:185)
                  fd: 2
                  arg_word: {(DQ (${ Id.VSub_Name stderrF))}
                )
              ]
            )
            (C {(assertFalse)} 
              {
                (SQ 
                  (Token
                    id: Id.Lit_Chars
                    val: '_flags_define() call with two arguments should fail'
                    span_id: 196
                  )
                )
              } {($ Id.VSub_QMark '$?')}
            )
            (C {(assertErrorMsg)} {(SQ )} {(SQ (Token id:Id.Lit_Chars val:'two arguments' span_id:208))})
            (command.Simple
              words: [{(_flags_define)} {(arg1)} {(arg2)} {(arg3)}]
              redirects: [
                (redir.Redir
                  op: (Token id:Id.Redir_Great val:'>' span_id:225)
                  fd: -1
                  arg_word: {(DQ (${ Id.VSub_Name stdoutF))}
                )
                (redir.Redir
                  op: (Token id:Id.Redir_Great val:'2>' span_id:232)
                  fd: 2
                  arg_word: {(DQ (${ Id.VSub_Name stderrF))}
                )
              ]
            )
            (C {(assertFalse)} 
              {
                (SQ 
                  (Token
                    id: Id.Lit_Chars
                    val: '_flags_define() call with three arguments should fail'
                    span_id: 243
                  )
                )
              } {($ Id.VSub_QMark '$?')}
            )
            (C {(assertErrorMsg)} {(SQ )} 
              {(SQ (Token id:Id.Lit_Chars val:'three arguments' span_id:255))}
            )
            (C {(_flags_define)} {(DQ (${ Id.VSub_Name __FLAGS_TYPE_BOOLEAN))} {(multiDefBool)} {(true)} 
              {(SQ (Token id:Id.Lit_Chars val:'multi def #1' span_id:277))} {(m)}
            )
            (command.Simple
              words: [
                {(_flags_define)}
                {(DQ (${ Id.VSub_Name __FLAGS_TYPE_BOOLEAN))}
                {(multiDefBool)}
                {(false)}
                {(SQ (Token id:Id.Lit_Chars val:'multi def #2' span_id:296))}
                {(m)}
              ]
              redirects: [
                (redir.Redir
                  op: (Token id:Id.Redir_Great val:'>' span_id:303)
                  fd: -1
                  arg_word: {(DQ (${ Id.VSub_Name stdoutF))}
                )
                (redir.Redir
                  op: (Token id:Id.Redir_Great val:'2>' span_id:310)
                  fd: 2
                  arg_word: {(DQ (${ Id.VSub_Name stderrF))}
                )
              ]
            )
            (C {(assertFalse)} 
              {
                (SQ 
                  (Token
                    id: Id.Lit_Chars
                    val: '_flags_define() with existing flag name should fail'
                    span_id: 321
                  )
                )
              } {($ Id.VSub_QMark '$?')}
            )
            (C {(assertTrue)} 
              {
                (SQ 
                  (Token
                    id: Id.Lit_Chars
                    val: '_flags_define() should not overwrite previously defined default.'
                    span_id: 332
                  )
                )
              } 
              {
                (DQ 
                  (braced_var_sub
                    token: (Token id:Id.VSub_Name val:FLAGS_multiDefBool span_id:339)
                    suffix_op: (suffix_op.Unary op_id:Id.VTest_ColonHyphen arg_word:(word.Empty))
                  )
                )
              }
            )
            (C {(assertWarnMsg)} {(SQ )} {(SQ (Token id:Id.Lit_Chars val:'existing flag' span_id:351))})
            (C {(_flags_define)} {(DQ (${ Id.VSub_Name __FLAGS_TYPE_STRING))} {(long-name)} 
              {(SQ (Token id:Id.Lit_Chars val:foo span_id:371))} {(SQ (Token id:Id.Lit_Chars val:'dashed name' span_id:375))} {(l)}
            )
            (command.Simple
              words: [
                {(_flags_define)}
                {(DQ (${ Id.VSub_Name __FLAGS_TYPE_STRING))}
                {(long_name)}
                {(SQ (Token id:Id.Lit_Chars val:bar span_id:392))}
                {(SQ (Token id:Id.Lit_Chars val:'underscored name' span_id:396))}
                {(l)}
              ]
              redirects: [
                (redir.Redir
                  op: (Token id:Id.Redir_Great val:'>' span_id:403)
                  fd: -1
                  arg_word: {(DQ (${ Id.VSub_Name stdoutF))}
                )
                (redir.Redir
                  op: (Token id:Id.Redir_Great val:'2>' span_id:410)
                  fd: 2
                  arg_word: {(DQ (${ Id.VSub_Name stderrF))}
                )
              ]
            )
            (C {(assertFalse)} 
              {
                (SQ 
                  (Token
                    id: Id.Lit_Chars
                    val: '_flags_define() with existing flag name should fail'
                    span_id: 421
                  )
                )
              } {($ Id.VSub_QMark '$?')}
            )
            (C {(assertEquals)} 
              {
                (SQ 
                  (Token
                    id: Id.Lit_Chars
                    val: '_flags_define() should not overwrite previously defined default.'
                    span_id: 436
                  )
                )
              } {(DQ (${ Id.VSub_Name FLAGS_long_name))} {(SQ (Token id:Id.Lit_Chars val:foo span_id:448))}
            )
            (C {(assertWarnMsg)} {(SQ )} {(SQ (Token id:Id.Lit_Chars val:'already exists' span_id:458))})
            (command.Simple
              words: [{(_flags_define)} {(invalid)} {(arg2)} {(arg3)} {(arg4)} {(i)}]
              redirects: [
                (redir.Redir
                  op: (Token id:Id.Redir_Great val:'>' span_id:484)
                  fd: -1
                  arg_word: {(DQ (${ Id.VSub_Name stdoutF))}
                )
                (redir.Redir
                  op: (Token id:Id.Redir_Great val:'2>' span_id:491)
                  fd: 2
                  arg_word: {(DQ (${ Id.VSub_Name stderrF))}
                )
              ]
            )
            (C {(assertFalse)} 
              {
                (SQ 
                  (Token
                    id: Id.Lit_Chars
                    val: '_flags_define() with "invalid" type should have failed.'
                    span_id: 502
                  )
                )
              } {($ Id.VSub_QMark '$?')}
            )
            (C {(assertErrorMsg)} 
              {(SQ (Token id:Id.Lit_Chars val:'unrecognized flag type' span_id:511))} {(SQ (Token id:Id.Lit_Chars val:'invalid type' span_id:515))}
            )
          ]
        )
    )
    (command.ShFunction
      name: testBoolean
      body: 
        (command.BraceGroup
          children: [
            (command.ForEach
              iter_name: default
              iter_words: [
                {(SQ (Token id:Id.Lit_Chars val:true span_id:539))}
                {(SQ (Token id:Id.Lit_Chars val:t span_id:543))}
                {(0)}
              ]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (C {(flags_reset)})
                    (C {(DEFINE_boolean)} {(boolVal)} {(DQ (${ Id.VSub_Name default))} 
                      {(SQ (Token id:Id.Lit_Chars val:'my boolean' span_id:566))} {(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: (Token id:Id.VSub_Name val:FLAGS_boolVal span_id:592)
                            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 (Token id:Id.Lit_Chars val:false span_id:632))}
                {(SQ (Token id:Id.Lit_Chars val:f span_id:636))}
                {(1)}
              ]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (C {(flags_reset)})
                    (C {(DEFINE_boolean)} {(boolVal)} {(DQ (${ Id.VSub_Name default))} 
                      {(SQ (Token id:Id.Lit_Chars val:'my boolean' span_id:659))} {(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: (Token id:Id.VSub_Name val:FLAGS_boolVal span_id:685)
                            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 (Token id:Id.Lit_Chars val:invalid span_id:726))}
                {(SQ (Token id:Id.Lit_Chars val:'my boolean' span_id:730))}
                {(b)}
              ]
              redirects: [
                (redir.Redir
                  op: (Token id:Id.Redir_Great val:'>' span_id:735)
                  fd: -1
                  arg_word: {(DQ (${ Id.VSub_Name stdoutF))}
                )
                (redir.Redir
                  op: (Token id:Id.Redir_Great val:'2>' span_id:742)
                  fd: 2
                  arg_word: {(DQ (${ Id.VSub_Name stderrF))}
                )
              ]
            )
            (C {(assertFalse)} 
              {
                (SQ 
                  (Token
                    id: Id.Lit_Chars
                    val: 'DEFINE_boolean() call with invalid default did not fail.'
                    span_id: 753
                  )
                )
              } {($ 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: (Token id:Id.VSub_Name val:FLAGS_floatVal span_id:832)
                            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 (Token id:Id.Lit_Chars val:invalid span_id:873))}
                {(SQ (Token id:Id.Lit_Chars val:'invalid float: string' span_id:877))}
                {(f)}
              ]
              redirects: [
                (redir.Redir
                  op: (Token id:Id.Redir_Great val:'>' span_id:884)
                  fd: -1
                  arg_word: {(DQ (${ Id.VSub_Name stdoutF))}
                )
                (redir.Redir
                  op: (Token id:Id.Redir_Great val:'2>' span_id:891)
                  fd: 2
                  arg_word: {(DQ (${ Id.VSub_Name stderrF))}
                )
              ]
            )
            (C {(assertFalse)} 
              {
                (SQ 
                  (Token
                    id: Id.Lit_Chars
                    val: 'DEFINE_float() call with string value default did not fail.'
                    span_id: 902
                  )
                )
              } {($ 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: (Token id:Id.VSub_Name val:FLAGS_intVal span_id:983)
                            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 (Token id:Id.Lit_Chars val:'invalid integer: float' span_id:1026))}
                {(i)}
              ]
              redirects: [
                (redir.Redir
                  op: (Token id:Id.Redir_Great val:'>' span_id:1033)
                  fd: -1
                  arg_word: {(DQ (${ Id.VSub_Name stdoutF))}
                )
                (redir.Redir
                  op: (Token id:Id.Redir_Great val:'2>' span_id:1040)
                  fd: 2
                  arg_word: {(DQ (${ Id.VSub_Name stderrF))}
                )
              ]
            )
            (C {(assertFalse)} 
              {
                (SQ 
                  (Token
                    id: Id.Lit_Chars
                    val: 'DEFINE_integer() call with float value default did not fail.'
                    span_id: 1051
                  )
                )
              } {($ Id.VSub_QMark '$?')}
            )
            (C {(assertErrorMsg)} {(SQ (Token id:Id.Lit_Chars val:'invalid default' span_id:1060))} 
              {(SQ (Token id:Id.Lit_Chars val:'float default' span_id:1064))}
            )
            (command.Simple
              words: [
                {(DEFINE_integer)}
                {(intVal)}
                {(-1.234)}
                {(SQ (Token id:Id.Lit_Chars val:'invalid integer: negative float' span_id:1076))}
                {(i)}
              ]
              redirects: [
                (redir.Redir
                  op: (Token id:Id.Redir_Great val:'>' span_id:1083)
                  fd: -1
                  arg_word: {(DQ (${ Id.VSub_Name stdoutF))}
                )
                (redir.Redir
                  op: (Token id:Id.Redir_Great val:'2>' span_id:1090)
                  fd: 2
                  arg_word: {(DQ (${ Id.VSub_Name stderrF))}
                )
              ]
            )
            (C {(assertFalse)} 
              {
                (SQ 
                  (Token
                    id: Id.Lit_Chars
                    val: 'DEFINE_integer() call with negative float value default did not fail.'
                    span_id: 1103
                  )
                )
              } {($ Id.VSub_QMark '$?')}
            )
            (C {(assertErrorMsg)} {(SQ (Token id:Id.Lit_Chars val:'invalid default' span_id:1114))} 
              {(SQ (Token id:Id.Lit_Chars val:'negative float default' span_id:1118))}
            )
            (command.Simple
              words: [
                {(DEFINE_integer)}
                {(intVal)}
                {(SQ (Token id:Id.Lit_Chars val:invalid span_id:1128))}
                {(SQ (Token id:Id.Lit_Chars val:'invalid integer: string' span_id:1132))}
                {(i)}
              ]
              redirects: [
                (redir.Redir
                  op: (Token id:Id.Redir_Great val:'>' span_id:1139)
                  fd: -1
                  arg_word: {(DQ (${ Id.VSub_Name stdoutF))}
                )
                (redir.Redir
                  op: (Token id:Id.Redir_Great val:'2>' span_id:1146)
                  fd: 2
                  arg_word: {(DQ (${ Id.VSub_Name stderrF))}
                )
              ]
            )
            (C {(assertFalse)} 
              {
                (SQ 
                  (Token
                    id: Id.Lit_Chars
                    val: 'DEFINE_integer() call with string value default did not fail.'
                    span_id: 1159
                  )
                )
              } {($ Id.VSub_QMark '$?')}
            )
            (C {(assertErrorMsg)} {(SQ (Token id:Id.Lit_Chars val:'invalid default' span_id:1170))} 
              {(SQ (Token id:Id.Lit_Chars val:'string default' span_id:1174))}
            )
          ]
        )
    )
    (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 (Token id:Id.Lit_Chars val:'also valid' span_id:1218))}
              ]
              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: (Token id:Id.VSub_Name val:FLAGS_strVal span_id:1270)
                            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: (Token id:Id.VSub_Name val:FLAGS_str span_id:1339)
                    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 (Token id:Id.Lit_Chars val:'true is a reserved flag name' span_id:1380))}
                        {(t)}
                      ]
                      redirects: [
                        (redir.Redir
                          op: (Token id:Id.Redir_Great val:'>' span_id:1387)
                          fd: -1
                          arg_word: {(DQ (${ Id.VSub_Name stdoutF))}
                        )
                        (redir.Redir
                          op: (Token id:Id.Redir_Great val:'2>' span_id:1394)
                          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 (Token id:Id.Lit_Chars val:'flag name (TRUE) is reserved' span_id:1426))}
            )
          ]
        )
    )
    (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: (Token id:Id.VSub_Name val:ZSH_VERSION span_id:1468)
                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))})
  ]
)