(command.CommandList
  children: [
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (C {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\['>)} {<-n>} 
          {
            (DQ 
              (braced_var_sub
                token: <Id.VSub_Name SHUNIT_VERSION>
                suffix_op: (suffix_op.Unary tok:<Id.VTest_ColonHyphen ':-'> arg_word:(word.Empty))
              )
            )
          } {<Id.Lit_RBracket ']'>}
        )
        (command.ControlFlow token:<Id.ControlFlow_Exit exit> arg_word:{<0>})
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:SHUNIT_VERSION)
          op: assign_op.Equal
          rhs: {(SQ <2.1.7pre>)}
          spids: [83]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:SHUNIT_TRUE)
          op: assign_op.Equal
          rhs: {<0>}
          spids: [92]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:SHUNIT_FALSE)
          op: assign_op.Equal
          rhs: {<1>}
          spids: [95]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:SHUNIT_ERROR)
          op: assign_op.Equal
          rhs: {<2>}
          spids: [98]
        )
      ]
    )
    (command.ShFunction
      name: _shunit_warn
      body: 
        (BraceGroup
          children: [
            (command.Sentence
              child: 
                (command.Simple
                  words: [{<echo>} {(DQ <'shunit2:WARN '> ($ Id.VSub_Star '$*'))}]
                  redirects: [(redir op:<Id.Redir_GreatAnd '>&'> loc:(redir_loc.Fd fd:1) arg:{<2>})]
                  do_fork: T
                )
              terminator: <Id.Op_Semi _>
            )
          ]
        )
    )
    (command.ShFunction
      name: _shunit_error
      body: 
        (BraceGroup
          children: [
            (command.Sentence
              child: 
                (command.Simple
                  words: [{<echo>} {(DQ <'shunit2:ERROR '> ($ Id.VSub_Star '$*'))}]
                  redirects: [(redir op:<Id.Redir_GreatAnd '>&'> loc:(redir_loc.Fd fd:1) arg:{<2>})]
                  do_fork: T
                )
              terminator: <Id.Op_Semi _>
            )
          ]
        )
    )
    (command.ShFunction
      name: _shunit_fatal
      body: 
        (BraceGroup
          children: [
            (command.Sentence
              child: 
                (command.Simple
                  words: [{<echo>} {(DQ <'shunit2:FATAL '> ($ Id.VSub_Star '$*'))}]
                  redirects: [(redir op:<Id.Redir_GreatAnd '>&'> loc:(redir_loc.Fd fd:1) arg:{<2>})]
                  do_fork: T
                )
              terminator: <Id.Op_Semi _>
            )
            (command.Sentence
              child: 
                (command.ControlFlow
                  token: <Id.ControlFlow_Exit exit>
                  arg_word: {(${ Id.VSub_Name SHUNIT_ERROR)}
                )
              terminator: <Id.Op_Semi _>
            )
          ]
        )
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:__SHUNIT_UNAME_S)
          op: assign_op.Equal
          rhs: {(command_sub left_token:<Id.Left_Backtick '`'> child:(C {<uname>} {<-s>}))}
          spids: [173]
        )
      ]
    )
    (command.Case
      to_match: {(DQ (${ Id.VSub_Name __SHUNIT_UNAME_S))}
      arms: [
        (case_arm
          pat_list: [{<BSD>}]
          action: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:__SHUNIT_CMD_EXPR)
                  op: assign_op.Equal
                  rhs: {(SQ <gexpr>)}
                  spids: [196]
                )
              ]
            )
          ]
          spids: [193 194 201 -1]
        )
        (case_arm
          pat_list: [{<Id.Lit_Star '*'>}]
          action: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:__SHUNIT_CMD_EXPR)
                  op: assign_op.Equal
                  rhs: {(SQ <expr>)}
                  spids: [207]
                )
              ]
            )
          ]
          spids: [204 205 212 -1]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:__SHUNIT_CMD_ECHO_ESC)
          op: assign_op.Equal
          rhs: {(SQ <'echo -e'>)}
          spids: [217]
        )
      ]
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (C {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\['>)} 
          {(DQ (command_sub left_token:<Id.Left_Backtick '`'> child:(C {<echo>} {<-e>} {<test>})))} {<Id.Lit_Equals '='>} {(SQ <'-e test'>)} {<Id.Lit_RBracket ']'>}
        )
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:__SHUNIT_CMD_ECHO_ESC)
              op: assign_op.Equal
              rhs: {(SQ <echo>)}
              spids: [249]
            )
          ]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:SHUNIT_CMD_EXPR)
          op: assign_op.Equal
          rhs: 
            {
              (braced_var_sub
                token: <Id.VSub_Name SHUNIT_CMD_EXPR>
                suffix_op: 
                  (suffix_op.Unary
                    tok: <Id.VTest_ColonHyphen ':-'>
                    arg_word: {(${ Id.VSub_Name __SHUNIT_CMD_EXPR)}
                  )
              )
            }
          spids: [258]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:SHUNIT_STRICT)
          op: assign_op.Equal
          rhs: 
            {
              (braced_var_sub
                token: <Id.VSub_Name SHUNIT_STRICT>
                suffix_op: 
                  (suffix_op.Unary
                    tok: <Id.VTest_ColonHyphen ':-'>
                    arg_word: {(${ Id.VSub_Name SHUNIT_TRUE)}
                  )
              )
            }
          spids: [271]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:SHUNIT_COLOR)
          op: assign_op.Equal
          rhs: 
            {
              (braced_var_sub
                token: <Id.VSub_Name SHUNIT_COLOR>
                suffix_op: (suffix_op.Unary tok:<Id.VTest_ColonHyphen ':-'> arg_word:{<auto>})
              )
            }
          spids: [284]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.Sentence
                  child: 
                    (C {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\['>)} {<-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 ']'>}
                    )
                  terminator: <Id.Op_Semi _>
                )
              ]
            )
          action: [
            (command.Pipeline
              children: [
                (C {<setopt>})
                (command.Simple
                  words: [{<grep>} {(DQ <'^shwordsplit'> <Id.Lit_Dollar '$'>)}]
                  redirects: [
                    (redir
                      op: <Id.Redir_Great '>'>
                      loc: (redir_loc.Fd fd:1)
                      arg: {<'/dev/null'>}
                    )
                  ]
                  do_fork: T
                )
              ]
              negated: F
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\['>)} 
                              {($ Id.VSub_QMark '$?')} {<-ne>} {(${ Id.VSub_Name SHUNIT_TRUE)} {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<_shunit_fatal>} 
                      {(SQ <'zsh shwordsplit option is required for proper operation'>)}
                    )
                  ]
                  spids: [328 343]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\['>)} {<-z>} 
                              {
                                (DQ 
                                  (braced_var_sub
                                    token: <Id.VSub_Name SHUNIT_PARENT>
                                    suffix_op: (suffix_op.Unary tok:<Id.VTest_ColonHyphen ':-'> arg_word:(word.Empty))
                                  )
                                )
                              } {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<_shunit_fatal>} 
                      {
                        (DQ <'zsh does not pass '> 
                          (word_part.EscapedLiteral
                            token: <Id.Lit_EscapedChar '\\$'>
                          ) <'0 through properly. please declare '> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'>) 
                          <'SHUNIT_PARENT='> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'>) <0> 
                          (word_part.EscapedLiteral
                            token: <Id.Lit_EscapedChar '\\"'>
                          ) <' before calling shUnit2'>
                        )
                      }
                    )
                  ]
                  spids: [356 372]
                )
              ]
            )
          ]
          spids: [295 311]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:__SHUNIT_MODE_SOURCED)
          op: assign_op.Equal
          rhs: {(SQ <sourced>)}
          spids: [406]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:__SHUNIT_MODE_STANDALONE)
          op: assign_op.Equal
          rhs: {(SQ <standalone>)}
          spids: [411]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:__SHUNIT_PARENT)
          op: assign_op.Equal
          rhs: 
            {
              (braced_var_sub
                token: <Id.VSub_Name SHUNIT_PARENT>
                suffix_op: 
                  (suffix_op.Unary
                    tok: <Id.VTest_ColonHyphen ':-'>
                    arg_word: {($ Id.VSub_Number '$0')}
                  )
              )
            }
          spids: [416]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:__SHUNIT_ANSI_NONE)
          op: assign_op.Equal
          rhs: {(SQ <'\\033[0m'>)}
          spids: [427]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:__SHUNIT_ANSI_RED)
          op: assign_op.Equal
          rhs: {(SQ <'\\033[1;31m'>)}
          spids: [432]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:__SHUNIT_ANSI_GREEN)
          op: assign_op.Equal
          rhs: {(SQ <'\\033[1;32m'>)}
          spids: [437]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:__SHUNIT_ANSI_YELLOW)
          op: assign_op.Equal
          rhs: {(SQ <'\\033[1;33m'>)}
          spids: [442]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:__SHUNIT_ANSI_CYAN)
          op: assign_op.Equal
          rhs: {(SQ <'\\033[1;36m'>)}
          spids: [447]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:__shunit_constants)
          op: assign_op.Equal
          rhs: 
            {
              (command_sub
                left_token: <Id.Left_Backtick '`'>
                child: 
                  (command.Pipeline
                    children: [
                      (C {<set>})
                      (C {<grep>} {(SQ <'^__SHUNIT_'>)})
                      (C {<cut>} {<-d> <Id.Lit_Equals '='>} {<-f1>})
                    ]
                    negated: F
                  )
              )
            }
          spids: [456]
        )
      ]
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (command.Pipeline
          children: [
            (C {<echo>} {(DQ (${ Id.VSub_Name __shunit_constants))})
            (command.Simple
              words: [{<grep>} {(SQ <'^Binary file'>)}]
              redirects: [(redir op:<Id.Redir_Great '>'> loc:(redir_loc.Fd fd:1) arg:{<'/dev/null'>})]
              do_fork: T
            )
          ]
          negated: F
        )
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:__shunit_constants)
              op: assign_op.Equal
              rhs: 
                {
                  (command_sub
                    left_token: <Id.Left_Backtick '`'>
                    child: 
                      (command.Pipeline
                        children: [
                          (C {<set>})
                          (C {<grep>} {<-a>} {(SQ <'^__SHUNIT_'>)})
                          (C {<cut>} {<-d> <Id.Lit_Equals '='>} {<-f1>})
                        ]
                        negated: F
                      )
                  )
                }
              spids: [500]
            )
          ]
        )
      ]
    )
    (command.ForEach
      iter_name: __shunit_const
      iter_words: [{(${ Id.VSub_Name __shunit_constants)}]
      do_arg_iter: F
      body: 
        (command.DoGroup
          children: [
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\['>)} {<-z>} 
                              {
                                (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 ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [(C {<readonly>} {(DQ (${ Id.VSub_Name __shunit_const))})]
                  spids: [538 554]
                )
              ]
              else_action: [
                (command.Case
                  to_match: {(${ Id.VSub_Name ZSH_VERSION)}
                  arms: [
                    (case_arm
                      pat_list: [
                        {<Id.Lit_LBracket '['> <123> <Id.Lit_RBracket ']'> <.> <Id.Lit_Star '*'>}
                      ]
                      action: [(C {<readonly>} {(DQ (${ Id.VSub_Name __shunit_const))})]
                      spids: [578 583 593 -1]
                    )
                    (case_arm
                      pat_list: [{<Id.Lit_Star '*'>}]
                      action: [(C {<readonly>} {<-g>} {(DQ (${ Id.VSub_Name __shunit_const))})]
                      spids: [596 597 -1 613]
                    )
                  ]
                )
              ]
            )
          ]
        )
    )
    (C {<unset>} {<__shunit_const>} {<__shunit_constants>})
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:__shunit_lineno)
          op: assign_op.Equal
          rhs: {(SQ )}
          spids: [640]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:__shunit_mode)
          op: assign_op.Equal
          rhs: {(${ Id.VSub_Name __SHUNIT_MODE_SOURCED)}
          spids: [647]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:__shunit_reportGenerated)
          op: assign_op.Equal
          rhs: {(${ Id.VSub_Name SHUNIT_FALSE)}
          spids: [655]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:__shunit_script)
          op: assign_op.Equal
          rhs: {(SQ )}
          spids: [663]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:__shunit_skip)
          op: assign_op.Equal
          rhs: {(${ Id.VSub_Name SHUNIT_FALSE)}
          spids: [670]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:__shunit_suite)
          op: assign_op.Equal
          rhs: {(SQ )}
          spids: [678]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:__shunit_ansi_none)
          op: assign_op.Equal
          rhs: {(SQ )}
          spids: [689]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:__shunit_ansi_red)
          op: assign_op.Equal
          rhs: {(SQ )}
          spids: [693]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:__shunit_ansi_green)
          op: assign_op.Equal
          rhs: {(SQ )}
          spids: [697]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:__shunit_ansi_yellow)
          op: assign_op.Equal
          rhs: {(SQ )}
          spids: [701]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:__shunit_ansi_cyan)
          op: assign_op.Equal
          rhs: {(SQ )}
          spids: [705]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:__shunit_testSuccess)
          op: assign_op.Equal
          rhs: {(${ Id.VSub_Name SHUNIT_TRUE)}
          spids: [713]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:__shunit_testsTotal)
          op: assign_op.Equal
          rhs: {<0>}
          spids: [718]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:__shunit_testsPassed)
          op: assign_op.Equal
          rhs: {<0>}
          spids: [721]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:__shunit_testsFailed)
          op: assign_op.Equal
          rhs: {<0>}
          spids: [724]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:__shunit_assertsTotal)
          op: assign_op.Equal
          rhs: {<0>}
          spids: [731]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:__shunit_assertsPassed)
          op: assign_op.Equal
          rhs: {<0>}
          spids: [734]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:__shunit_assertsFailed)
          op: assign_op.Equal
          rhs: {<0>}
          spids: [737]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:__shunit_assertsSkipped)
          op: assign_op.Equal
          rhs: {<0>}
          spids: [740]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:_SHUNIT_LINENO_)
          op: assign_op.Equal
          rhs: 
            {
              (SQ 
                <
'eval __shunit_lineno=""; if \\[ "${1:-}" = "--lineno" ]; then \\[ -n "$2" ] && __shunit_lineno="[$2] "; shift 2; fi'
                >
              )
            }
          spids: [757]
        )
      ]
    )
    (command.ShFunction
      name: assertEquals
      body: 
        (BraceGroup
          children: [
            (C {(${ Id.VSub_Name _SHUNIT_LINENO_)})
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\['>)} 
                              {($ Id.VSub_Pound '$#')} {<-lt>} {<2>} {<-o>} {($ Id.VSub_Pound '$#')} {<-gt>} {<3>} {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<_shunit_error>} 
                      {
                        (DQ <'assertEquals() requires two or three arguments; '> 
                          ($ Id.VSub_Pound '$#') <' given'>
                        )
                      }
                    )
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {(${ Id.VSub_Name SHUNIT_ERROR)}
                    )
                  ]
                  spids: [813 834]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<_shunit_shouldSkip>})
                (command.ControlFlow
                  token: <Id.ControlFlow_Return return>
                  arg_word: {(${ Id.VSub_Name SHUNIT_TRUE)}
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:shunit_message_)
                  op: assign_op.Equal
                  rhs: {(${ Id.VSub_Name __shunit_lineno)}
                  spids: [868]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\['>)} 
                              {($ Id.VSub_Pound '$#')} {<-eq>} {<3>} {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:shunit_message_)
                          op: assign_op.Equal
                          rhs: {(DQ (${ Id.VSub_Name shunit_message_) ($ Id.VSub_Number '$1'))}
                          spids: [890]
                        )
                      ]
                    )
                    (C {<shift>})
                  ]
                  spids: [874 887]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:shunit_expected_)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_Number '$1')}
                  spids: [905]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:shunit_actual_)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_Number '$2')}
                  spids: [909]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:shunit_return)
                  op: assign_op.Equal
                  rhs: {(${ Id.VSub_Name SHUNIT_TRUE)}
                  spids: [914]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\['>)} 
                              {(DQ (${ Id.VSub_Name shunit_expected_))} {<Id.Lit_Equals '='>} {(DQ (${ Id.VSub_Name shunit_actual_))} {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [(C {<_shunit_assertPass>})]
                  spids: [920 941]
                )
              ]
              else_action: [
                (C {<failNotEquals>} {(DQ (${ Id.VSub_Name shunit_message_))} 
                  {(DQ (${ Id.VSub_Name shunit_expected_))} {(DQ (${ Id.VSub_Name shunit_actual_))}
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:shunit_return)
                      op: assign_op.Equal
                      rhs: {(${ Id.VSub_Name SHUNIT_FALSE)}
                      spids: [971]
                    )
                  ]
                )
              ]
            )
            (C {<unset>} {<shunit_message_>} {<shunit_expected_>} {<shunit_actual_>})
            (command.ControlFlow
              token: <Id.ControlFlow_Return return>
              arg_word: {(${ Id.VSub_Name shunit_return)}
            )
          ]
        )
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:_ASSERT_EQUALS_)
          op: assign_op.Equal
          rhs: {(SQ <'eval assertEquals --lineno "${LINENO:-}"'>)}
          spids: [1001]
        )
      ]
    )
    (command.ShFunction
      name: assertNotEquals
      body: 
        (BraceGroup
          children: [
            (C {(${ Id.VSub_Name _SHUNIT_LINENO_)})
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\['>)} 
                              {($ Id.VSub_Pound '$#')} {<-lt>} {<2>} {<-o>} {($ Id.VSub_Pound '$#')} {<-gt>} {<3>} {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<_shunit_error>} 
                      {
                        (DQ <'assertNotEquals() requires two or three arguments; '> 
                          ($ Id.VSub_Pound '$#') <' given'>
                        )
                      }
                    )
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {(${ Id.VSub_Name SHUNIT_ERROR)}
                    )
                  ]
                  spids: [1047 1068]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<_shunit_shouldSkip>})
                (command.ControlFlow
                  token: <Id.ControlFlow_Return return>
                  arg_word: {(${ Id.VSub_Name SHUNIT_TRUE)}
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:shunit_message_)
                  op: assign_op.Equal
                  rhs: {(${ Id.VSub_Name __shunit_lineno)}
                  spids: [1102]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\['>)} 
                              {($ Id.VSub_Pound '$#')} {<-eq>} {<3>} {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:shunit_message_)
                          op: assign_op.Equal
                          rhs: {(DQ (${ Id.VSub_Name shunit_message_) ($ Id.VSub_Number '$1'))}
                          spids: [1124]
                        )
                      ]
                    )
                    (C {<shift>})
                  ]
                  spids: [1108 1121]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:shunit_expected_)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_Number '$1')}
                  spids: [1139]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:shunit_actual_)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_Number '$2')}
                  spids: [1143]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:shunit_return)
                  op: assign_op.Equal
                  rhs: {(${ Id.VSub_Name SHUNIT_TRUE)}
                  spids: [1148]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\['>)} 
                              {(DQ (${ Id.VSub_Name shunit_expected_))} {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} {(DQ (${ Id.VSub_Name shunit_actual_))} {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [(C {<_shunit_assertPass>})]
                  spids: [1154 1176]
                )
              ]
              else_action: [
                (C {<failSame>} {(DQ (${ Id.VSub_Name shunit_message_))} {(DQ ($ Id.VSub_At '$@'))})
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:shunit_return)
                      op: assign_op.Equal
                      rhs: {(${ Id.VSub_Name SHUNIT_FALSE)}
                      spids: [1198]
                    )
                  ]
                )
              ]
            )
            (C {<unset>} {<shunit_message_>} {<shunit_expected_>} {<shunit_actual_>})
            (command.ControlFlow
              token: <Id.ControlFlow_Return return>
              arg_word: {(${ Id.VSub_Name shunit_return)}
            )
          ]
        )
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:_ASSERT_NOT_EQUALS_)
          op: assign_op.Equal
          rhs: {(SQ <'eval assertNotEquals --lineno "${LINENO:-}"'>)}
          spids: [1228]
        )
      ]
    )
    (command.ShFunction
      name: assertNull
      body: 
        (BraceGroup
          children: [
            (C {(${ Id.VSub_Name _SHUNIT_LINENO_)})
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\['>)} 
                              {($ Id.VSub_Pound '$#')} {<-lt>} {<1>} {<-o>} {($ Id.VSub_Pound '$#')} {<-gt>} {<2>} {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<_shunit_error>} 
                      {
                        (DQ <'assertNull() requires one or two arguments; '> ($ Id.VSub_Pound '$#') 
                          <' given'>
                        )
                      }
                    )
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {(${ Id.VSub_Name SHUNIT_ERROR)}
                    )
                  ]
                  spids: [1271 1292]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<_shunit_shouldSkip>})
                (command.ControlFlow
                  token: <Id.ControlFlow_Return return>
                  arg_word: {(${ Id.VSub_Name SHUNIT_TRUE)}
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:shunit_message_)
                  op: assign_op.Equal
                  rhs: {(${ Id.VSub_Name __shunit_lineno)}
                  spids: [1326]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\['>)} 
                              {($ Id.VSub_Pound '$#')} {<-eq>} {<2>} {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:shunit_message_)
                          op: assign_op.Equal
                          rhs: {(DQ (${ Id.VSub_Name shunit_message_) ($ Id.VSub_Number '$1'))}
                          spids: [1348]
                        )
                      ]
                    )
                    (C {<shift>})
                  ]
                  spids: [1332 1345]
                )
              ]
            )
            (C {<assertTrue>} {(DQ (${ Id.VSub_Name shunit_message_))} 
              {(DQ <'[ -z \''> ($ Id.VSub_Number '$1') <'\' ]'>)}
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:shunit_return)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_QMark '$?')}
                  spids: [1378]
                )
              ]
            )
            (C {<unset>} {<shunit_message_>})
            (command.ControlFlow
              token: <Id.ControlFlow_Return return>
              arg_word: {(${ Id.VSub_Name shunit_return)}
            )
          ]
        )
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:_ASSERT_NULL_)
          op: assign_op.Equal
          rhs: {(SQ <'eval assertNull --lineno "${LINENO:-}"'>)}
          spids: [1399]
        )
      ]
    )
    (command.ShFunction
      name: assertNotNull
      body: 
        (BraceGroup
          children: [
            (C {(${ Id.VSub_Name _SHUNIT_LINENO_)})
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\['>)} 
                              {($ Id.VSub_Pound '$#')} {<-gt>} {<2>} {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<_shunit_error>} 
                      {
                        (DQ <'assertNotNull() requires one or two arguments; '> ($ Id.VSub_Pound '$#') 
                          <' given'>
                        )
                      }
                    )
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {(${ Id.VSub_Name SHUNIT_ERROR)}
                    )
                  ]
                  spids: [1442 1455]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<_shunit_shouldSkip>})
                (command.ControlFlow
                  token: <Id.ControlFlow_Return return>
                  arg_word: {(${ Id.VSub_Name SHUNIT_TRUE)}
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:shunit_message_)
                  op: assign_op.Equal
                  rhs: {(${ Id.VSub_Name __shunit_lineno)}
                  spids: [1492]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\['>)} 
                              {($ Id.VSub_Pound '$#')} {<-eq>} {<2>} {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:shunit_message_)
                          op: assign_op.Equal
                          rhs: {(DQ (${ Id.VSub_Name shunit_message_) ($ Id.VSub_Number '$1'))}
                          spids: [1514]
                        )
                      ]
                    )
                    (C {<shift>})
                  ]
                  spids: [1498 1511]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:shunit_actual_)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (command_sub
                        left_token: <Id.Left_Backtick '`'>
                        child: 
                          (C {<_shunit_escapeCharactersInString>} 
                            {
                              (DQ 
                                (braced_var_sub
                                  token: <Id.VSub_Number 1>
                                  suffix_op: (suffix_op.Unary tok:<Id.VTest_ColonHyphen ':-'> arg_word:(word.Empty))
                                )
                              )
                            }
                          )
                      )
                    }
                  spids: [1529]
                )
              ]
            )
            (C {<test>} {<-n>} {(DQ (${ Id.VSub_Name shunit_actual_))})
            (C {<assertTrue>} {(DQ (${ Id.VSub_Name shunit_message_))} {($ Id.VSub_QMark '$?')})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:shunit_return)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_QMark '$?')}
                  spids: [1566]
                )
              ]
            )
            (C {<unset>} {<shunit_actual_>} {<shunit_message_>})
            (command.ControlFlow
              token: <Id.ControlFlow_Return return>
              arg_word: {(${ Id.VSub_Name shunit_return)}
            )
          ]
        )
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:_ASSERT_NOT_NULL_)
          op: assign_op.Equal
          rhs: {(SQ <'eval assertNotNull --lineno "${LINENO:-}"'>)}
          spids: [1589]
        )
      ]
    )
    (command.ShFunction
      name: assertSame
      body: 
        (BraceGroup
          children: [
            (C {(${ Id.VSub_Name _SHUNIT_LINENO_)})
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\['>)} 
                              {($ Id.VSub_Pound '$#')} {<-lt>} {<2>} {<-o>} {($ Id.VSub_Pound '$#')} {<-gt>} {<3>} {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<_shunit_error>} 
                      {
                        (DQ <'assertSame() requires two or three arguments; '> ($ Id.VSub_Pound '$#') 
                          <' given'>
                        )
                      }
                    )
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {(${ Id.VSub_Name SHUNIT_ERROR)}
                    )
                  ]
                  spids: [1635 1656]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<_shunit_shouldSkip>})
                (command.ControlFlow
                  token: <Id.ControlFlow_Return return>
                  arg_word: {(${ Id.VSub_Name SHUNIT_TRUE)}
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:shunit_message_)
                  op: assign_op.Equal
                  rhs: {(${ Id.VSub_Name __shunit_lineno)}
                  spids: [1690]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\['>)} 
                              {($ Id.VSub_Pound '$#')} {<-eq>} {<3>} {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:shunit_message_)
                          op: assign_op.Equal
                          rhs: {(DQ (${ Id.VSub_Name shunit_message_) ($ Id.VSub_Number '$1'))}
                          spids: [1712]
                        )
                      ]
                    )
                    (C {<shift>})
                  ]
                  spids: [1696 1709]
                )
              ]
            )
            (C {<assertEquals>} {(DQ (${ Id.VSub_Name shunit_message_))} {(DQ ($ Id.VSub_Number '$1'))} 
              {(DQ ($ Id.VSub_Number '$2'))}
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:shunit_return)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_QMark '$?')}
                  spids: [1744]
                )
              ]
            )
            (C {<unset>} {<shunit_message_>})
            (command.ControlFlow
              token: <Id.ControlFlow_Return return>
              arg_word: {(${ Id.VSub_Name shunit_return)}
            )
          ]
        )
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:_ASSERT_SAME_)
          op: assign_op.Equal
          rhs: {(SQ <'eval assertSame --lineno "${LINENO:-}"'>)}
          spids: [1765]
        )
      ]
    )
    (command.ShFunction
      name: assertNotSame
      body: 
        (BraceGroup
          children: [
            (C {(${ Id.VSub_Name _SHUNIT_LINENO_)})
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\['>)} 
                              {($ Id.VSub_Pound '$#')} {<-lt>} {<2>} {<-o>} {($ Id.VSub_Pound '$#')} {<-gt>} {<3>} {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<_shunit_error>} 
                      {
                        (DQ <'assertNotSame() requires two or three arguments; '> 
                          ($ Id.VSub_Pound '$#') <' given'>
                        )
                      }
                    )
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {(${ Id.VSub_Name SHUNIT_ERROR)}
                    )
                  ]
                  spids: [1811 1832]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<_shunit_shouldSkip>})
                (command.ControlFlow
                  token: <Id.ControlFlow_Return return>
                  arg_word: {(${ Id.VSub_Name SHUNIT_TRUE)}
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:shunit_message_)
                  op: assign_op.Equal
                  rhs: {(${ Id.VSub_Name __shunit_lineno)}
                  spids: [1866]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\['>)} 
                              {($ Id.VSub_Pound '$#')} {<-eq>} {<3>} {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:shunit_message_)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (DQ 
                                (braced_var_sub
                                  token: <Id.VSub_Name shunit_message_>
                                  suffix_op: (suffix_op.Unary tok:<Id.VTest_ColonHyphen ':-'> arg_word:(word.Empty))
                                ) ($ Id.VSub_Number '$1')
                              )
                            }
                          spids: [1888]
                        )
                      ]
                    )
                    (C {<shift>})
                  ]
                  spids: [1872 1885]
                )
              ]
            )
            (C {<assertNotEquals>} {(DQ (${ Id.VSub_Name shunit_message_))} 
              {(DQ ($ Id.VSub_Number '$1'))} {(DQ ($ Id.VSub_Number '$2'))}
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:shunit_return)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_QMark '$?')}
                  spids: [1921]
                )
              ]
            )
            (C {<unset>} {<shunit_message_>})
            (command.ControlFlow
              token: <Id.ControlFlow_Return return>
              arg_word: {(${ Id.VSub_Name shunit_return)}
            )
          ]
        )
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:_ASSERT_NOT_SAME_)
          op: assign_op.Equal
          rhs: {(SQ <'eval assertNotSame --lineno "${LINENO:-}"'>)}
          spids: [1942]
        )
      ]
    )
    (command.ShFunction
      name: assertTrue
      body: 
        (BraceGroup
          children: [
            (C {(${ Id.VSub_Name _SHUNIT_LINENO_)})
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\['>)} 
                              {($ Id.VSub_Pound '$#')} {<-lt>} {<1>} {<-o>} {($ Id.VSub_Pound '$#')} {<-gt>} {<2>} {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<_shunit_error>} 
                      {
                        (DQ <'assertTrue() takes one or two arguments; '> ($ Id.VSub_Pound '$#') 
                          <' given'>
                        )
                      }
                    )
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {(${ Id.VSub_Name SHUNIT_ERROR)}
                    )
                  ]
                  spids: [2027 2048]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<_shunit_shouldSkip>})
                (command.ControlFlow
                  token: <Id.ControlFlow_Return return>
                  arg_word: {(${ Id.VSub_Name SHUNIT_TRUE)}
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:shunit_message_)
                  op: assign_op.Equal
                  rhs: {(${ Id.VSub_Name __shunit_lineno)}
                  spids: [2082]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\['>)} 
                              {($ Id.VSub_Pound '$#')} {<-eq>} {<2>} {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:shunit_message_)
                          op: assign_op.Equal
                          rhs: {(DQ (${ Id.VSub_Name shunit_message_) ($ Id.VSub_Number '$1'))}
                          spids: [2104]
                        )
                      ]
                    )
                    (C {<shift>})
                  ]
                  spids: [2088 2101]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:shunit_condition_)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_Number '$1')}
                  spids: [2119]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:shunit_match_)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (command_sub
                        left_token: <Id.Left_Backtick '`'>
                        child: 
                          (C {<expr>} {(DQ (${ Id.VSub_Name shunit_condition_))} {<Id.Lit_Colon ':'>} 
                            {(SQ <'\\([0-9]*\\)'>)}
                          )
                      )
                    }
                  spids: [2128]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:shunit_return)
                  op: assign_op.Equal
                  rhs: {(${ Id.VSub_Name SHUNIT_TRUE)}
                  spids: [2152]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\['>)} {<-z>} 
                              {(DQ (${ Id.VSub_Name shunit_condition_))} {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:shunit_return)
                          op: assign_op.Equal
                          rhs: {(${ Id.VSub_Name SHUNIT_FALSE)}
                          spids: [2180]
                        )
                      ]
                    )
                  ]
                  spids: [2158 2173]
                )
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (C {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\['>)} {<-n>} 
                          {(DQ (${ Id.VSub_Name shunit_match_))} {<-a>} {(DQ (${ Id.VSub_Name shunit_condition_))} {<Id.Lit_Equals '='>} 
                          {(DQ (${ Id.VSub_Name shunit_match_))} {<Id.Lit_RBracket ']'>}
                        )
                      ]
                    )
                  action: [
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (C {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\['>)} 
                          {(DQ (${ Id.VSub_Name shunit_condition_))} {<-ne>} {<0>} {<Id.Lit_RBracket ']'>}
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:shunit_return)
                              op: assign_op.Equal
                              rhs: {(${ Id.VSub_Name SHUNIT_FALSE)}
                              spids: [2240]
                            )
                          ]
                        )
                      ]
                    )
                  ]
                  spids: [2186 2217]
                )
              ]
              else_action: [
                (command.Subshell
                  child: (C {<eval>} {(DQ (${ Id.VSub_Name shunit_condition_))})
                  redirects: [
                    (redir
                      op: <Id.Redir_Great '>'>
                      loc: (redir_loc.Fd fd:1)
                      arg: {<'/dev/null'>}
                    )
                    (redir
                      op: <Id.Redir_GreatAnd '2>&'>
                      loc: (redir_loc.Fd fd:2)
                      arg: {<1>}
                    )
                  ]
                )
                (command.AndOr
                  ops: [Id.Op_DAmp]
                  children: [
                    (C {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\['>)} 
                      {($ Id.VSub_QMark '$?')} {<-ne>} {<0>} {<Id.Lit_RBracket ']'>}
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:shunit_return)
                          op: assign_op.Equal
                          rhs: {(${ Id.VSub_Name SHUNIT_FALSE)}
                          spids: [2284]
                        )
                      ]
                    )
                  ]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\['>)} 
                              {(${ Id.VSub_Name shunit_return)} {<-eq>} {(${ Id.VSub_Name SHUNIT_TRUE)} {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [(C {<_shunit_assertPass>})]
                  spids: [2298 2315]
                )
              ]
              else_action: [(C {<_shunit_assertFail>} {(DQ (${ Id.VSub_Name shunit_message_))})]
            )
            (C {<unset>} {<shunit_message_>} {<shunit_condition_>} {<shunit_match_>})
            (command.ControlFlow
              token: <Id.ControlFlow_Return return>
              arg_word: {(${ Id.VSub_Name shunit_return)}
            )
          ]
        )
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:_ASSERT_TRUE_)
          op: assign_op.Equal
          rhs: {(SQ <'eval assertTrue --lineno "${LINENO:-}"'>)}
          spids: [2357]
        )
      ]
    )
    (command.ShFunction
      name: assertFalse
      body: 
        (BraceGroup
          children: [
            (C {(${ Id.VSub_Name _SHUNIT_LINENO_)})
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\['>)} 
                              {($ Id.VSub_Pound '$#')} {<-lt>} {<1>} {<-o>} {($ Id.VSub_Pound '$#')} {<-gt>} {<2>} {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<_shunit_error>} 
                      {
                        (DQ <'assertFalse() quires one or two arguments; '> ($ Id.VSub_Pound '$#') 
                          <' given'>
                        )
                      }
                    )
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {(${ Id.VSub_Name SHUNIT_ERROR)}
                    )
                  ]
                  spids: [2442 2463]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<_shunit_shouldSkip>})
                (command.ControlFlow
                  token: <Id.ControlFlow_Return return>
                  arg_word: {(${ Id.VSub_Name SHUNIT_TRUE)}
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:shunit_message_)
                  op: assign_op.Equal
                  rhs: {(${ Id.VSub_Name __shunit_lineno)}
                  spids: [2497]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\['>)} 
                              {($ Id.VSub_Pound '$#')} {<-eq>} {<2>} {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:shunit_message_)
                          op: assign_op.Equal
                          rhs: {(DQ (${ Id.VSub_Name shunit_message_) ($ Id.VSub_Number '$1'))}
                          spids: [2519]
                        )
                      ]
                    )
                    (C {<shift>})
                  ]
                  spids: [2503 2516]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:shunit_condition_)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_Number '$1')}
                  spids: [2534]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:shunit_match_)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (command_sub
                        left_token: <Id.Left_Backtick '`'>
                        child: 
                          (C {<expr>} {(DQ (${ Id.VSub_Name shunit_condition_))} {<Id.Lit_Colon ':'>} 
                            {(SQ <'\\([0-9]*\\)'>)}
                          )
                      )
                    }
                  spids: [2543]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:shunit_return)
                  op: assign_op.Equal
                  rhs: {(${ Id.VSub_Name SHUNIT_TRUE)}
                  spids: [2567]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\['>)} {<-z>} 
                              {(DQ (${ Id.VSub_Name shunit_condition_))} {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:shunit_return)
                          op: assign_op.Equal
                          rhs: {(${ Id.VSub_Name SHUNIT_FALSE)}
                          spids: [2595]
                        )
                      ]
                    )
                  ]
                  spids: [2573 2588]
                )
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (C {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\['>)} {<-n>} 
                          {(DQ (${ Id.VSub_Name shunit_match_))} {<-a>} {(DQ (${ Id.VSub_Name shunit_condition_))} {<Id.Lit_Equals '='>} 
                          {(DQ (${ Id.VSub_Name shunit_match_))} {<Id.Lit_RBracket ']'>}
                        )
                      ]
                    )
                  action: [
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (C {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\['>)} 
                          {(DQ (${ Id.VSub_Name shunit_condition_))} {<-eq>} {<0>} {<Id.Lit_RBracket ']'>}
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:shunit_return)
                              op: assign_op.Equal
                              rhs: {(${ Id.VSub_Name SHUNIT_FALSE)}
                              spids: [2655]
                            )
                          ]
                        )
                      ]
                    )
                  ]
                  spids: [2601 2632]
                )
              ]
              else_action: [
                (command.Subshell
                  child: (C {<eval>} {(DQ (${ Id.VSub_Name shunit_condition_))})
                  redirects: [
                    (redir
                      op: <Id.Redir_Great '>'>
                      loc: (redir_loc.Fd fd:1)
                      arg: {<'/dev/null'>}
                    )
                    (redir
                      op: <Id.Redir_GreatAnd '2>&'>
                      loc: (redir_loc.Fd fd:2)
                      arg: {<1>}
                    )
                  ]
                )
                (command.AndOr
                  ops: [Id.Op_DAmp]
                  children: [
                    (C {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\['>)} 
                      {($ Id.VSub_QMark '$?')} {<-eq>} {<0>} {<Id.Lit_RBracket ']'>}
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:shunit_return)
                          op: assign_op.Equal
                          rhs: {(${ Id.VSub_Name SHUNIT_FALSE)}
                          spids: [2699]
                        )
                      ]
                    )
                  ]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\['>)} 
                              {(DQ (${ Id.VSub_Name shunit_return))} {<-eq>} {(DQ (${ Id.VSub_Name SHUNIT_TRUE))} {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [(C {<_shunit_assertPass>})]
                  spids: [2713 2734]
                )
              ]
              else_action: [(C {<_shunit_assertFail>} {(DQ (${ Id.VSub_Name shunit_message_))})]
            )
            (C {<unset>} {<shunit_message_>} {<shunit_condition_>} {<shunit_match_>})
            (command.ControlFlow
              token: <Id.ControlFlow_Return return>
              arg_word: {(DQ (${ Id.VSub_Name shunit_return))}
            )
          ]
        )
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:_ASSERT_FALSE_)
          op: assign_op.Equal
          rhs: {(SQ <'eval assertFalse --lineno "${LINENO:-}"'>)}
          spids: [2778]
        )
      ]
    )
    (command.ShFunction
      name: fail
      body: 
        (BraceGroup
          children: [
            (C {(${ Id.VSub_Name _SHUNIT_LINENO_)})
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\['>)} 
                              {($ Id.VSub_Pound '$#')} {<-gt>} {<1>} {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<_shunit_error>} 
                      {
                        (DQ <'fail() requires zero or one arguments; '> ($ Id.VSub_Pound '$#') 
                          <' given'>
                        )
                      }
                    )
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {(${ Id.VSub_Name SHUNIT_ERROR)}
                    )
                  ]
                  spids: [2828 2841]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<_shunit_shouldSkip>})
                (command.ControlFlow
                  token: <Id.ControlFlow_Return return>
                  arg_word: {(${ Id.VSub_Name SHUNIT_TRUE)}
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:shunit_message_)
                  op: assign_op.Equal
                  rhs: {(${ Id.VSub_Name __shunit_lineno)}
                  spids: [2875]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\['>)} 
                              {($ Id.VSub_Pound '$#')} {<-eq>} {<1>} {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:shunit_message_)
                          op: assign_op.Equal
                          rhs: {(DQ (${ Id.VSub_Name shunit_message_) ($ Id.VSub_Number '$1'))}
                          spids: [2897]
                        )
                      ]
                    )
                    (C {<shift>})
                  ]
                  spids: [2881 2894]
                )
              ]
            )
            (C {<_shunit_assertFail>} {(DQ (${ Id.VSub_Name shunit_message_))})
            (C {<unset>} {<shunit_message_>})
            (command.ControlFlow
              token: <Id.ControlFlow_Return return>
              arg_word: {(${ Id.VSub_Name SHUNIT_FALSE)}
            )
          ]
        )
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:_FAIL_)
          op: assign_op.Equal
          rhs: {(SQ <'eval fail --lineno "${LINENO:-}"'>)}
          spids: [2939]
        )
      ]
    )
    (command.ShFunction
      name: failNotEquals
      body: 
        (BraceGroup
          children: [
            (C {(${ Id.VSub_Name _SHUNIT_LINENO_)})
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\['>)} 
                              {($ Id.VSub_Pound '$#')} {<-lt>} {<2>} {<-o>} {($ Id.VSub_Pound '$#')} {<-gt>} {<3>} {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<_shunit_error>} 
                      {
                        (DQ <'failNotEquals() requires one or two arguments; '> ($ Id.VSub_Pound '$#') 
                          <' given'>
                        )
                      }
                    )
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {(${ Id.VSub_Name SHUNIT_ERROR)}
                    )
                  ]
                  spids: [2985 3006]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<_shunit_shouldSkip>})
                (command.ControlFlow
                  token: <Id.ControlFlow_Return return>
                  arg_word: {(${ Id.VSub_Name SHUNIT_TRUE)}
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:shunit_message_)
                  op: assign_op.Equal
                  rhs: {(${ Id.VSub_Name __shunit_lineno)}
                  spids: [3040]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\['>)} 
                              {($ Id.VSub_Pound '$#')} {<-eq>} {<3>} {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:shunit_message_)
                          op: assign_op.Equal
                          rhs: {(DQ (${ Id.VSub_Name shunit_message_) ($ Id.VSub_Number '$1'))}
                          spids: [3062]
                        )
                      ]
                    )
                    (C {<shift>})
                  ]
                  spids: [3046 3059]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:shunit_expected_)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_Number '$1')}
                  spids: [3077]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:shunit_actual_)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_Number '$2')}
                  spids: [3081]
                )
              ]
            )
            (C {<_shunit_assertFail>} 
              {
                (DQ 
                  (braced_var_sub
                    token: <Id.VSub_Name shunit_message_>
                    suffix_op: 
                      (suffix_op.Unary
                        tok: <Id.VTest_ColonPlus ':+'>
                        arg_word: {(${ Id.VSub_Name shunit_message_) <' '>}
                      )
                  ) <'expected:<'> (${ Id.VSub_Name shunit_expected_) <'> but was:<'> (${ Id.VSub_Name shunit_actual_) <'>'>
                )
              }
            )
            (C {<unset>} {<shunit_message_>} {<shunit_expected_>} {<shunit_actual_>})
            (command.ControlFlow
              token: <Id.ControlFlow_Return return>
              arg_word: {(${ Id.VSub_Name SHUNIT_FALSE)}
            )
          ]
        )
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:_FAIL_NOT_EQUALS_)
          op: assign_op.Equal
          rhs: {(SQ <'eval failNotEquals --lineno "${LINENO:-}"'>)}
          spids: [3130]
        )
      ]
    )
    (command.ShFunction
      name: failSame
      body: 
        (BraceGroup
          children: [
            (C {(${ Id.VSub_Name _SHUNIT_LINENO_)})
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\['>)} 
                              {($ Id.VSub_Pound '$#')} {<-lt>} {<2>} {<-o>} {($ Id.VSub_Pound '$#')} {<-gt>} {<3>} {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<_shunit_error>} 
                      {
                        (DQ <'failSame() requires two or three arguments; '> ($ Id.VSub_Pound '$#') 
                          <' given'>
                        )
                      }
                    )
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {(${ Id.VSub_Name SHUNIT_ERROR)}
                    )
                  ]
                  spids: [3176 3197]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<_shunit_shouldSkip>})
                (command.ControlFlow
                  token: <Id.ControlFlow_Return return>
                  arg_word: {(${ Id.VSub_Name SHUNIT_TRUE)}
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:shunit_message_)
                  op: assign_op.Equal
                  rhs: {(${ Id.VSub_Name __shunit_lineno)}
                  spids: [3231]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\['>)} 
                              {($ Id.VSub_Pound '$#')} {<-eq>} {<3>} {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:shunit_message_)
                          op: assign_op.Equal
                          rhs: {(DQ (${ Id.VSub_Name shunit_message_) ($ Id.VSub_Number '$1'))}
                          spids: [3253]
                        )
                      ]
                    )
                    (C {<shift>})
                  ]
                  spids: [3237 3250]
                )
              ]
            )
            (C {<_shunit_assertFail>} 
              {
                (DQ 
                  (braced_var_sub
                    token: <Id.VSub_Name shunit_message_>
                    suffix_op: 
                      (suffix_op.Unary
                        tok: <Id.VTest_ColonPlus ':+'>
                        arg_word: {(${ Id.VSub_Name shunit_message_) <' '>}
                      )
                  ) <'expected not same'>
                )
              }
            )
            (C {<unset>} {<shunit_message_>})
            (command.ControlFlow
              token: <Id.ControlFlow_Return return>
              arg_word: {(${ Id.VSub_Name SHUNIT_FALSE)}
            )
          ]
        )
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:_FAIL_SAME_)
          op: assign_op.Equal
          rhs: {(SQ <'eval failSame --lineno "${LINENO:-}"'>)}
          spids: [3301]
        )
      ]
    )
    (command.ShFunction
      name: failNotSame
      body: 
        (BraceGroup
          children: [
            (C {(${ Id.VSub_Name _SHUNIT_LINENO_)})
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\['>)} 
                              {($ Id.VSub_Pound '$#')} {<-lt>} {<2>} {<-o>} {($ Id.VSub_Pound '$#')} {<-gt>} {<3>} {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<_shunit_error>} 
                      {
                        (DQ <'failNotEquals() requires one or two arguments; '> ($ Id.VSub_Pound '$#') 
                          <' given'>
                        )
                      }
                    )
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {(${ Id.VSub_Name SHUNIT_ERROR)}
                    )
                  ]
                  spids: [3353 3374]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<_shunit_shouldSkip>})
                (command.ControlFlow
                  token: <Id.ControlFlow_Return return>
                  arg_word: {(${ Id.VSub_Name SHUNIT_TRUE)}
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:shunit_message_)
                  op: assign_op.Equal
                  rhs: {(${ Id.VSub_Name __shunit_lineno)}
                  spids: [3408]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\['>)} 
                              {($ Id.VSub_Pound '$#')} {<-eq>} {<3>} {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:shunit_message_)
                          op: assign_op.Equal
                          rhs: {(DQ (${ Id.VSub_Name shunit_message_) ($ Id.VSub_Number '$1'))}
                          spids: [3430]
                        )
                      ]
                    )
                    (C {<shift>})
                  ]
                  spids: [3414 3427]
                )
              ]
            )
            (C {<failNotEquals>} {(DQ (${ Id.VSub_Name shunit_message_))} {(DQ ($ Id.VSub_Number '$1'))} 
              {(DQ ($ Id.VSub_Number '$2'))}
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:shunit_return)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_QMark '$?')}
                  spids: [3462]
                )
              ]
            )
            (C {<unset>} {<shunit_message_>})
            (command.ControlFlow
              token: <Id.ControlFlow_Return return>
              arg_word: {(${ Id.VSub_Name shunit_return)}
            )
          ]
        )
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:_FAIL_NOT_SAME_)
          op: assign_op.Equal
          rhs: {(SQ <'eval failNotSame --lineno "${LINENO:-}"'>)}
          spids: [3483]
        )
      ]
    )
    (command.ShFunction
      name: startSkipping
      body: 
        (BraceGroup
          children: [
            (command.Sentence
              child: 
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:__shunit_skip)
                      op: assign_op.Equal
                      rhs: {(${ Id.VSub_Name SHUNIT_TRUE)}
                      spids: [3529]
                    )
                  ]
                )
              terminator: <Id.Op_Semi _>
            )
          ]
        )
    )
    (command.ShFunction
      name: endSkipping
      body: 
        (BraceGroup
          children: [
            (command.Sentence
              child: 
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:__shunit_skip)
                      op: assign_op.Equal
                      rhs: {(${ Id.VSub_Name SHUNIT_FALSE)}
                      spids: [3556]
                    )
                  ]
                )
              terminator: <Id.Op_Semi _>
            )
          ]
        )
    )
    (command.ShFunction
      name: isSkipping
      body: 
        (BraceGroup
          children: [
            (command.Sentence
              child: 
                (command.ControlFlow
                  token: <Id.ControlFlow_Return return>
                  arg_word: {(${ Id.VSub_Name __shunit_skip)}
                )
              terminator: <Id.Op_Semi _>
            )
          ]
        )
    )
    (command.ShFunction
      name: suite_addTest
      body: 
        (BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:shunit_func_)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (braced_var_sub
                        token: <Id.VSub_Number 1>
                        suffix_op: (suffix_op.Unary tok:<Id.VTest_ColonHyphen ':-'> arg_word:{})
                      )
                    }
                  spids: [3686]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:__shunit_suite)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (DQ 
                        (braced_var_sub
                          token: <Id.VSub_Name __shunit_suite>
                          suffix_op: 
                            (suffix_op.Unary
                              tok: <Id.VTest_ColonPlus ':+'>
                              arg_word: {(${ Id.VSub_Name __shunit_suite) <' '>}
                            )
                        ) (${ Id.VSub_Name shunit_func_)
                      )
                    }
                  spids: [3694]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:__shunit_testsTotal)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (command_sub
                        left_token: <Id.Left_Backtick '`'>
                        child: 
                          (C {<expr>} {(${ Id.VSub_Name __shunit_testsTotal)} {<Id.Lit_Other '+'>} {<1>})
                      )
                    }
                  spids: [3710]
                )
              ]
            )
            (C {<unset>} {<shunit_func_>})
          ]
        )
    )
    (command.ShFunction
      name: _shunit_mktempDir
      body: 
        (BraceGroup
          children: [
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (command.Subshell
                  child: 
                    (command.Simple
                      words: [{<exec>} {<mktemp>} {<-dqt>} {<shunit.XXXXXX>}]
                      redirects: [
                        (redir
                          op: <Id.Redir_Great '2>'>
                          loc: (redir_loc.Fd fd:2)
                          arg: {<'/dev/null'>}
                        )
                      ]
                      do_fork: T
                    )
                )
                (command.ControlFlow token:<Id.ControlFlow_Return return>)
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\['>)} {<-r>} 
                              {(SQ <'/dev/urandom'>)} {<-a>} {<-x>} {(SQ <'/usr/bin/od'>)} {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:_shunit_random_)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Id.Left_Backtick '`'>
                                child: 
                                  (command.Pipeline
                                    children: [
                                      (command.Simple
                                        words: [{<'/usr/bin/od'>} {<-vAn>} {<-N4>} {<-tx4>}]
                                        redirects: [
                                          (redir
                                            op: <Id.Redir_Less '<'>
                                            loc: (redir_loc.Fd fd:0)
                                            arg: {<'/dev/urandom'>}
                                          )
                                        ]
                                        do_fork: T
                                      )
                                      (C {<sed>} {(SQ <'s/^[^0-9a-f]*//'>)})
                                    ]
                                    negated: F
                                  )
                              )
                            }
                          spids: [3968]
                        )
                      ]
                    )
                  ]
                  spids: [3944 3965]
                )
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\['>)} {<-n>} 
                              {
                                (DQ 
                                  (braced_var_sub
                                    token: <Id.VSub_Name RANDOM>
                                    suffix_op: (suffix_op.Unary tok:<Id.VTest_ColonHyphen ':-'> arg_word:(word.Empty))
                                  )
                                )
                              } {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:_shunit_random_)
                          op: assign_op.Equal
                          rhs: 
                            {(${ Id.VSub_Name RANDOM) (${ Id.VSub_Name RANDOM) 
                              (${ Id.VSub_Name RANDOM) ($ Id.VSub_Dollar '$$')
                            }
                          spids: [4020]
                        )
                      ]
                    )
                  ]
                  spids: [3997 4013]
                )
              ]
              else_action: [
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:_shunit_date_)
                      op: assign_op.Equal
                      rhs: 
                        {
                          (command_sub
                            left_token: <Id.Left_Backtick '`'>
                            child: (C {<date>} {(SQ <'+%Y%m%d%H%M%S'>)})
                          )
                        }
                      spids: [4040]
                    )
                  ]
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:_shunit_random_)
                      op: assign_op.Equal
                      rhs: 
                        {
                          (command_sub
                            left_token: <Id.Left_Backtick '`'>
                            child: 
                              (C {<expr>} {(DQ (${ Id.VSub_Name _shunit_date_))} {<'/'>} 
                                {($ Id.VSub_Dollar '$$')}
                              )
                          )
                        }
                      spids: [4052]
                    )
                  ]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:_shunit_tmpDir_)
                  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>}
                            )
                        ) <'/shunit.'> (${ Id.VSub_Name _shunit_random_)
                      )
                    }
                  spids: [4074]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (command.Subshell
                  child: 
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (C {<umask>} {<077>})
                        (C {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\m'>) <kdir>} 
                          {(DQ (${ Id.VSub_Name _shunit_tmpDir_))}
                        )
                      ]
                    )
                )
                (C {<_shunit_fatal>} {(SQ <'could not create temporary directory! exiting'>)})
              ]
            )
            (C {<echo>} {(DQ (${ Id.VSub_Name _shunit_tmpDir_))})
            (C {<unset>} {<_shunit_date_>} {<_shunit_random_>} {<_shunit_tmpDir_>})
          ]
        )
    )
    (command.ShFunction
      name: _shunit_mktempFunc
      body: 
        (BraceGroup
          children: [
            (command.ForEach
              iter_name: _shunit_func_
              iter_words: [{<oneTimeSetUp>} {<oneTimeTearDown>} {<setUp>} {<tearDown>} {<suite>} {<noexec>}]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:_shunit_file_)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (DQ (${ Id.VSub_Name __shunit_tmpDir) <'/'> 
                                (${ Id.VSub_Name _shunit_func_)
                              )
                            }
                          spids: [4181]
                        )
                      ]
                    )
                    (command.Simple
                      words: [{(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\c'>) <at>}]
                      redirects: [
                        (redir
                          op: <Id.Redir_DLess '<<'>
                          loc: (redir_loc.Fd fd:0)
                          arg: 
                            (redir_param.HereDoc
                              here_begin: {<EOF>}
                              here_end_span_id: 4213
                              stdin_parts: [
                                <'#! /bin/sh\n'>
                                <'exit '>
                                (${ Id.VSub_Name SHUNIT_TRUE)
                                <'\n'>
                              ]
                            )
                        )
                        (redir
                          op: <Id.Redir_Great '>'>
                          loc: (redir_loc.Fd fd:1)
                          arg: {(DQ (${ Id.VSub_Name _shunit_file_))}
                        )
                      ]
                      do_fork: T
                    )
                    (C {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\c'>) <hmod>} 
                      {<Id.Lit_Other '+'> <x>} {(DQ (${ Id.VSub_Name _shunit_file_))}
                    )
                  ]
                )
            )
            (C {<unset>} {<_shunit_file_>})
          ]
        )
    )
    (command.ShFunction
      name: _shunit_cleanup
      body: 
        (BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:_shunit_name_)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_Number '$1')}
                  spids: [4270]
                )
              ]
            )
            (command.Case
              to_match: {(${ Id.VSub_Name _shunit_name_)}
              arms: [
                (case_arm
                  pat_list: [{<EXIT>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:_shunit_signal_)
                          op: assign_op.Equal
                          rhs: {<0>}
                          spids: [4287]
                        )
                      ]
                    )
                  ]
                  spids: [4284 4285 4290 -1]
                )
                (case_arm
                  pat_list: [{<INT>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:_shunit_signal_)
                          op: assign_op.Equal
                          rhs: {<2>}
                          spids: [4296]
                        )
                      ]
                    )
                  ]
                  spids: [4293 4294 4299 -1]
                )
                (case_arm
                  pat_list: [{<TERM>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:_shunit_signal_)
                          op: assign_op.Equal
                          rhs: {<15>}
                          spids: [4305]
                        )
                      ]
                    )
                  ]
                  spids: [4302 4303 4308 -1]
                )
                (case_arm
                  pat_list: [{<Id.Lit_Star '*'>}]
                  action: [
                    (C {<_shunit_error>} 
                      {(DQ <'unrecognized trap value ('> (${ Id.VSub_Name _shunit_name_) <')'>)}
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:_shunit_signal_)
                          op: assign_op.Equal
                          rhs: {<0>}
                          spids: [4326]
                        )
                      ]
                    )
                  ]
                  spids: [4311 4312 4330 -1]
                )
              ]
            )
            (C {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\r'>) <m>} {<-fr>} 
              {(DQ (${ Id.VSub_Name __shunit_tmpDir))}
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\['>)} 
                              {(DQ (${ Id.VSub_Name _shunit_name_))} {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} {(SQ <EXIT>)} {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<_shunit_warn>} 
                      {
                        (DQ <'trapped and now handling the ('> (${ Id.VSub_Name _shunit_name_) 
                          <') signal'>
                        )
                      }
                    )
                    (C {<trap>} {<0>})
                    (command.ControlFlow
                      token: <Id.ControlFlow_Exit exit>
                      arg_word: 
                        {
                          (DQ 
                            (command_sub
                              left_token: <Id.Left_Backtick '`'>
                              child: 
                                (C {<expr>} {(DQ (${ Id.VSub_Name _shunit_signal_))} 
                                  {<Id.Lit_Other '+'>} {<128>}
                                )
                            )
                          )
                        }
                    )
                  ]
                  spids: [4358 4378]
                )
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\['>)} 
                              {(${ Id.VSub_Name __shunit_reportGenerated)} {<-eq>} {(${ Id.VSub_Name SHUNIT_FALSE)} {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<_shunit_assertFail>} {(SQ <'Unknown failure encountered running a test'>)})
                    (C {<_shunit_generateReport>})
                    (command.ControlFlow
                      token: <Id.ControlFlow_Exit exit>
                      arg_word: {(${ Id.VSub_Name SHUNIT_ERROR)}
                    )
                  ]
                  spids: [4426 4444]
                )
              ]
            )
            (C {<unset>} {<_shunit_name_>} {<_shunit_signal_>})
          ]
        )
    )
    (command.ShFunction
      name: _shunit_configureColor
      body: 
        (BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:_shunit_color_)
                  op: assign_op.Equal
                  rhs: {(${ Id.VSub_Name SHUNIT_FALSE)}
                  spids: [4496]
                )
              ]
            )
            (command.Case
              to_match: {($ Id.VSub_Number '$1')}
              arms: [
                (case_arm
                  pat_list: [{(SQ <always>)}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:_shunit_color_)
                          op: assign_op.Equal
                          rhs: {(${ Id.VSub_Name SHUNIT_TRUE)}
                          spids: [4517]
                        )
                      ]
                    )
                  ]
                  spids: [4512 4515 4522 -1]
                )
                (case_arm
                  pat_list: [{(SQ <auto>)}]
                  action: [
                    (command.Subshell
                      child: 
                        (command.Simple
                          words: [{<exec>} {<tput>}]
                          redirects: [
                            (redir
                              op: <Id.Redir_Great '>'>
                              loc: (redir_loc.Fd fd:1)
                              arg: {<'/dev/null'>}
                            )
                            (redir
                              op: <Id.Redir_GreatAnd '2>&'>
                              loc: (redir_loc.Fd fd:2)
                              arg: {<1>}
                            )
                          ]
                          do_fork: T
                        )
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (C {<Id.Lit_LBracket '['>} {($ Id.VSub_QMark '$?')} {<-lt>} {<127>} 
                                      {<Id.Lit_RBracket ']'>}
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:_shunit_tput_)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (command_sub
                                        left_token: <Id.Left_Backtick '`'>
                                        child: (C {<tput>} {<colors>})
                                      )
                                    }
                                  spids: [4565]
                                )
                              ]
                            )
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (C {<Id.Lit_LBracket '['>} {($ Id.VSub_QMark '$?')} {<-eq>} {<0>} {<-a>} 
                                  {(DQ (${ Id.VSub_Name _shunit_tput_))} {<-ge>} {<16>} {<Id.Lit_RBracket ']'>}
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:_shunit_color_)
                                      op: assign_op.Equal
                                      rhs: {(${ Id.VSub_Name SHUNIT_TRUE)}
                                      spids: [4603]
                                    )
                                  ]
                                )
                              ]
                            )
                          ]
                          spids: [4549 4562]
                        )
                      ]
                    )
                  ]
                  spids: [4525 4528 4612 -1]
                )
                (case_arm pat_list:[{(SQ <none>)}] spids:[4615 4618 4620 -1])
                (case_arm
                  pat_list: [{<Id.Lit_Star '*'>}]
                  action: [
                    (C {<_shunit_fatal>} 
                      {
                        (DQ <'unrecognized SHUNIT_COLOR option \''> (${ Id.VSub_Name SHUNIT_COLOR) 
                          <'\''>
                        )
                      }
                    )
                  ]
                  spids: [4623 4624 4636 -1]
                )
              ]
            )
            (command.Case
              to_match: {(${ Id.VSub_Name _shunit_color_)}
              arms: [
                (case_arm
                  pat_list: [{(${ Id.VSub_Name SHUNIT_TRUE)}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:__shunit_ansi_none)
                          op: assign_op.Equal
                          rhs: {(${ Id.VSub_Name __SHUNIT_ANSI_NONE)}
                          spids: [4658]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:__shunit_ansi_red)
                          op: assign_op.Equal
                          rhs: {(${ Id.VSub_Name __SHUNIT_ANSI_RED)}
                          spids: [4664]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:__shunit_ansi_green)
                          op: assign_op.Equal
                          rhs: {(${ Id.VSub_Name __SHUNIT_ANSI_GREEN)}
                          spids: [4670]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:__shunit_ansi_yellow)
                          op: assign_op.Equal
                          rhs: {(${ Id.VSub_Name __SHUNIT_ANSI_YELLOW)}
                          spids: [4676]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:__shunit_ansi_cyan)
                          op: assign_op.Equal
                          rhs: {(${ Id.VSub_Name __SHUNIT_ANSI_CYAN)}
                          spids: [4682]
                        )
                      ]
                    )
                  ]
                  spids: [4652 4655 4688 -1]
                )
                (case_arm
                  pat_list: [{(${ Id.VSub_Name SHUNIT_FALSE)}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:__shunit_ansi_none)
                          op: assign_op.Equal
                          rhs: {(SQ )}
                          spids: [4697]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:__shunit_ansi_red)
                          op: assign_op.Equal
                          rhs: {(SQ )}
                          spids: [4702]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:__shunit_ansi_green)
                          op: assign_op.Equal
                          rhs: {(SQ )}
                          spids: [4707]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:__shunit_ansi_yellow)
                          op: assign_op.Equal
                          rhs: {(SQ )}
                          spids: [4712]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:__shunit_ansi_cyan)
                          op: assign_op.Equal
                          rhs: {(SQ )}
                          spids: [4717]
                        )
                      ]
                    )
                  ]
                  spids: [4691 4694 4722 -1]
                )
              ]
            )
            (C {<unset>} {<_shunit_color_>} {<_shunit_tput_>})
          ]
        )
    )
    (command.ShFunction
      name: _shunit_execSuite
      body: 
        (BraceGroup
          children: [
            (command.ForEach
              iter_name: _shunit_test_
              iter_words: [{(${ Id.VSub_Name __shunit_suite)}]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:__shunit_testSuccess)
                          op: assign_op.Equal
                          rhs: {(${ Id.VSub_Name SHUNIT_TRUE)}
                          spids: [4771]
                        )
                      ]
                    )
                    (C {<endSkipping>})
                    (C {<setUp>})
                    (C {<echo>} {(DQ (${ Id.VSub_Name _shunit_test_))})
                    (C {<eval>} {(DQ (${ Id.VSub_Name _shunit_test_))})
                    (C {<tearDown>})
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (C {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\['>)} 
                                      {(${ Id.VSub_Name __shunit_testSuccess)} {<-eq>} {(${ Id.VSub_Name SHUNIT_TRUE)} {<Id.Lit_RBracket ']'>}
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:__shunit_testsPassed)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (command_sub
                                        left_token: <Id.Left_Backtick '`'>
                                        child: 
                                          (C {<expr>} {(${ Id.VSub_Name __shunit_testsPassed)} 
                                            {<Id.Lit_Other '+'>} {<1>}
                                          )
                                      )
                                    }
                                  spids: [4849]
                                )
                              ]
                            )
                          ]
                          spids: [4829 4846]
                        )
                      ]
                      else_action: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:__shunit_testsFailed)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (command_sub
                                    left_token: <Id.Left_Backtick '`'>
                                    child: 
                                      (C {<expr>} {(${ Id.VSub_Name __shunit_testsFailed)} 
                                        {<Id.Lit_Other '+'>} {<1>}
                                      )
                                  )
                                }
                              spids: [4868]
                            )
                          ]
                        )
                      ]
                    )
                  ]
                )
            )
            (C {<unset>} {<_shunit_test_>})
          ]
        )
    )
    (command.ShFunction
      name: _shunit_generateReport
      body: 
        (BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:_shunit_ok_)
                  op: assign_op.Equal
                  rhs: {(${ Id.VSub_Name SHUNIT_TRUE)}
                  spids: [4923]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\['>)} 
                  {(DQ (${ Id.VSub_Name __shunit_testsFailed))} {<-gt>} {<0>} {<-o>} {(${ Id.VSub_Name __shunit_testSuccess)} {<-eq>} {(${ Id.VSub_Name SHUNIT_FALSE)} 
                  {<Id.Lit_RBracket ']'>}
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:_shunit_ok_)
                      op: assign_op.Equal
                      rhs: {(${ Id.VSub_Name SHUNIT_FALSE)}
                      spids: [4966]
                    )
                  ]
                )
              ]
            )
            (C {<echo>})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:_shunit_msg_)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (DQ <'Ran '> (${ Id.VSub_Name __shunit_ansi_cyan) 
                        (${ Id.VSub_Name __shunit_testsTotal) (${ Id.VSub_Name __shunit_ansi_none)
                      )
                    }
                  spids: [4976]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\['>)} 
                              {(DQ (${ Id.VSub_Name __shunit_testsTotal))} {<-eq>} {<1>} {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {(${ Id.VSub_Name __SHUNIT_CMD_ECHO_ESC)} 
                      {(DQ (${ Id.VSub_Name _shunit_msg_) <' test.'>)}
                    )
                  ]
                  spids: [4991 5008]
                )
              ]
              else_action: [
                (C {(${ Id.VSub_Name __SHUNIT_CMD_ECHO_ESC)} 
                  {(DQ (${ Id.VSub_Name _shunit_msg_) <' tests.'>)}
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:_shunit_failures_)
                  op: assign_op.Equal
                  rhs: {(SQ )}
                  spids: [5042]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:_shunit_skipped_)
                  op: assign_op.Equal
                  rhs: {(SQ )}
                  spids: [5047]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\['>)} 
                  {(${ Id.VSub_Name __shunit_assertsFailed)} {<-gt>} {<0>} {<Id.Lit_RBracket ']'>}
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:_shunit_failures_)
                      op: assign_op.Equal
                      rhs: {(DQ <'failures='> (${ Id.VSub_Name __shunit_assertsFailed))}
                      spids: [5068]
                    )
                  ]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\['>)} 
                  {(${ Id.VSub_Name __shunit_assertsSkipped)} {<-gt>} {<0>} {<Id.Lit_RBracket ']'>}
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:_shunit_skipped_)
                      op: assign_op.Equal
                      rhs: {(DQ <'skipped='> (${ Id.VSub_Name __shunit_assertsSkipped))}
                      spids: [5093]
                    )
                  ]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\['>)} 
                              {(${ Id.VSub_Name _shunit_ok_)} {<-eq>} {(${ Id.VSub_Name SHUNIT_TRUE)} {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:_shunit_msg_)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (DQ (${ Id.VSub_Name __shunit_ansi_green) <OK> 
                                (${ Id.VSub_Name __shunit_ansi_none)
                              )
                            }
                          spids: [5123]
                        )
                      ]
                    )
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (C {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\['>)} {<-n>} 
                          {(DQ (${ Id.VSub_Name _shunit_skipped_))} {<Id.Lit_RBracket ']'>}
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:_shunit_msg_)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (DQ (${ Id.VSub_Name _shunit_msg_) <' ('> 
                                    (${ Id.VSub_Name __shunit_ansi_yellow) (${ Id.VSub_Name _shunit_skipped_) (${ Id.VSub_Name __shunit_ansi_none) <')'>
                                  )
                                }
                              spids: [5151]
                            )
                          ]
                        )
                      ]
                    )
                  ]
                  spids: [5103 5120]
                )
              ]
              else_action: [
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:_shunit_msg_)
                      op: assign_op.Equal
                      rhs: 
                        {
                          (DQ (${ Id.VSub_Name __shunit_ansi_red) <FAILED> 
                            (${ Id.VSub_Name __shunit_ansi_none)
                          )
                        }
                      spids: [5173]
                    )
                  ]
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:_shunit_msg_)
                      op: assign_op.Equal
                      rhs: 
                        {
                          (DQ (${ Id.VSub_Name _shunit_msg_) <' ('> (${ Id.VSub_Name __shunit_ansi_red) 
                            (${ Id.VSub_Name _shunit_failures_) (${ Id.VSub_Name __shunit_ansi_none)
                          )
                        }
                      spids: [5185]
                    )
                  ]
                )
                (command.AndOr
                  ops: [Id.Op_DAmp]
                  children: [
                    (C {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\['>)} {<-n>} 
                      {(DQ (${ Id.VSub_Name _shunit_skipped_))} {<Id.Lit_RBracket ']'>}
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:_shunit_msg_)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (DQ (${ Id.VSub_Name _shunit_msg_) <','> 
                                (${ Id.VSub_Name __shunit_ansi_yellow) (${ Id.VSub_Name _shunit_skipped_) (${ Id.VSub_Name __shunit_ansi_none)
                              )
                            }
                          spids: [5219]
                        )
                      ]
                    )
                  ]
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:_shunit_msg_)
                      op: assign_op.Equal
                      rhs: {(DQ (${ Id.VSub_Name _shunit_msg_) <')'>)}
                      spids: [5237]
                    )
                  ]
                )
              ]
            )
            (C {<echo>})
            (C {(${ Id.VSub_Name __SHUNIT_CMD_ECHO_ESC)} {(DQ (${ Id.VSub_Name _shunit_msg_))})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:__shunit_reportGenerated)
                  op: assign_op.Equal
                  rhs: {(${ Id.VSub_Name SHUNIT_TRUE)}
                  spids: [5264]
                )
              ]
            )
            (C {<unset>} {<_shunit_failures_>} {<_shunit_msg_>} {<_shunit_ok_>} {<_shunit_skipped_>})
          ]
        )
    )
    (command.ShFunction
      name: _shunit_shouldSkip
      body: 
        (BraceGroup
          children: [
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\['>)} 
                  {(${ Id.VSub_Name __shunit_skip)} {<-eq>} {(${ Id.VSub_Name SHUNIT_FALSE)} {<Id.Lit_RBracket ']'>}
                )
                (command.ControlFlow
                  token: <Id.ControlFlow_Return return>
                  arg_word: {(${ Id.VSub_Name SHUNIT_FALSE)}
                )
              ]
            )
            (C {<_shunit_assertSkip>})
          ]
        )
    )
    (command.ShFunction
      name: _shunit_assertPass
      body: 
        (BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:__shunit_assertsPassed)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (command_sub
                        left_token: <Id.Left_Backtick '`'>
                        child: 
                          (C {<expr>} {(${ Id.VSub_Name __shunit_assertsPassed)} {<Id.Lit_Other '+'>} 
                            {<1>}
                          )
                      )
                    }
                  spids: [5356]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:__shunit_assertsTotal)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (command_sub
                        left_token: <Id.Left_Backtick '`'>
                        child: 
                          (C {<expr>} {(${ Id.VSub_Name __shunit_assertsTotal)} {<Id.Lit_Other '+'>} 
                            {<1>}
                          )
                      )
                    }
                  spids: [5372]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: _shunit_assertFail
      body: 
        (BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:_shunit_msg_)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_Number '$1')}
                  spids: [5409]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:__shunit_testSuccess)
                  op: assign_op.Equal
                  rhs: {(${ Id.VSub_Name SHUNIT_FALSE)}
                  spids: [5414]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:__shunit_assertsFailed)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (command_sub
                        left_token: <Id.Left_Backtick '`'>
                        child: 
                          (C {<expr>} {(DQ (${ Id.VSub_Name __shunit_assertsFailed))} 
                            {<Id.Lit_Other '+'>} {<1>}
                          )
                      )
                    }
                  spids: [5420]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:__shunit_assertsTotal)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (command_sub
                        left_token: <Id.Left_Backtick '`'>
                        child: 
                          (C {<expr>} {(DQ (${ Id.VSub_Name __shunit_assertsTotal))} 
                            {<Id.Lit_Other '+'>} {<1>}
                          )
                      )
                    }
                  spids: [5438]
                )
              ]
            )
            (C {(${ Id.VSub_Name __SHUNIT_CMD_ECHO_ESC)} 
              {
                (DQ (${ Id.VSub_Name __shunit_ansi_red) <'ASSERT:'> 
                  (${ Id.VSub_Name __shunit_ansi_none) (${ Id.VSub_Name _shunit_msg_)
                )
              }
            )
            (C {<unset>} {<_shunit_msg_>})
          ]
        )
    )
    (command.ShFunction
      name: _shunit_assertSkip
      body: 
        (BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:__shunit_assertsSkipped)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (command_sub
                        left_token: <Id.Left_Backtick '`'>
                        child: 
                          (C {<expr>} {(DQ (${ Id.VSub_Name __shunit_assertsSkipped))} 
                            {<Id.Lit_Other '+'>} {<1>}
                          )
                      )
                    }
                  spids: [5503]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:__shunit_assertsTotal)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (command_sub
                        left_token: <Id.Left_Backtick '`'>
                        child: 
                          (C {<expr>} {(DQ (${ Id.VSub_Name __shunit_assertsTotal))} 
                            {<Id.Lit_Other '+'>} {<1>}
                          )
                      )
                    }
                  spids: [5521]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: _shunit_prepForSourcing
      body: 
        (BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:_shunit_script_)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_Number '$1')}
                  spids: [5566]
                )
              ]
            )
            (command.Case
              to_match: {(DQ (${ Id.VSub_Name _shunit_script_))}
              arms: [
                (case_arm
                  pat_list: [{<'/'> <Id.Lit_Star '*'>} {<'./'> <Id.Lit_Star '*'>}]
                  action: [(C {<echo>} {(DQ (${ Id.VSub_Name _shunit_script_))})]
                  spids: [5581 5586 5596 -1]
                )
                (case_arm
                  pat_list: [{<Id.Lit_Star '*'>}]
                  action: [(C {<echo>} {(DQ <'./'> (${ Id.VSub_Name _shunit_script_))})]
                  spids: [5599 5600 5611 -1]
                )
              ]
            )
            (C {<unset>} {<_shunit_script_>})
          ]
        )
    )
    (command.ShFunction
      name: _shunit_escapeCharInStr
      body: 
        (BraceGroup
          children: [
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (C {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\['>)} {<-n>} 
                  {(DQ ($ Id.VSub_Number '$2'))} {<Id.Lit_RBracket ']'>}
                )
                (command.ControlFlow token:<Id.ControlFlow_Return return>)
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:_shunit_c_)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_Number '$1')}
                  spids: [5679]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:_shunit_s_)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_Number '$2')}
                  spids: [5683]
                )
              ]
            )
            (command.Pipeline
              children: [
                (C {<echo>} {(SQ ) (${ Id.VSub_Name _shunit_s_) (SQ )})
                (C {<sed>} 
                  {(SQ <'s/\\'>) (${ Id.VSub_Name _shunit_c_) (SQ <'/\\\\\\'>) 
                    (${ Id.VSub_Name _shunit_c_) (SQ <'/g'>)
                  }
                )
              ]
              negated: F
            )
            (C {<unset>} {<_shunit_c_>} {<_shunit_s_>})
          ]
        )
    )
    (command.ShFunction
      name: _shunit_escapeCharactersInString
      body: 
        (BraceGroup
          children: [
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (C {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\['>)} {<-n>} 
                  {(DQ ($ Id.VSub_Number '$1'))} {<Id.Lit_RBracket ']'>}
                )
                (command.ControlFlow token:<Id.ControlFlow_Return return>)
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:_shunit_str_)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_Number '$1')}
                  spids: [5781]
                )
              ]
            )
            (command.ForEach
              iter_name: _shunit_char_
              iter_words: [{(SQ <'"'>)} {(SQ <'$'>)} {(DQ <'\''>)} {(SQ <'`'>)}]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:_shunit_str_)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Id.Left_Backtick '`'>
                                child: 
                                  (C {<_shunit_escapeCharInStr>} {(DQ (${ Id.VSub_Name _shunit_char_))} 
                                    {(DQ (${ Id.VSub_Name _shunit_str_))}
                                  )
                              )
                            }
                          spids: [5820]
                        )
                      ]
                    )
                  ]
                )
            )
            (C {<echo>} {(DQ (${ Id.VSub_Name _shunit_str_))})
            (C {<unset>} {<_shunit_char_>} {<_shunit_str_>})
          ]
        )
    )
    (command.ShFunction
      name: _shunit_extractTestFunctions
      body: 
        (BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:_shunit_script_)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_Number '$1')}
                  spids: [5887]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:_shunit_regex_)
                  op: assign_op.Equal
                  rhs: {(SQ <'^[ \t]*(function )*test[A-Za-z0-9_]* *\\(\\)'>)}
                  spids: [5900]
                )
              ]
            )
            (command.Pipeline
              children: [
                (C {<egrep>} {(DQ (${ Id.VSub_Name _shunit_regex_))} 
                  {(DQ (${ Id.VSub_Name _shunit_script_))}
                )
                (C {<sed>} {(SQ <'s/^[^A-Za-z0-9_]*//;s/^function //;s/\\([A-Za-z0-9_]*\\).*/\\1/g'>)})
                (C {<xargs>})
              ]
              negated: F
            )
            (C {<unset>} {<_shunit_regex_>} {<_shunit_script_>})
          ]
        )
    )
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.Sentence
                  child: 
                    (C {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\['>)} 
                      {($ Id.VSub_Pound '$#')} {<-eq>} {<0>} {<Id.Lit_RBracket ']'>}
                    )
                  terminator: <Id.Op_Semi _>
                )
              ]
            )
          action: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:__shunit_script)
                  op: assign_op.Equal
                  rhs: {(${ Id.VSub_Name __SHUNIT_PARENT)}
                  spids: [5978]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:__shunit_mode)
                  op: assign_op.Equal
                  rhs: {(${ Id.VSub_Name __SHUNIT_MODE_SOURCED)}
                  spids: [5984]
                )
              ]
            )
          ]
          spids: [5962 5975]
        )
      ]
      else_action: [
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:__shunit_script)
              op: assign_op.Equal
              rhs: {($ Id.VSub_Number '$1')}
              spids: [5992]
            )
          ]
        )
        (command.AndOr
          ops: [Id.Op_DPipe]
          children: [
            (C {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\['>)} {<-r>} 
              {(DQ (${ Id.VSub_Name __shunit_script))} {<Id.Lit_RBracket ']'>}
            )
            (C {<_shunit_fatal>} {(DQ <'unable to read from '> (${ Id.VSub_Name __shunit_script))})
          ]
        )
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:__shunit_mode)
              op: assign_op.Equal
              rhs: {(${ Id.VSub_Name __SHUNIT_MODE_STANDALONE)}
              spids: [6022]
            )
          ]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:__shunit_tmpDir)
          op: assign_op.Equal
          rhs: {(command_sub left_token:<Id.Left_Backtick '`'> child:(C {<_shunit_mktempDir>}))}
          spids: [6033]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:SHUNIT_TMPDIR)
          op: assign_op.Equal
          rhs: {(DQ (${ Id.VSub_Name __shunit_tmpDir) <'/tmp'>)}
          spids: [6047]
        )
      ]
    )
    (C {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\m'>) <kdir>} 
      {(DQ (${ Id.VSub_Name SHUNIT_TMPDIR))}
    )
    (C {<trap>} {(SQ <'_shunit_cleanup EXIT'>)} {<0>})
    (C {<trap>} {(SQ <'_shunit_cleanup INT'>)} {<2>})
    (C {<trap>} {(SQ <'_shunit_cleanup TERM'>)} {<15>})
    (C {<_shunit_mktempFunc>})
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:PATH)
          op: assign_op.Equal
          rhs: {(DQ (${ Id.VSub_Name __shunit_tmpDir) <':'> (${ Id.VSub_Name PATH))}
          spids: [6098]
        )
      ]
    )
    (command.AndOr
      ops: [Id.Op_DPipe]
      children: [
        (command.Simple
          words: [{<noexec>}]
          redirects: [(redir op:<Id.Redir_Great '2>'> loc:(redir_loc.Fd fd:2) arg:{<'/dev/null'>})]
          do_fork: T
        )
        (C {<_shunit_fatal>} 
          {(SQ <'Please declare TMPDIR with path on partition with exec permission.'>)}
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.Sentence
                  child: 
                    (C {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\['>)} 
                      {(DQ (${ Id.VSub_Name __shunit_mode))} {<Id.Lit_Equals '='>} {(DQ (${ Id.VSub_Name __SHUNIT_MODE_STANDALONE))} {<Id.Lit_RBracket ']'>}
                    )
                  terminator: <Id.Op_Semi _>
                )
              ]
            )
          action: [
            (C {<.>} 
              {
                (DQ 
                  (command_sub
                    left_token: <Id.Left_Backtick '`'>
                    child: (C {<_shunit_prepForSourcing>} {(DQ (${ Id.VSub_Name __shunit_script))})
                  )
                )
              }
            )
          ]
          spids: [6138 6159]
        )
      ]
    )
    (C {<_shunit_configureColor>} {(DQ (${ Id.VSub_Name SHUNIT_COLOR))})
    (C {<oneTimeSetUp>})
    (C {<suite>})
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.Sentence
                  child: 
                    (C {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\['>)} {<-z>} 
                      {(DQ (${ Id.VSub_Name __shunit_suite))} {<Id.Lit_RBracket ']'>}
                    )
                  terminator: <Id.Op_Semi _>
                )
              ]
            )
          action: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:shunit_funcs_)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (command_sub
                        left_token: <Id.Left_Backtick '`'>
                        child: 
                          (C {<_shunit_extractTestFunctions>} {(DQ (${ Id.VSub_Name __shunit_script))})
                      )
                    }
                  spids: [6236]
                )
              ]
            )
            (command.ForEach
              iter_name: shunit_func_
              iter_words: [{(${ Id.VSub_Name shunit_funcs_)}]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [(C {<suite_addTest>} {(DQ (${ Id.VSub_Name shunit_func_))})]
                )
            )
          ]
          spids: [6218 6233]
        )
      ]
    )
    (C {<unset>} {<shunit_func_>} {<shunit_funcs_>})
    (C {<_shunit_execSuite>})
    (C {<oneTimeTearDown>})
    (C {<_shunit_generateReport>})
    (C {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\['>)} 
      {(DQ (${ Id.VSub_Name __shunit_testsFailed))} {<-eq>} {<0>} {<Id.Lit_RBracket ']'>}
    )
    (command.ControlFlow token:<Id.ControlFlow_Exit exit> arg_word:{($ Id.VSub_QMark '$?')})
  ]
)