(CommandList
  children: [
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:stdoutF)
          op: Equal
          rhs: 
            {
              (DQ 
                (BracedVarSub
                  token: <VSub_Name TMPDIR>
                  suffix_op: (StringUnary op_id:VTest_ColonHyphen arg_word:{(Lit_Slash /) (tmp)})
                  spids: [63 68]
                ) (/STDOUT)
              )
            }
          spids: [61]
        )
      ]
      spids: [61]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:stderrF)
          op: Equal
          rhs: 
            {
              (DQ 
                (BracedVarSub
                  token: <VSub_Name TMPDIR>
                  suffix_op: (StringUnary op_id:VTest_ColonHyphen arg_word:{(Lit_Slash /) (tmp)})
                  spids: [74 79]
                ) (/STDERR)
              )
            }
          spids: [72]
        )
      ]
      spids: [72]
    )
    (C {(.)} {(./shflags_test_helpers)})
    (FuncDef
      name: testColumns
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:cols)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: (CommandList children:[(C {(_flags_columns)})])
                        left_token: <Left_Backtick '`'>
                        spids: [100 102]
                      )
                    }
                  spids: [99]
                )
              ]
              spids: [99]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:value)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [
                              (C {(expr)} {(DQ (${ VSub_Name cols))} {(Lit_Other ':')} 
                                {(SQ <'\\([0-9]*\\)'>)}
                              )
                            ]
                          )
                        left_token: <Left_Backtick '`'>
                        spids: [106 120]
                      )
                    }
                  spids: [105]
                )
              ]
              spids: [105]
            )
            (C {(assertNotNull)} {(DQ ('unexpected screen width (') (${ VSub_Name cols) (')'))} 
              {(DQ (${ VSub_Name value))}
            )
          ]
          spids: [96]
        )
      spids: [92 95]
    )
    (FuncDef
      name: testGetoptVers
      body: 
        (BraceGroup
          children: [
            (While
              cond: [(Sentence child:(C {(read)} {(desc)} {(mock)} {(want)}) terminator:<Op_Semi ';'>)]
              body: 
                (DoGroup
                  children: [
                    (C {(assertEquals)} {(DQ (${ VSub_Name desc))} 
                      {
                        (DQ 
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [(C {(_flags_getopt_vers)} {(DQ (${ VSub_Name mock))})]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [176 184]
                          )
                        )
                      } {(DQ (${ VSub_Name want))}
                    )
                  ]
                  spids: [164 194]
                )
              redirects: [
                (HereDoc
                  op_id: Redir_DLess
                  fd: 16777215
                  body: 
                    {
                      (DQ ('standard mock_getopt_std ') (${ VSub_Name __FLAGS_GETOPT_VERS_STD) ('\n') 
                        ('enhanced mock_getopt_enh ') (${ VSub_Name __FLAGS_GETOPT_VERS_ENH) ('\n')
                      )
                    }
                  do_expansion: True
                  here_end: EOF
                  was_filled: True
                  spids: [196]
                )
              ]
            )
          ]
          spids: [146]
        )
      spids: [142 145]
    )
    (FuncDef
      name: mock_getopt_std
      body: 
        (BraceGroup
          children: [
            (Sentence child:(C {(echo)} {(SQ <' -- --foo'>)}) terminator:<Op_Semi ';'>)
            (Sentence
              child: (ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
              terminator: <Op_Semi ';'>
            )
          ]
          spids: [223]
        )
      spids: [219 222]
    )
    (FuncDef
      name: mock_getopt_enh
      body: 
        (BraceGroup
          children: [
            (Sentence child:(C {(echo)} {(SQ <' --foo --'>)}) terminator:<Op_Semi ';'>)
            (Sentence
              child: (ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
              terminator: <Op_Semi ';'>
            )
          ]
          spids: [246]
        )
      spids: [242 245]
    )
    (FuncDef
      name: testGenOptStr
      body: 
        (BraceGroup
          children: [
            (C {(_testGenOptStr)} {(SQ )} {(SQ )})
            (C {(DEFINE_boolean)} {(bool)} {(false)} {(SQ <'boolean value'>)} {(b)})
            (C {(_testGenOptStr)} {(SQ <b>)} {(SQ <bool>)})
            (C {(DEFINE_float)} {(float)} {(0.0)} {(SQ <'float value'>)} {(f)})
            (C {(_testGenOptStr)} {(SQ <'bf:'>)} {(SQ <'bool,float:'>)})
            (C {(DEFINE_integer)} {(int)} {(0)} {(SQ <'integer value'>)} {(i)})
            (C {(_testGenOptStr)} {(SQ <'bf:i:'>)} {(SQ <'bool,float:,int:'>)})
            (C {(DEFINE_string)} {(str)} {(0)} {(SQ <'string value'>)} {(s)})
            (C {(_testGenOptStr)} {(SQ <'bf:i:s:'>)} {(SQ <'bool,float:,int:,str:'>)})
            (C {(DEFINE_boolean)} {(help)} {(false)} {(SQ <'show help'>)} {(h)})
            (C {(_testGenOptStr)} {(SQ <'bf:i:s:h'>)} {(SQ <'bool,float:,int:,str:,help'>)})
          ]
          spids: [267]
        )
      spids: [263 266]
    )
    (FuncDef
      name: _testGenOptStr
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:short)
                  op: Equal
                  rhs: {($ VSub_Number '$1')}
                  spids: [413]
                )
              ]
              spids: [413]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:long)
                  op: Equal
                  rhs: {($ VSub_Number '$2')}
                  spids: [417]
                )
              ]
              spids: [417]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:result)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [
                              (C {(_flags_genOptStr)} {(DQ (${ VSub_Name __FLAGS_OPTSTR_SHORT))})
                            ]
                          )
                        left_token: <Left_CommandSub '$('>
                        spids: [423 431]
                      )
                    }
                  spids: [422]
                )
              ]
              spids: [422]
            )
            (C {(assertTrue)} {(SQ <'short option string generation failed'>)} {($ VSub_QMark '$?')})
            (C {(assertEquals)} {(DQ (${ VSub_Name short))} {(DQ (${ VSub_Name result))})
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:result)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [
                              (C {(_flags_genOptStr)} {(DQ (${ VSub_Name __FLAGS_OPTSTR_LONG))})
                            ]
                          )
                        left_token: <Left_Backtick '`'>
                        spids: [460 468]
                      )
                    }
                  spids: [459]
                )
              ]
              spids: [459]
            )
            (C {(assertTrue)} {(SQ <'long option string generation failed'>)} {($ VSub_QMark '$?')})
            (C {(assertEquals)} {(DQ (${ VSub_Name long))} {(DQ (${ VSub_Name result))})
          ]
          spids: [410]
        )
      spids: [406 409]
    )
    (FuncDef
      name: testGetFlagInfo
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:__flags_blah_foobar)
                  op: Equal
                  rhs: {(SQ <1234>)}
                  spids: [504]
                )
              ]
              spids: [504]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:rslt)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [(C {(_flags_getFlagInfo)} {(SQ <blah>)} {(SQ <foobar>)})]
                          )
                        left_token: <Left_Backtick '`'>
                        spids: [512 522]
                      )
                    }
                  spids: [511]
                )
              ]
              spids: [511]
            )
            (C {(assertTrue)} {(SQ <'request for valid flag info failed'>)} {($ VSub_QMark '$?')})
            (C {(assertEquals)} {(SQ <'invalid flag info returned'>)} 
              {(DQ (${ VSub_Name __flags_blah_foobar))} {(DQ (${ VSub_Name rslt))}
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:rslt)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [
                              (SimpleCommand
                                words: [{(_flags_getFlagInfo)} {(SQ <blah>)} {(SQ <hubbabubba>)}]
                                redirects: [
                                  (Redir
                                    op_id: Redir_Great
                                    fd: 16777215
                                    arg_word: {(DQ (${ VSub_Name stdoutF))}
                                    spids: [566]
                                  )
                                  (Redir
                                    op_id: Redir_Great
                                    fd: 2
                                    arg_word: {(DQ (${ VSub_Name stderrF))}
                                    spids: [573]
                                  )
                                ]
                              )
                            ]
                          )
                        left_token: <Left_Backtick '`'>
                        spids: [555 579]
                      )
                    }
                  spids: [554]
                )
              ]
              spids: [554]
            )
            (C {(assertEquals)} {(SQ <'invalid flag did not result in an error'>)} 
              {(DQ (${ VSub_Name FLAGS_ERROR))} {($ VSub_QMark '$?')}
            )
            (C {(assertErrorMsg)} {(SQ <'missing flag info variable'>)})
          ]
          spids: [501]
        )
      spids: [497 500]
    )
    (FuncDef
      name: testItemInList
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:list)
                  op: Equal
                  rhs: {(SQ <'this is a test'>)}
                  spids: [613]
                )
              ]
              spids: [613]
            )
            (While
              cond: [(Sentence child:(C {(read)} {(desc)} {(item)} {(want)}) terminator:<Op_Semi ';'>)]
              body: 
                (DoGroup
                  children: [
                    (C {(_flags_itemInList)} {(DQ (${ VSub_Name item))} {(DQ (${ VSub_Name list))})
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:got)
                          op: Equal
                          rhs: {($ VSub_QMark '$?')}
                          spids: [652]
                        )
                      ]
                      spids: [652]
                    )
                    (C {(assertEquals)} 
                      {(DQ (${ VSub_Name desc) (': itemInList(') (${ VSub_Name item) (')'))} {(DQ (${ VSub_Name got))} {(DQ (${ VSub_Name want))}
                    )
                  ]
                  spids: [634 682]
                )
              redirects: [
                (HereDoc
                  op_id: Redir_DLess
                  fd: 16777215
                  body: 
                    {
                      (DQ ('lead_item       this  ') (${ VSub_Name FLAGS_TRUE) ('\n') 
                        ('middle_item     is    ') (${ VSub_Name FLAGS_TRUE) ('\n') ('last_item       test  ') (${ VSub_Name FLAGS_TRUE) ('\n') 
                        ('missing_item    asdf  ') (${ VSub_Name FLAGS_FALSE) ('\n') ('test_partial_te te    ') (${ VSub_Name FLAGS_FALSE) ('\n') 
                        ('test_partial_es es    ') (${ VSub_Name FLAGS_FALSE) ('\n') ('test_partial_st st    ') (${ VSub_Name FLAGS_FALSE) ('\n') 
                        ("empty_item      ''    ") (${ VSub_Name FLAGS_FALSE) ('\n')
                      )
                    }
                  do_expansion: True
                  here_end: EOF
                  was_filled: True
                  spids: [684]
                )
              ]
            )
            (C {(_flags_itemInList)} {(SQ <item>)} {(SQ )})
            (C {(assertFalse)} {(SQ <'empty lists should not match'>)} {($ VSub_QMark '$?')})
          ]
          spids: [610]
        )
      spids: [606 609]
    )
    (FuncDef
      name: testValidBool
      body: 
        (BraceGroup
          children: [
            (ForEach
              iter_name: value
              iter_words: [{(${ VSub_Name TH_BOOL_VALID)}]
              do_arg_iter: False
              body: 
                (DoGroup
                  children: [
                    (C {(_flags_validBool)} {(DQ (${ VSub_Name value))})
                    (C {(assertTrue)} 
                      {(DQ ('valid value (') (${ VSub_Name value) (') did not validate'))} {($ VSub_QMark '$?')}
                    )
                  ]
                  spids: [773 798]
                )
              spids: [767 771]
            )
            (ForEach
              iter_name: value
              iter_words: [{(${ VSub_Name TH_BOOL_INVALID)}]
              do_arg_iter: False
              body: 
                (DoGroup
                  children: [
                    (C {(_flags_validBool)} {(DQ (${ VSub_Name value))})
                    (C {(assertFalse)} {(DQ ('invalid value (') (${ VSub_Name value) (') validated'))} 
                      {($ VSub_QMark '$?')}
                    )
                  ]
                  spids: [817 842]
                )
              spids: [811 815]
            )
          ]
          spids: [755]
        )
      spids: [751 754]
    )
    (FuncDef
      name: _testValidFloat
      body: 
        (BraceGroup
          children: [
            (ForEach
              iter_name: value
              iter_words: [{(${ VSub_Name TH_INT_VALID)} {(${ VSub_Name TH_FLOAT_VALID)}]
              do_arg_iter: False
              body: 
                (DoGroup
                  children: [
                    (C {(_flags_validFloat)} {(DQ (${ VSub_Name value))})
                    (C {(assertTrue)} 
                      {(DQ ('valid value (') (${ VSub_Name value) (') did not validate'))} {($ VSub_QMark '$?')}
                    )
                  ]
                  spids: [873 898]
                )
              spids: [863 871]
            )
            (ForEach
              iter_name: value
              iter_words: [{(${ VSub_Name TH_FLOAT_INVALID)}]
              do_arg_iter: False
              body: 
                (DoGroup
                  children: [
                    (C {(_flags_validFloat)} {(DQ (${ VSub_Name value))})
                    (C {(assertFalse)} {(DQ ('invalid value (') (${ VSub_Name value) (') validated'))} 
                      {($ VSub_QMark '$?')}
                    )
                  ]
                  spids: [917 942]
                )
              spids: [911 915]
            )
          ]
          spids: [851]
        )
      spids: [847 850]
    )
    (FuncDef
      name: testValidFloatBuiltin
      body: 
        (BraceGroup
          children: [
            (AndOr
              children: [(C {(_flags_useBuiltin)}) (C {(startSkipping)})]
              op_id: Op_DPipe
            )
            (C {(_testValidFloat)})
          ]
          spids: [951]
        )
      spids: [947 950]
    )
    (FuncDef
      name: testValidFloatExpr
      body: 
        (BraceGroup
          children: [
            (Subshell
              child: 
                (CommandList
                  children: [
                    (FuncDef
                      name: _flags_useBuiltin
                      body: 
                        (BraceGroup
                          children: [
                            (Sentence
                              child: 
                                (ControlFlow
                                  token: <ControlFlow_Return return>
                                  arg_word: {(DQ (${ VSub_Name FLAGS_FALSE))}
                                )
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          spids: [980]
                        )
                      spids: [976 979]
                    )
                    (C {(_testValidFloat)})
                  ]
                )
              spids: [973 997]
            )
          ]
          spids: [970]
        )
      spids: [966 969]
    )
    (FuncDef
      name: _testValidInt
      body: 
        (BraceGroup
          children: [
            (ForEach
              iter_name: value
              iter_words: [{(${ VSub_Name TH_INT_VALID)}]
              do_arg_iter: False
              body: 
                (DoGroup
                  children: [
                    (C {(_flags_validInt)} {(DQ (${ VSub_Name value))})
                    (C {(assertTrue)} 
                      {(DQ ('valid value (') (${ VSub_Name value) (') did not validate'))} {($ VSub_QMark '$?')}
                    )
                  ]
                  spids: [1024 1049]
                )
              spids: [1018 1022]
            )
            (ForEach
              iter_name: value
              iter_words: [{(${ VSub_Name TH_INT_INVALID)}]
              do_arg_iter: False
              body: 
                (DoGroup
                  children: [
                    (C {(_flags_validInt)} {(DQ (${ VSub_Name value))})
                    (C {(assertFalse)} 
                      {(DQ ('invalid value (') (${ VSub_Name value) (') should not validate'))} {($ VSub_QMark '$?')}
                    )
                  ]
                  spids: [1068 1093]
                )
              spids: [1062 1066]
            )
          ]
          spids: [1006]
        )
      spids: [1002 1005]
    )
    (FuncDef
      name: testValidIntBuiltin
      body: 
        (BraceGroup
          children: [
            (AndOr
              children: [(C {(_flags_useBuiltin)}) (C {(startSkipping)})]
              op_id: Op_DPipe
            )
            (C {(_testValidInt)})
          ]
          spids: [1102]
        )
      spids: [1098 1101]
    )
    (FuncDef
      name: testValidIntExpr
      body: 
        (BraceGroup
          children: [
            (Subshell
              child: 
                (CommandList
                  children: [
                    (FuncDef
                      name: _flags_useBuiltin
                      body: 
                        (BraceGroup
                          children: [
                            (Sentence
                              child: 
                                (ControlFlow
                                  token: <ControlFlow_Return return>
                                  arg_word: {(DQ (${ VSub_Name FLAGS_FALSE))}
                                )
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          spids: [1131]
                        )
                      spids: [1127 1130]
                    )
                    (C {(_testValidInt)})
                  ]
                )
              spids: [1124 1148]
            )
          ]
          spids: [1121]
        )
      spids: [1117 1120]
    )
    (FuncDef
      name: _testMath
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:result)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: (CommandList children:[(C {(_flags_math)} {(1)})])
                        left_token: <Left_Backtick '`'>
                        spids: [1161 1165]
                      )
                    }
                  spids: [1160]
                )
              ]
              spids: [1160]
            )
            (C {(assertTrue)} {(SQ <'1 failed'>)} {($ VSub_QMark '$?')})
            (C {(assertEquals)} {(SQ <1>)} {(1)} {(DQ (${ VSub_Name result))})
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:result)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: (CommandList children:[(C {(_flags_math)} {(SQ <'1 + 2'>)})])
                        left_token: <Left_Backtick '`'>
                        spids: [1194 1200]
                      )
                    }
                  spids: [1193]
                )
              ]
              spids: [1193]
            )
            (C {(assertTrue)} {(SQ <'1+2 failed'>)} {($ VSub_QMark '$?')})
            (C {(assertEquals)} {(SQ <'1+2'>)} {(3)} {(DQ (${ VSub_Name result))})
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:result)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [(C {(_flags_math)} {(SQ <'1 + 2 + 3'>)})]
                          )
                        left_token: <Left_Backtick '`'>
                        spids: [1229 1235]
                      )
                    }
                  spids: [1228]
                )
              ]
              spids: [1228]
            )
            (C {(assertTrue)} {(SQ <'1+2+3 failed'>)} {($ VSub_QMark '$?')})
            (C {(assertEquals)} {(SQ <'1+2+3'>)} {(6)} {(DQ (${ VSub_Name result))})
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:result)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: (CommandList children:[(C {(_flags_math)})])
                        left_token: <Left_Backtick '`'>
                        spids: [1264 1266]
                      )
                    }
                  spids: [1263]
                )
              ]
              spids: [1263]
            )
            (C {(assertFalse)} {(SQ <'missing math succeeded'>)} {($ VSub_QMark '$?')})
          ]
          spids: [1157]
        )
      spids: [1153 1156]
    )
    (FuncDef
      name: testMathBuiltin
      body: 
        (BraceGroup
          children: [
            (AndOr
              children: [(C {(_flags_useBuiltin)}) (C {(startSkipping)})]
              op_id: Op_DPipe
            )
            (C {(_testMath)})
          ]
          spids: [1284]
        )
      spids: [1280 1283]
    )
    (FuncDef
      name: testMathExpr
      body: 
        (BraceGroup
          children: [
            (Subshell
              child: 
                (CommandList
                  children: [
                    (FuncDef
                      name: _flags_useBuiltin
                      body: 
                        (BraceGroup
                          children: [
                            (Sentence
                              child: 
                                (ControlFlow
                                  token: <ControlFlow_Return return>
                                  arg_word: {(DQ (${ VSub_Name FLAGS_FALSE))}
                                )
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          spids: [1313]
                        )
                      spids: [1309 1312]
                    )
                    (C {(_testMath)})
                  ]
                )
              spids: [1306 1330]
            )
          ]
          spids: [1303]
        )
      spids: [1299 1302]
    )
    (FuncDef
      name: _testStrlen
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:len)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: (CommandList children:[(C {(_flags_strlen)})])
                        left_token: <Left_Backtick '`'>
                        spids: [1343 1345]
                      )
                    }
                  spids: [1342]
                )
              ]
              spids: [1342]
            )
            (C {(assertTrue)} {(SQ <'missing argument failed'>)} {($ VSub_QMark '$?')})
            (C {(assertEquals)} {(SQ <'missing argument'>)} {(0)} {(DQ (${ VSub_Name len))})
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:len)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: (CommandList children:[(C {(_flags_strlen)} {(SQ )})])
                        left_token: <Left_Backtick '`'>
                        spids: [1374 1379]
                      )
                    }
                  spids: [1373]
                )
              ]
              spids: [1373]
            )
            (C {(assertTrue)} {(SQ <'empty argument failed'>)} {($ VSub_QMark '$?')})
            (C {(assertEquals)} {(SQ <'empty argument'>)} {(0)} {(DQ (${ VSub_Name len))})
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:len)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: (CommandList children:[(C {(_flags_strlen)} {(abc123)})])
                        left_token: <Left_Backtick '`'>
                        spids: [1408 1412]
                      )
                    }
                  spids: [1407]
                )
              ]
              spids: [1407]
            )
            (C {(assertTrue)} {(SQ <'single-word failed'>)} {($ VSub_QMark '$?')})
            (C {(assertEquals)} {(SQ <single-word>)} {(6)} {(DQ (${ VSub_Name len))})
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:len)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [(C {(_flags_strlen)} {(SQ <'This is a test'>)})]
                          )
                        left_token: <Left_Backtick '`'>
                        spids: [1441 1447]
                      )
                    }
                  spids: [1440]
                )
              ]
              spids: [1440]
            )
            (C {(assertTrue)} {(SQ <'multi-word failed'>)} {($ VSub_QMark '$?')})
            (C {(assertEquals)} {(SQ <multi-word>)} {(14)} {(DQ (${ VSub_Name len))})
          ]
          spids: [1339]
        )
      spids: [1335 1338]
    )
    (FuncDef
      name: testStrlenBuiltin
      body: 
        (BraceGroup
          children: [
            (AndOr
              children: [(C {(_flags_useBuiltin)}) (C {(startSkipping)})]
              op_id: Op_DPipe
            )
            (C {(_testStrlen)})
          ]
          spids: [1480]
        )
      spids: [1476 1479]
    )
    (FuncDef
      name: testStrlenExpr
      body: 
        (BraceGroup
          children: [
            (Subshell
              child: 
                (CommandList
                  children: [
                    (FuncDef
                      name: _flags_useBuiltin
                      body: 
                        (BraceGroup
                          children: [
                            (Sentence
                              child: 
                                (ControlFlow
                                  token: <ControlFlow_Return return>
                                  arg_word: {(DQ (${ VSub_Name FLAGS_FALSE))}
                                )
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          spids: [1509]
                        )
                      spids: [1505 1508]
                    )
                    (C {(_testStrlen)})
                  ]
                )
              spids: [1502 1526]
            )
          ]
          spids: [1499]
        )
      spids: [1495 1498]
    )
    (FuncDef
      name: oneTimeSetUp
      body: 
        (BraceGroup
          children: [
            (C {(th_oneTimeSetUp)})
            (AndOr
              children: [
                (C {(_flags_useBuiltin)})
                (C {(th_warn)} {(SQ <'Shell built-ins not supported. Some tests will be skipped.'>)})
              ]
              op_id: Op_DPipe
            )
          ]
          spids: [1535]
        )
      spids: [1531 1534]
    )
    (FuncDef
      name: tearDown
      body: (BraceGroup children:[(C {(flags_reset)})] spids:[1561])
      spids: [1557 1560]
    )
    (AndOr
      children: [
        (C {(Lit_Other '[')} {(-n)} 
          {
            (DQ 
              (BracedVarSub
                token: <VSub_Name ZSH_VERSION>
                suffix_op: (StringUnary op_id:VTest_ColonHyphen arg_word:{(SQ )})
                spids: [1580 1583]
              )
            )
          } {(Lit_Other ']')}
        )
        (Assignment
          keyword: Assign_None
          pairs: [
            (assign_pair
              lhs: (LhsName name:SHUNIT_PARENT)
              op: Equal
              rhs: {($ VSub_Number '$0')}
              spids: [1590]
            )
          ]
          spids: [1590]
        )
      ]
      op_id: Op_DAmp
    )
    (C {(.)} {(DQ (${ VSub_Name TH_SHUNIT))})
  ]
)