(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
                      tok: <Id.VTest_ColonHyphen ':-'>
                      arg_word: {<Id.Lit_Slash '/'> <tmp>}
                    )
                ) <'/STDOUT'>
              )
            }
          spids: [61]
        )
      ]
    )
    (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
                      tok: <Id.VTest_ColonHyphen ':-'>
                      arg_word: {<Id.Lit_Slash '/'> <tmp>}
                    )
                ) <'/STDERR'>
              )
            }
          spids: [72]
        )
      ]
    )
    (C {<.>} {<'./shflags_test_helpers'>})
    (command.ShFunction
      name: testColumns
      body: 
        (BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:cols)
                  op: assign_op.Equal
                  rhs: {(command_sub left_token:<Id.Left_Backtick '`'> child:(C {<_flags_columns>}))}
                  spids: [99]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:value)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (command_sub
                        left_token: <Id.Left_Backtick '`'>
                        child: 
                          (C {<expr>} {(DQ (${ Id.VSub_Name cols))} {<Id.Lit_Colon ':'>} 
                            {(SQ <'\\([0-9]*\\)'>)}
                          )
                      )
                    }
                  spids: [107]
                )
              ]
            )
            (C {<assertNotNull>} {(DQ <'unexpected screen width ('> (${ Id.VSub_Name cols) <')'>)} 
              {(DQ (${ Id.VSub_Name value))}
            )
          ]
        )
    )
    (command.ShFunction
      name: testGetoptVers
      body: 
        (BraceGroup
          children: [
            (command.WhileUntil
              keyword: <Id.KW_While while>
              cond: 
                (condition.Shell
                  commands: [
                    (command.Sentence
                      child: (C {<read>} {<desc>} {<mock>} {<want>})
                      terminator: <Id.Op_Semi _>
                    )
                  ]
                )
              body: 
                (command.DoGroup
                  children: [
                    (C {<assertEquals>} {(DQ (${ Id.VSub_Name desc))} 
                      {
                        (DQ 
                          (command_sub
                            left_token: <Id.Left_DollarParen '$('>
                            child: (C {<_flags_getopt_vers>} {(DQ (${ Id.VSub_Name mock))})
                          )
                        )
                      } {(DQ (${ Id.VSub_Name want))}
                    )
                  ]
                )
              redirects: [
                (redir
                  op: <Id.Redir_DLess '<<'>
                  loc: (redir_loc.Fd fd:0)
                  arg: 
                    (redir_param.HereDoc
                      here_begin: {<EOF>}
                      here_end_span_id: 218
                      stdin_parts: [
                        <'standard mock_getopt_std '>
                        (${ Id.VSub_Name __FLAGS_GETOPT_VERS_STD)
                        <'\n'>
                        <'enhanced mock_getopt_enh '>
                        (${ Id.VSub_Name __FLAGS_GETOPT_VERS_ENH)
                        <'\n'>
                      ]
                    )
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: mock_getopt_std
      body: 
        (BraceGroup
          children: [
            (command.Sentence
              child: (C {<echo>} {(SQ <' -- --foo'>)})
              terminator: <Id.Op_Semi _>
            )
            (command.Sentence
              child: (command.ControlFlow token:<Id.ControlFlow_Return return> arg_word:{<0>})
              terminator: <Id.Op_Semi _>
            )
          ]
        )
    )
    (command.ShFunction
      name: mock_getopt_enh
      body: 
        (BraceGroup
          children: [
            (command.Sentence
              child: (C {<echo>} {(SQ <' --foo --'>)})
              terminator: <Id.Op_Semi _>
            )
            (command.Sentence
              child: (command.ControlFlow token:<Id.ControlFlow_Return return> arg_word:{<0>})
              terminator: <Id.Op_Semi _>
            )
          ]
        )
    )
    (command.ShFunction
      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'>)})
          ]
        )
    )
    (command.ShFunction
      name: _testGenOptStr
      body: 
        (BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:short)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_Number '$1')}
                  spids: [422]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:long)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_Number '$2')}
                  spids: [426]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:result)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        child: (C {<_flags_genOptStr>} {(DQ (${ Id.VSub_Name __FLAGS_OPTSTR_SHORT))})
                      )
                    }
                  spids: [431]
                )
              ]
            )
            (C {<assertTrue>} {(SQ <'short option string generation failed'>)} {($ Id.VSub_QMark '$?')})
            (C {<assertEquals>} {(DQ (${ Id.VSub_Name short))} {(DQ (${ Id.VSub_Name result))})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:result)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (command_sub
                        left_token: <Id.Left_Backtick '`'>
                        child: (C {<_flags_genOptStr>} {(DQ (${ Id.VSub_Name __FLAGS_OPTSTR_LONG))})
                      )
                    }
                  spids: [468]
                )
              ]
            )
            (C {<assertTrue>} {(SQ <'long option string generation failed'>)} {($ Id.VSub_QMark '$?')})
            (C {<assertEquals>} {(DQ (${ Id.VSub_Name long))} {(DQ (${ Id.VSub_Name result))})
          ]
        )
    )
    (command.ShFunction
      name: testGetFlagInfo
      body: 
        (BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:__flags_blah_foobar)
                  op: assign_op.Equal
                  rhs: {(SQ <1234>)}
                  spids: [515]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:rslt)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (command_sub
                        left_token: <Id.Left_Backtick '`'>
                        child: (C {<_flags_getFlagInfo>} {(SQ <blah>)} {(SQ <foobar>)})
                      )
                    }
                  spids: [522]
                )
              ]
            )
            (C {<assertTrue>} {(SQ <'request for valid flag info failed'>)} {($ Id.VSub_QMark '$?')})
            (C {<assertEquals>} {(SQ <'invalid flag info returned'>)} 
              {(DQ (${ Id.VSub_Name __flags_blah_foobar))} {(DQ (${ Id.VSub_Name rslt))}
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:rslt)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (command_sub
                        left_token: <Id.Left_Backtick '`'>
                        child: 
                          (command.Simple
                            words: [{<_flags_getFlagInfo>} {(SQ <blah>)} {(SQ <hubbabubba>)}]
                            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
                          )
                      )
                    }
                  spids: [567]
                )
              ]
            )
            (C {<assertEquals>} {(SQ <'invalid flag did not result in an error'>)} 
              {(DQ (${ Id.VSub_Name FLAGS_ERROR))} {($ Id.VSub_QMark '$?')}
            )
            (C {<assertErrorMsg>} {(SQ <'missing flag info variable'>)})
          ]
        )
    )
    (command.ShFunction
      name: testItemInList
      body: 
        (BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:list)
                  op: assign_op.Equal
                  rhs: {(SQ <'this is a test'>)}
                  spids: [628]
                )
              ]
            )
            (command.WhileUntil
              keyword: <Id.KW_While while>
              cond: 
                (condition.Shell
                  commands: [
                    (command.Sentence
                      child: (C {<read>} {<desc>} {<item>} {<want>})
                      terminator: <Id.Op_Semi _>
                    )
                  ]
                )
              body: 
                (command.DoGroup
                  children: [
                    (C {<_flags_itemInList>} {(DQ (${ Id.VSub_Name item))} {(DQ (${ Id.VSub_Name list))})
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:got)
                          op: assign_op.Equal
                          rhs: {($ Id.VSub_QMark '$?')}
                          spids: [667]
                        )
                      ]
                    )
                    (C {<assertEquals>} 
                      {(DQ (${ Id.VSub_Name desc) <': itemInList('> (${ Id.VSub_Name item) <')'>)} {(DQ (${ Id.VSub_Name got))} {(DQ (${ Id.VSub_Name want))}
                    )
                  ]
                )
              redirects: [
                (redir
                  op: <Id.Redir_DLess '<<'>
                  loc: (redir_loc.Fd fd:0)
                  arg: 
                    (redir_param.HereDoc
                      here_begin: {<EOF>}
                      here_end_span_id: 743
                      stdin_parts: [
                        <'lead_item       this  '>
                        (${ Id.VSub_Name FLAGS_TRUE)
                        <'\n'>
                        <'middle_item     is    '>
                        (${ Id.VSub_Name FLAGS_TRUE)
                        <'\n'>
                        <'last_item       test  '>
                        (${ Id.VSub_Name FLAGS_TRUE)
                        <'\n'>
                        <'missing_item    asdf  '>
                        (${ Id.VSub_Name FLAGS_FALSE)
                        <'\n'>
                        <'test_partial_te te    '>
                        (${ Id.VSub_Name FLAGS_FALSE)
                        <'\n'>
                        <'test_partial_es es    '>
                        (${ Id.VSub_Name FLAGS_FALSE)
                        <'\n'>
                        <'test_partial_st st    '>
                        (${ Id.VSub_Name FLAGS_FALSE)
                        <'\n'>
                        <'empty_item      \'\'    '>
                        (${ Id.VSub_Name FLAGS_FALSE)
                        <'\n'>
                      ]
                    )
                )
              ]
            )
            (C {<_flags_itemInList>} {(SQ <item>)} {(SQ )})
            (C {<assertFalse>} {(SQ <'empty lists should not match'>)} {($ Id.VSub_QMark '$?')})
          ]
        )
    )
    (command.ShFunction
      name: testValidBool
      body: 
        (BraceGroup
          children: [
            (command.ForEach
              iter_name: value
              iter_words: [{(${ Id.VSub_Name TH_BOOL_VALID)}]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (C {<_flags_validBool>} {(DQ (${ Id.VSub_Name value))})
                    (C {<assertTrue>} 
                      {(DQ <'valid value ('> (${ Id.VSub_Name value) <') did not validate'>)} {($ Id.VSub_QMark '$?')}
                    )
                  ]
                )
            )
            (command.ForEach
              iter_name: value
              iter_words: [{(${ Id.VSub_Name TH_BOOL_INVALID)}]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (C {<_flags_validBool>} {(DQ (${ Id.VSub_Name value))})
                    (C {<assertFalse>} 
                      {(DQ <'invalid value ('> (${ Id.VSub_Name value) <') validated'>)} {($ Id.VSub_QMark '$?')}
                    )
                  ]
                )
            )
          ]
        )
    )
    (command.ShFunction
      name: _testValidFloat
      body: 
        (BraceGroup
          children: [
            (command.ForEach
              iter_name: value
              iter_words: [{(${ Id.VSub_Name TH_INT_VALID)} {(${ Id.VSub_Name TH_FLOAT_VALID)}]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (C {<_flags_validFloat>} {(DQ (${ Id.VSub_Name value))})
                    (C {<assertTrue>} 
                      {(DQ <'valid value ('> (${ Id.VSub_Name value) <') did not validate'>)} {($ Id.VSub_QMark '$?')}
                    )
                  ]
                )
            )
            (command.ForEach
              iter_name: value
              iter_words: [{(${ Id.VSub_Name TH_FLOAT_INVALID)}]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (C {<_flags_validFloat>} {(DQ (${ Id.VSub_Name value))})
                    (C {<assertFalse>} 
                      {(DQ <'invalid value ('> (${ Id.VSub_Name value) <') validated'>)} {($ Id.VSub_QMark '$?')}
                    )
                  ]
                )
            )
          ]
        )
    )
    (command.ShFunction
      name: testValidFloatBuiltin
      body: 
        (BraceGroup
          children: [
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [(C {<_flags_useBuiltin>}) (C {<startSkipping>})]
            )
            (C {<_testValidFloat>})
          ]
        )
    )
    (command.ShFunction
      name: testValidFloatExpr
      body: 
        (BraceGroup
          children: [
            (command.Subshell
              child: 
                (command.CommandList
                  children: [
                    (command.ShFunction
                      name: _flags_useBuiltin
                      body: 
                        (BraceGroup
                          children: [
                            (command.Sentence
                              child: 
                                (command.ControlFlow
                                  token: <Id.ControlFlow_Return return>
                                  arg_word: {(DQ (${ Id.VSub_Name FLAGS_FALSE))}
                                )
                              terminator: <Id.Op_Semi _>
                            )
                          ]
                        )
                    )
                    (C {<_testValidFloat>})
                  ]
                )
            )
          ]
        )
    )
    (command.ShFunction
      name: _testValidInt
      body: 
        (BraceGroup
          children: [
            (command.ForEach
              iter_name: value
              iter_words: [{(${ Id.VSub_Name TH_INT_VALID)}]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (C {<_flags_validInt>} {(DQ (${ Id.VSub_Name value))})
                    (C {<assertTrue>} 
                      {(DQ <'valid value ('> (${ Id.VSub_Name value) <') did not validate'>)} {($ Id.VSub_QMark '$?')}
                    )
                  ]
                )
            )
            (command.ForEach
              iter_name: value
              iter_words: [{(${ Id.VSub_Name TH_INT_INVALID)}]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (C {<_flags_validInt>} {(DQ (${ Id.VSub_Name value))})
                    (C {<assertFalse>} 
                      {(DQ <'invalid value ('> (${ Id.VSub_Name value) <') should not validate'>)} {($ Id.VSub_QMark '$?')}
                    )
                  ]
                )
            )
          ]
        )
    )
    (command.ShFunction
      name: testValidIntBuiltin
      body: 
        (BraceGroup
          children: [
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [(C {<_flags_useBuiltin>}) (C {<startSkipping>})]
            )
            (C {<_testValidInt>})
          ]
        )
    )
    (command.ShFunction
      name: testValidIntExpr
      body: 
        (BraceGroup
          children: [
            (command.Subshell
              child: 
                (command.CommandList
                  children: [
                    (command.ShFunction
                      name: _flags_useBuiltin
                      body: 
                        (BraceGroup
                          children: [
                            (command.Sentence
                              child: 
                                (command.ControlFlow
                                  token: <Id.ControlFlow_Return return>
                                  arg_word: {(DQ (${ Id.VSub_Name FLAGS_FALSE))}
                                )
                              terminator: <Id.Op_Semi _>
                            )
                          ]
                        )
                    )
                    (C {<_testValidInt>})
                  ]
                )
            )
          ]
        )
    )
    (command.ShFunction
      name: _testMath
      body: 
        (BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:result)
                  op: assign_op.Equal
                  rhs: {(command_sub left_token:<Id.Left_Backtick '`'> child:(C {<_flags_math>} {<1>}))}
                  spids: [1176]
                )
              ]
            )
            (C {<assertTrue>} {(SQ <'1 failed'>)} {($ Id.VSub_QMark '$?')})
            (C {<assertEquals>} {(SQ <1>)} {<1>} {(DQ (${ Id.VSub_Name result))})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:result)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (command_sub
                        left_token: <Id.Left_Backtick '`'>
                        child: (C {<_flags_math>} {(SQ <'1 + 2'>)})
                      )
                    }
                  spids: [1211]
                )
              ]
            )
            (C {<assertTrue>} {(SQ <'1+2 failed'>)} {($ Id.VSub_QMark '$?')})
            (C {<assertEquals>} {(SQ <'1+2'>)} {<3>} {(DQ (${ Id.VSub_Name result))})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:result)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (command_sub
                        left_token: <Id.Left_Backtick '`'>
                        child: (C {<_flags_math>} {(SQ <'1 + 2 + 3'>)})
                      )
                    }
                  spids: [1248]
                )
              ]
            )
            (C {<assertTrue>} {(SQ <'1+2+3 failed'>)} {($ Id.VSub_QMark '$?')})
            (C {<assertEquals>} {(SQ <'1+2+3'>)} {<6>} {(DQ (${ Id.VSub_Name result))})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:result)
                  op: assign_op.Equal
                  rhs: {(command_sub left_token:<Id.Left_Backtick '`'> child:(C {<_flags_math>}))}
                  spids: [1285]
                )
              ]
            )
            (C {<assertFalse>} {(SQ <'missing math succeeded'>)} {($ Id.VSub_QMark '$?')})
          ]
        )
    )
    (command.ShFunction
      name: testMathBuiltin
      body: 
        (BraceGroup
          children: [
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [(C {<_flags_useBuiltin>}) (C {<startSkipping>})]
            )
            (C {<_testMath>})
          ]
        )
    )
    (command.ShFunction
      name: testMathExpr
      body: 
        (BraceGroup
          children: [
            (command.Subshell
              child: 
                (command.CommandList
                  children: [
                    (command.ShFunction
                      name: _flags_useBuiltin
                      body: 
                        (BraceGroup
                          children: [
                            (command.Sentence
                              child: 
                                (command.ControlFlow
                                  token: <Id.ControlFlow_Return return>
                                  arg_word: {(DQ (${ Id.VSub_Name FLAGS_FALSE))}
                                )
                              terminator: <Id.Op_Semi _>
                            )
                          ]
                        )
                    )
                    (C {<_testMath>})
                  ]
                )
            )
          ]
        )
    )
    (command.ShFunction
      name: _testStrlen
      body: 
        (BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:len)
                  op: assign_op.Equal
                  rhs: {(command_sub left_token:<Id.Left_Backtick '`'> child:(C {<_flags_strlen>}))}
                  spids: [1366]
                )
              ]
            )
            (C {<assertTrue>} {(SQ <'missing argument failed'>)} {($ Id.VSub_QMark '$?')})
            (C {<assertEquals>} {(SQ <'missing argument'>)} {<0>} {(DQ (${ Id.VSub_Name len))})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:len)
                  op: assign_op.Equal
                  rhs: {(command_sub left_token:<Id.Left_Backtick '`'> child:(C {<_flags_strlen>} {(SQ )}))}
                  spids: [1399]
                )
              ]
            )
            (C {<assertTrue>} {(SQ <'empty argument failed'>)} {($ Id.VSub_QMark '$?')})
            (C {<assertEquals>} {(SQ <'empty argument'>)} {<0>} {(DQ (${ Id.VSub_Name len))})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:len)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (command_sub
                        left_token: <Id.Left_Backtick '`'>
                        child: (C {<_flags_strlen>} {<abc123>})
                      )
                    }
                  spids: [1435]
                )
              ]
            )
            (C {<assertTrue>} {(SQ <'single-word failed'>)} {($ Id.VSub_QMark '$?')})
            (C {<assertEquals>} {(SQ <single-word>)} {<6>} {(DQ (${ Id.VSub_Name len))})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:len)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (command_sub
                        left_token: <Id.Left_Backtick '`'>
                        child: (C {<_flags_strlen>} {(SQ <'This is a test'>)})
                      )
                    }
                  spids: [1470]
                )
              ]
            )
            (C {<assertTrue>} {(SQ <'multi-word failed'>)} {($ Id.VSub_QMark '$?')})
            (C {<assertEquals>} {(SQ <multi-word>)} {<14>} {(DQ (${ Id.VSub_Name len))})
          ]
        )
    )
    (command.ShFunction
      name: testStrlenBuiltin
      body: 
        (BraceGroup
          children: [
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [(C {<_flags_useBuiltin>}) (C {<startSkipping>})]
            )
            (C {<_testStrlen>})
          ]
        )
    )
    (command.ShFunction
      name: testStrlenExpr
      body: 
        (BraceGroup
          children: [
            (command.Subshell
              child: 
                (command.CommandList
                  children: [
                    (command.ShFunction
                      name: _flags_useBuiltin
                      body: 
                        (BraceGroup
                          children: [
                            (command.Sentence
                              child: 
                                (command.ControlFlow
                                  token: <Id.ControlFlow_Return return>
                                  arg_word: {(DQ (${ Id.VSub_Name FLAGS_FALSE))}
                                )
                              terminator: <Id.Op_Semi _>
                            )
                          ]
                        )
                    )
                    (C {<_testStrlen>})
                  ]
                )
            )
          ]
        )
    )
    (command.ShFunction
      name: oneTimeSetUp
      body: 
        (BraceGroup
          children: [
            (C {<th_oneTimeSetUp>})
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (C {<_flags_useBuiltin>})
                (C {<th_warn>} {(SQ <'Shell built-ins not supported. Some tests will be skipped.'>)})
              ]
            )
          ]
        )
    )
    (command.ShFunction name:tearDown body:(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 tok:<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: [1622]
            )
          ]
        )
      ]
    )
    (C {<.>} {(DQ (${ Id.VSub_Name TH_SHUNIT))})
  ]
)