(CommandList
  children: [
    (FuncDef
      name: test_set_editor
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:FAKE_EDITOR)
                  op: Equal
                  rhs: {(DQ ($ VSub_Number "$1"))}
                  spids: [87]
                )
              ]
              spids: [87]
            )
            (C {(export)} {(FAKE_EDITOR)})
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:EDITOR)
                  op: Equal
                  rhs: {(SQ <"\"$FAKE_EDITOR\"">)}
                  spids: [98]
                )
              ]
              spids: [98]
            )
            (C {(export)} {(EDITOR)})
          ]
          spids: [84]
        )
      spids: [79 83]
    )
    (FuncDef
      name: test_set_index_version
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:GIT_INDEX_VERSION)
                  op: Equal
                  rhs: {(DQ ($ VSub_Number "$1"))}
                  spids: [119]
                )
              ]
              spids: [119]
            )
            (C {(export)} {(GIT_INDEX_VERSION)})
          ]
          spids: [116]
        )
      spids: [111 115]
    )
    (FuncDef
      name: test_decode_color
      body: 
        (BraceGroup
          children: [
            (C {(awk)} 
              {
                (SQ <"\n"> <"\t\tfunction name(n) {\n"> <"\t\t\tif (n == 0) return \"RESET\";\n"> 
                  <"\t\t\tif (n == 1) return \"BOLD\";\n"> <"\t\t\tif (n == 30) return \"BLACK\";\n"> <"\t\t\tif (n == 31) return \"RED\";\n"> 
                  <"\t\t\tif (n == 32) return \"GREEN\";\n"> <"\t\t\tif (n == 33) return \"YELLOW\";\n"> <"\t\t\tif (n == 34) return \"BLUE\";\n"> 
                  <"\t\t\tif (n == 35) return \"MAGENTA\";\n"> <"\t\t\tif (n == 36) return \"CYAN\";\n"> <"\t\t\tif (n == 37) return \"WHITE\";\n"> 
                  <"\t\t\tif (n == 40) return \"BLACK\";\n"> <"\t\t\tif (n == 41) return \"BRED\";\n"> <"\t\t\tif (n == 42) return \"BGREEN\";\n"> 
                  <"\t\t\tif (n == 43) return \"BYELLOW\";\n"> <"\t\t\tif (n == 44) return \"BBLUE\";\n"> <"\t\t\tif (n == 45) return \"BMAGENTA\";\n"> 
                  <"\t\t\tif (n == 46) return \"BCYAN\";\n"> <"\t\t\tif (n == 47) return \"BWHITE\";\n"> <"\t\t}\n"> <"\t\t{\n"> 
                  <"\t\t\twhile (match($0, /\\033\\[[0-9;]*m/) != 0) {\n"> <"\t\t\t\tprintf \"%s<\", substr($0, 1, RSTART-1);\n"> 
                  <"\t\t\t\tcodes = substr($0, RSTART+2, RLENGTH-3);\n"> <"\t\t\t\tif (length(codes) == 0)\n"> <"\t\t\t\t\tprintf \"%s\", name(0)\n"> <"\t\t\t\telse {\n"> 
                  <"\t\t\t\t\tn = split(codes, ary, \";\");\n"> <"\t\t\t\t\tsep = \"\";\n"> <"\t\t\t\t\tfor (i = 1; i <= n; i++) {\n"> 
                  <"\t\t\t\t\t\tprintf \"%s%s\", sep, name(ary[i]);\n"> <"\t\t\t\t\t\tsep = \";\"\n"> <"\t\t\t\t\t}\n"> <"\t\t\t\t}\n"> <"\t\t\t\tprintf \">\";\n"> 
                  <
"\t\t\t\t$0 = substr($0, RSTART + RLENGTH, length($0) - RSTART - RLENGTH + 1);\n"
                  > <"\t\t\t}\n"> <"\t\t\tprint\n"> <"\t\t}\n"> <"\t">
                )
              }
            )
          ]
          spids: [137]
        )
      spids: [132 136]
    )
    (FuncDef
      name: lf_to_nul
      body: (BraceGroup children:[(C {(perl)} {(-pe)} {(SQ <"y/\\012/\\000/">)})] spids:[194])
      spids: [189 193]
    )
    (FuncDef
      name: nul_to_q
      body: (BraceGroup children:[(C {(perl)} {(-pe)} {(SQ <"y/\\000/Q/">)})] spids:[213])
      spids: [208 212]
    )
    (FuncDef
      name: q_to_nul
      body: (BraceGroup children:[(C {(perl)} {(-pe)} {(SQ <"y/Q/\\000/">)})] spids:[232])
      spids: [227 231]
    )
    (FuncDef
      name: q_to_cr
      body: (BraceGroup children:[(C {(tr)} {(Q)} {(SQ <"\\015">)})] spids:[251])
      spids: [246 250]
    )
    (FuncDef
      name: q_to_tab
      body: (BraceGroup children:[(C {(tr)} {(Q)} {(SQ <"\\011">)})] spids:[270])
      spids: [265 269]
    )
    (FuncDef
      name: qz_to_tab_space
      body: (BraceGroup children:[(C {(tr)} {(QZ)} {(SQ <"\\011\\040">)})] spids:[289])
      spids: [284 288]
    )
    (FuncDef
      name: append_cr
      body: 
        (BraceGroup
          children: [
            (Pipeline
              children: [(C {(sed)} {(-e)} {(SQ <"s/$/Q/">)}) (C {(tr)} {(Q)} {(SQ <"\\015">)})]
              negated: False
            )
          ]
          spids: [308]
        )
      spids: [303 307]
    )
    (FuncDef
      name: remove_cr
      body: 
        (BraceGroup
          children: [
            (Pipeline
              children: [(C {(tr)} {(SQ <"\\015">)} {(Q)}) (C {(sed)} {(-e)} {(SQ <"s/Q$//">)})]
              negated: False
            )
          ]
          spids: [337]
        )
      spids: [332 336]
    )
    (FuncDef
      name: sane_unset
      body: 
        (BraceGroup
          children: [
            (C {(unset)} {(DQ ($ VSub_At "$@"))})
            (ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
          ]
          spids: [382]
        )
      spids: [377 381]
    )
    (FuncDef
      name: test_tick
      body: 
        (BraceGroup
          children: [
            (If
              arms: [
                (if_arm
                  cond: [
                    (C {(test)} {(-z)} 
                      {
                        (DQ 
                          (BracedVarSub
                            token: <VSub_Name test_tick>
                            suffix_op: (StringUnary op_id:VTest_Plus arg_word:{(set)})
                            spids: [414 418]
                          )
                        )
                      }
                    )
                  ]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:test_tick)
                          op: Equal
                          rhs: {(1112911993)}
                          spids: [425]
                        )
                      ]
                      spids: [425]
                    )
                  ]
                  spids: [-1 422]
                )
              ]
              else_action: [
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:test_tick)
                      op: Equal
                      rhs: 
                        {
                          (ArithSubPart
                            anode: 
                              (ArithBinary
                                op_id: Arith_Plus
                                left: (ArithWord w:{($ VSub_Name "$test_tick")})
                                right: (ArithWord w:{(Lit_Digits 60)})
                              )
                            spids: [433 440]
                          )
                        }
                      spids: [432]
                    )
                  ]
                  spids: [432]
                )
              ]
              spids: [429 443]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:GIT_COMMITTER_DATE)
                  op: Equal
                  rhs: {(DQ ($ VSub_Name "$test_tick") (" -0700"))}
                  spids: [446]
                )
              ]
              spids: [446]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:GIT_AUTHOR_DATE)
                  op: Equal
                  rhs: {(DQ ($ VSub_Name "$test_tick") (" -0700"))}
                  spids: [453]
                )
              ]
              spids: [453]
            )
            (C {(export)} {(GIT_COMMITTER_DATE)} {(GIT_AUTHOR_DATE)})
          ]
          spids: [404]
        )
      spids: [399 403]
    )
    (FuncDef
      name: test_pause
      body: 
        (BraceGroup
          children: [
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: (C {(test)} {(DQ ($ VSub_Name "$verbose"))} {(Lit_Other "=")} {(t)})
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (SimpleCommand
                      words: [{(DQ ($ VSub_Name "$SHELL_PATH"))}]
                      redirects: [
                        (Redir
                          op_id: Redir_LessAnd
                          fd: -1
                          arg_word: {(6)}
                          spids: [510]
                        )
                        (Redir
                          op_id: Redir_GreatAnd
                          fd: -1
                          arg_word: {(3)}
                          spids: [513]
                        )
                        (Redir
                          op_id: Redir_GreatAnd
                          fd: 2
                          arg_word: {(4)}
                          spids: [516]
                        )
                      ]
                    )
                  ]
                  spids: [-1 503]
                )
              ]
              else_action: [
                (SimpleCommand
                  words: [{(error)} {(DQ ("test_pause requires --verbose"))}]
                  redirects: [(Redir op_id:Redir_GreatAnd fd:-1 arg_word:{(5)} spids:[525])]
                )
              ]
              spids: [520 533]
            )
          ]
          spids: [487]
        )
      spids: [482 486]
    )
    (FuncDef
      name: debug
      body: 
        (BraceGroup
          children: [
            (SimpleCommand
              words: [{(DQ ($ VSub_At "$@"))}]
              more_env: [(env_pair name:GIT_TEST_GDB val:{(1)} spids:[558])]
            )
          ]
          spids: [555]
        )
      spids: [550 554]
    )
    (FuncDef
      name: test_commit
      body: 
        (BraceGroup
          children: [
            (AndOr
              children: [
                (Assignment
                  keyword: Assign_None
                  pairs: [(assign_pair lhs:(LhsName name:notick) op:Equal rhs:{(SQ )} spids:[595])]
                  spids: [595]
                )
                (AndOr
                  children: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:signoff)
                          op: Equal
                          rhs: {(SQ )}
                          spids: [600]
                        )
                      ]
                      spids: [600]
                    )
                    (AndOr
                      children: [
                        (While
                          cond: [
                            (C {(test)} {($ VSub_Pound "$#")} {(KW_Bang "!") (Lit_Other "=")} {(0)})
                          ]
                          body: 
                            (DoGroup
                              children: [
                                (Case
                                  to_match: {(DQ ($ VSub_Number "$1"))}
                                  arms: [
                                    (case_arm
                                      pat_list: [{(--notick)}]
                                      action: [
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:notick)
                                              op: Equal
                                              rhs: {(yes)}
                                              spids: [633]
                                            )
                                          ]
                                          spids: [633]
                                        )
                                      ]
                                      spids: [629 630 637 -1]
                                    )
                                    (case_arm
                                      pat_list: [{(--signoff)}]
                                      action: [
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:signoff)
                                              op: Equal
                                              rhs: {(DQ ($ VSub_Number "$1"))}
                                              spids: [644]
                                            )
                                          ]
                                          spids: [644]
                                        )
                                      ]
                                      spids: [640 641 650 -1]
                                    )
                                    (case_arm
                                      pat_list: [{(Lit_Other "*")}]
                                      action: [(ControlFlow token:<ControlFlow_Break break>)]
                                      spids: [653 654 660 -1]
                                    )
                                  ]
                                  spids: [620 626 663]
                                )
                                (C {(shift)})
                              ]
                              spids: [617 669]
                            )
                        )
                        (AndOr
                          children: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:file)
                                  op: Equal
                                  rhs: 
                                    {
                                      (BracedVarSub
                                        token: <VSub_Number 2>
                                        suffix_op: 
                                          (StringUnary
                                            op_id: VTest_ColonHyphen
                                            arg_word: {(DQ ($ VSub_Number "$1") (.t))}
                                          )
                                        spids: [675 682]
                                      )
                                    }
                                  spids: [674]
                                )
                              ]
                              spids: [674]
                            )
                            (AndOr
                              children: [
                                (SimpleCommand
                                  words: [
                                    {(echo)}
                                    {
                                      (DQ 
                                        (BracedVarSub
                                          token: <VSub_Number 3>
                                          suffix_op: 
                                            (StringUnary
                                              op_id: VTest_Hyphen
                                              arg_word: {($ VSub_Number "$1")}
                                            )
                                          spids: [690 694]
                                        )
                                      )
                                    }
                                  ]
                                  redirects: [
                                    (Redir
                                      op_id: Redir_Great
                                      fd: -1
                                      arg_word: {(DQ ($ VSub_Name "$file"))}
                                      spids: [697]
                                    )
                                  ]
                                )
                                (AndOr
                                  children: [
                                    (C {(git)} {(add)} {(DQ ($ VSub_Name "$file"))})
                                    (AndOr
                                      children: [
                                        (If
                                          arms: [
                                            (if_arm
                                              cond: [(C {(test)} {(-z)} {(DQ ($ VSub_Name "$notick"))})]
                                              action: [(C {(test_tick)})]
                                              spids: [-1 728]
                                            )
                                          ]
                                          spids: [-1 734]
                                        )
                                        (AndOr
                                          children: [
                                            (C {(git)} {(commit)} {($ VSub_Name "$signoff")} {(-m)} 
                                              {(DQ ($ VSub_Number "$1"))}
                                            )
                                            (C {(git)} {(tag)} 
                                              {
                                                (DQ 
                                                  (BracedVarSub
                                                    token: <VSub_Number 4>
                                                    suffix_op: 
                                                      (StringUnary
                                                        op_id: VTest_ColonHyphen
                                                        arg_word: {($ VSub_Number "$1")}
                                                      )
                                                    spids: [759 763]
                                                  )
                                                )
                                              }
                                            )
                                          ]
                                          op_id: Op_DAmp
                                        )
                                      ]
                                      op_id: Op_DAmp
                                    )
                                  ]
                                  op_id: Op_DAmp
                                )
                              ]
                              op_id: Op_DAmp
                            )
                          ]
                          op_id: Op_DAmp
                        )
                      ]
                      op_id: Op_DAmp
                    )
                  ]
                  op_id: Op_DAmp
                )
              ]
              op_id: Op_DAmp
            )
          ]
          spids: [592]
        )
      spids: [587 591]
    )
    (FuncDef
      name: test_merge
      body: 
        (BraceGroup
          children: [
            (AndOr
              children: [
                (C {(test_tick)})
                (AndOr
                  children: [
                    (C {(git)} {(merge)} {(-m)} {(DQ ($ VSub_Number "$1"))} {(DQ ($ VSub_Number "$2"))})
                    (C {(git)} {(tag)} {(DQ ($ VSub_Number "$1"))})
                  ]
                  op_id: Op_DAmp
                )
              ]
              op_id: Op_DAmp
            )
          ]
          spids: [781]
        )
      spids: [776 780]
    )
    (FuncDef
      name: test_chmod
      body: 
        (BraceGroup
          children: [
            (AndOr
              children: [
                (C {(chmod)} {(DQ ($ VSub_At "$@"))})
                (C {(git)} {(update-index)} {(--add)} {(DQ ("--chmod=") ($ VSub_At "$@"))})
              ]
              op_id: Op_DAmp
            )
          ]
          spids: [832]
        )
      spids: [827 831]
    )
    (FuncDef
      name: test_unconfig
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [(assign_pair lhs:(LhsName name:config_dir) op:Equal rhs:{(SQ )} spids:[869])]
              spids: [869]
            )
            (If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(DQ ($ VSub_Number "$1"))} {(Lit_Other "=")} {(-C)})]
                  action: [
                    (C {(shift)})
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:config_dir)
                          op: Equal
                          rhs: {($ VSub_Number "$1")}
                          spids: [891]
                        )
                      ]
                      spids: [891]
                    )
                    (C {(shift)})
                  ]
                  spids: [-1 885]
                )
              ]
              spids: [-1 898]
            )
            (C {(git)} 
              {
                (BracedVarSub
                  token: <VSub_Name config_dir>
                  suffix_op: 
                    (StringUnary
                      op_id: VTest_ColonPlus
                      arg_word: {("-C ") (DQ ($ VSub_Name "$config_dir"))}
                    )
                  spids: [903 910]
                )
              } {(config)} {(--unset-all)} {(DQ ($ VSub_At "$@"))}
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:config_status)
                  op: Equal
                  rhs: {($ VSub_QMark "$?")}
                  spids: [921]
                )
              ]
              spids: [921]
            )
            (Case
              to_match: {(DQ ($ VSub_Name "$config_status"))}
              arms: [
                (case_arm
                  pat_list: [{(5)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:config_status)
                          op: Equal
                          rhs: {(0)}
                          spids: [941]
                        )
                      ]
                      spids: [941]
                    )
                  ]
                  spids: [934 935 945 -1]
                )
              ]
              spids: [925 931 948]
            )
            (ControlFlow
              token: <ControlFlow_Return return>
              arg_word: {($ VSub_Name "$config_status")}
            )
          ]
          spids: [866]
        )
      spids: [861 865]
    )
    (FuncDef
      name: test_config
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [(assign_pair lhs:(LhsName name:config_dir) op:Equal rhs:{(SQ )} spids:[969])]
              spids: [969]
            )
            (If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(DQ ($ VSub_Number "$1"))} {(Lit_Other "=")} {(-C)})]
                  action: [
                    (C {(shift)})
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:config_dir)
                          op: Equal
                          rhs: {($ VSub_Number "$1")}
                          spids: [991]
                        )
                      ]
                      spids: [991]
                    )
                    (C {(shift)})
                  ]
                  spids: [-1 985]
                )
              ]
              spids: [-1 998]
            )
            (AndOr
              children: [
                (C {(test_when_finished)} 
                  {
                    (DQ ("test_unconfig ") 
                      (BracedVarSub
                        token: <VSub_Name config_dir>
                        suffix_op: 
                          (StringUnary
                            op_id: VTest_ColonPlus
                            arg_word: {("-C '") ($ VSub_Name "$config_dir") ("'")}
                          )
                        spids: [1005 1011]
                      ) (" '") ($ VSub_Number "$1") ("'")
                    )
                  }
                )
                (C {(git)} 
                  {
                    (BracedVarSub
                      token: <VSub_Name config_dir>
                      suffix_op: 
                        (StringUnary
                          op_id: VTest_ColonPlus
                          arg_word: {("-C ") (DQ ($ VSub_Name "$config_dir"))}
                        )
                      spids: [1022 1029]
                    )
                  } {(config)} {(DQ ($ VSub_At "$@"))}
                )
              ]
              op_id: Op_DAmp
            )
          ]
          spids: [966]
        )
      spids: [961 965]
    )
    (FuncDef
      name: test_config_global
      body: 
        (BraceGroup
          children: [
            (AndOr
              children: [
                (C {(test_when_finished)} {(DQ ("test_unconfig --global '") ($ VSub_Number "$1") ("'"))})
                (C {(git)} {(config)} {(--global)} {(DQ ($ VSub_At "$@"))})
              ]
              op_id: Op_DAmp
            )
          ]
          spids: [1045]
        )
      spids: [1040 1044]
    )
    (FuncDef
      name: write_script
      body: 
        (BraceGroup
          children: [
            (AndOr
              children: [
                (BraceGroup
                  children: [
                    (AndOr
                      children: [
                        (C {(echo)} 
                          {
                            (DQ ("#!") 
                              (BracedVarSub
                                token: <VSub_Number 2>
                                suffix_op: 
                                  (StringUnary
                                    op_id: VTest_Hyphen
                                    arg_word: {(DQ ($ VSub_Name "$SHELL_PATH"))}
                                  )
                                spids: [1087 1093]
                              )
                            )
                          }
                        )
                        (C {(cat)})
                      ]
                      op_id: Op_DAmp
                    )
                  ]
                  redirects: [
                    (Redir
                      op_id: Redir_Great
                      fd: -1
                      arg_word: {(DQ ($ VSub_Number "$1"))}
                      spids: [1104]
                    )
                  ]
                  spids: [1080]
                )
                (C {(chmod)} {(Lit_Other "+") (x)} {(DQ ($ VSub_Number "$1"))})
              ]
              op_id: Op_DAmp
            )
          ]
          spids: [1077]
        )
      spids: [1072 1076]
    )
    (FuncDef
      name: test_set_prereq
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:satisfied_prereq)
                  op: Equal
                  rhs: {(DQ ($ VSub_Name "$satisfied_prereq") ($ VSub_Number "$1") (" "))}
                  spids: [1163]
                )
              ]
              spids: [1163]
            )
          ]
          spids: [1160]
        )
      spids: [1155 1159]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:satisfied_prereq)
          op: Equal
          rhs: {(DQ (" "))}
          spids: [1172]
        )
      ]
      spids: [1172]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:lazily_testable_prereq)
          op: Equal
          rhs: {(SQ )}
          spids: [1177]
        )
        (assign_pair
          lhs: (LhsName name:lazily_tested_prereq)
          op: Equal
          rhs: {(SQ )}
          spids: [1179]
        )
      ]
      spids: [1177]
    )
    (FuncDef
      name: test_lazy_prereq
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:lazily_testable_prereq)
                  op: Equal
                  rhs: {(DQ ($ VSub_Name "$lazily_testable_prereq") ($ VSub_Number "$1") (" "))}
                  spids: [1193]
                )
              ]
              spids: [1193]
            )
            (C {(eval)} 
              {(test_prereq_lazily_) ($ VSub_Number "$1") (Lit_Other "=") 
                (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) (2)
              }
            )
          ]
          spids: [1190]
        )
      spids: [1185 1189]
    )
    (FuncDef
      name: test_run_lazy_prereq_
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:script)
                  op: Equal
                  rhs: 
                    {
                      (SQ <"\n"> <"mkdir -p \"$TRASH_DIRECTORY/prereq-test-dir\" &&\n"> <"(\n"> 
                        <"\tcd \"$TRASH_DIRECTORY/prereq-test-dir\" &&">
                      ) (DQ ($ VSub_Number "$2")) (SQ <"\n"> <")">)
                    }
                  spids: [1220]
                )
              ]
              spids: [1220]
            )
            (SimpleCommand
              words: [{(say)} {(DQ ("checking prerequisite: ") ($ VSub_Number "$1"))}]
              redirects: [(Redir op_id:Redir_GreatAnd fd:-1 arg_word:{(3)} spids:[1238])]
            )
            (SimpleCommand
              words: [{(say)} {(DQ ($ VSub_Name "$script"))}]
              redirects: [(Redir op_id:Redir_GreatAnd fd:-1 arg_word:{(3)} spids:[1249])]
            )
            (C {(test_eval_)} {(DQ ($ VSub_Name "$script"))})
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:eval_ret)
                  op: Equal
                  rhs: {($ VSub_QMark "$?")}
                  spids: [1264]
                )
              ]
              spids: [1264]
            )
            (C {(rm)} {(-rf)} {(DQ ($ VSub_Name "$TRASH_DIRECTORY") (/prereq-test-dir))})
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: (C {(test)} {(DQ ($ VSub_Name "$eval_ret"))} {(Lit_Other "=")} {(0)})
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (SimpleCommand
                      words: [{(say)} {(DQ ("prerequisite ") ($ VSub_Number "$1") (" ok"))}]
                      redirects: [(Redir op_id:Redir_GreatAnd fd:-1 arg_word:{(3)} spids:[1296])]
                    )
                  ]
                  spids: [-1 1291]
                )
              ]
              else_action: [
                (SimpleCommand
                  words: [{(say)} {(DQ ("prerequisite ") ($ VSub_Number "$1") (" not satisfied"))}]
                  redirects: [(Redir op_id:Redir_GreatAnd fd:-1 arg_word:{(3)} spids:[1311])]
                )
              ]
              spids: [1306 1321]
            )
            (ControlFlow
              token: <ControlFlow_Return return>
              arg_word: {($ VSub_Name "$eval_ret")}
            )
          ]
          spids: [1217]
        )
      spids: [1212 1216]
    )
    (FuncDef
      name: test_have_prereq
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:save_IFS)
                  op: Equal
                  rhs: {($ VSub_Name "$IFS")}
                  spids: [1343]
                )
              ]
              spids: [1343]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:IFS)
                  op: Equal
                  rhs: {(Lit_Comma ",")}
                  spids: [1347]
                )
              ]
              spids: [1347]
            )
            (C {(set)} {(--)} {($ VSub_Star "$*")})
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:IFS)
                  op: Equal
                  rhs: {($ VSub_Name "$save_IFS")}
                  spids: [1358]
                )
              ]
              spids: [1358]
            )
            (Assignment
              keyword: Assign_None
              pairs: [(assign_pair lhs:(LhsName name:total_prereq) op:Equal rhs:{(0)} spids:[1363])]
              spids: [1363]
            )
            (Assignment
              keyword: Assign_None
              pairs: [(assign_pair lhs:(LhsName name:ok_prereq) op:Equal rhs:{(0)} spids:[1367])]
              spids: [1367]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:missing_prereq)
                  op: Equal
                  rhs: {(SQ )}
                  spids: [1371]
                )
              ]
              spids: [1371]
            )
            (ForEach
              iter_name: prerequisite
              do_arg_iter: True
              body: 
                (DoGroup
                  children: [
                    (Case
                      to_match: {(DQ ($ VSub_Name "$prerequisite"))}
                      arms: [
                        (case_arm
                          pat_list: [{(KW_Bang "!") (Lit_Other "*")}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:negative_prereq)
                                  op: Equal
                                  rhs: {(t)}
                                  spids: [1397]
                                )
                              ]
                              spids: [1397]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:prerequisite)
                                  op: Equal
                                  rhs: 
                                    {
                                      (BracedVarSub
                                        token: <VSub_Name prerequisite>
                                        suffix_op: (StringUnary op_id:VOp1_Pound arg_word:{("!")})
                                        spids: [1402 1406]
                                      )
                                    }
                                  spids: [1401]
                                )
                              ]
                              spids: [1401]
                            )
                          ]
                          spids: [1392 1394 1409 -1]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other "*")}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:negative_prereq)
                                  op: Equal
                                  rhs: {(SQ )}
                                  spids: [1416]
                                )
                              ]
                              spids: [1416]
                            )
                          ]
                          spids: [1412 1413 -1 1419]
                        )
                      ]
                      spids: [1383 1389 1419]
                    )
                    (Case
                      to_match: {(DQ (" ") ($ VSub_Name "$lazily_tested_prereq") (" "))}
                      arms: [
                        (case_arm
                          pat_list: [
                            {(Lit_Other "*") (DQ (" ") ($ VSub_Name "$prerequisite") (" ")) 
                              (Lit_Other "*")
                            }
                          ]
                          spids: [1434 1441 1444 -1]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other "*")}]
                          action: [
                            (Case
                              to_match: {(DQ (" ") ($ VSub_Name "$lazily_testable_prereq") (" "))}
                              arms: [
                                (case_arm
                                  pat_list: [
                                    {(Lit_Other "*") (DQ (" ") ($ VSub_Name "$prerequisite") (" ")) 
                                      (Lit_Other "*")
                                    }
                                  ]
                                  action: [
                                    (AndOr
                                      children: [
                                        (C {(eval)} 
                                          {
                                            (DQ ("script=") 
                                              (EscapedLiteralPart
                                                token: <Lit_EscapedChar "\\$">
                                              ) (test_prereq_lazily_) ($ VSub_Name "$prerequisite")
                                            )
                                          }
                                        )
                                        (If
                                          arms: [
                                            (if_arm
                                              cond: [
                                                (C {(test_run_lazy_prereq_)} 
                                                  {(DQ ($ VSub_Name "$prerequisite"))} {(DQ ($ VSub_Name "$script"))}
                                                )
                                              ]
                                              action: [
                                                (C {(test_set_prereq)} {($ VSub_Name "$prerequisite")})
                                              ]
                                              spids: [-1 1497]
                                            )
                                          ]
                                          spids: [-1 1505]
                                        )
                                      ]
                                      op_id: Op_DAmp
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:lazily_tested_prereq)
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ ($ VSub_Name "$lazily_tested_prereq") 
                                                ($ VSub_Name "$prerequisite") (" ")
                                              )
                                            }
                                          spids: [1508]
                                        )
                                      ]
                                      spids: [1508]
                                    )
                                  ]
                                  spids: [1462 1469 -1 1516]
                                )
                              ]
                              spids: [1451 1459 1516]
                            )
                          ]
                          spids: [1447 1448 1519 -1]
                        )
                      ]
                      spids: [1423 1431 1522]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:total_prereq)
                          op: Equal
                          rhs: 
                            {
                              (ArithSubPart
                                anode: 
                                  (ArithBinary
                                    op_id: Arith_Plus
                                    left: (ArithWord w:{($ VSub_Name "$total_prereq")})
                                    right: (ArithWord w:{(Lit_Digits 1)})
                                  )
                                spids: [1527 1534]
                              )
                            }
                          spids: [1526]
                        )
                      ]
                      spids: [1526]
                    )
                    (Case
                      to_match: {(DQ ($ VSub_Name "$satisfied_prereq"))}
                      arms: [
                        (case_arm
                          pat_list: [
                            {(Lit_Other "*") (DQ (" ") ($ VSub_Name "$prerequisite") (" ")) 
                              (Lit_Other "*")
                            }
                          ]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:satisfied_this_prereq)
                                  op: Equal
                                  rhs: {(t)}
                                  spids: [1556]
                                )
                              ]
                              spids: [1556]
                            )
                          ]
                          spids: [1546 1553 1560 -1]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other "*")}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:satisfied_this_prereq)
                                  op: Equal
                                  rhs: {(SQ )}
                                  spids: [1567]
                                )
                              ]
                              spids: [1567]
                            )
                          ]
                          spids: [1563 1564 -1 1570]
                        )
                      ]
                      spids: [1537 1543 1570]
                    )
                    (Case
                      to_match: 
                        {
                          (DQ ($ VSub_Name "$satisfied_this_prereq") (",") 
                            ($ VSub_Name "$negative_prereq")
                          )
                        }
                      arms: [
                        (case_arm
                          pat_list: [{(t) (Lit_Comma ",")} {(Lit_Comma ",") (t)}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:ok_prereq)
                                  op: Equal
                                  rhs: 
                                    {
                                      (ArithSubPart
                                        anode: 
                                          (ArithBinary
                                            op_id: Arith_Plus
                                            left: (ArithWord w:{($ VSub_Name "$ok_prereq")})
                                            right: (ArithWord w:{(Lit_Digits 1)})
                                          )
                                        spids: [1594 1601]
                                      )
                                    }
                                  spids: [1593]
                                )
                              ]
                              spids: [1593]
                            )
                          ]
                          spids: [1585 1590 1604 -1]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other "*")}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:prerequisite)
                                  op: Equal
                                  rhs: 
                                    {
                                      (BracedVarSub
                                        token: <VSub_Name negative_prereq>
                                        suffix_op: (StringUnary op_id:VTest_ColonPlus arg_word:{("!")})
                                        spids: [1620 1624]
                                      ) ($ VSub_Name "$prerequisite")
                                    }
                                  spids: [1619]
                                )
                              ]
                              spids: [1619]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [(C {(test)} {(-z)} {(DQ ($ VSub_Name "$missing_prereq"))})]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:missing_prereq)
                                          op: Equal
                                          rhs: {($ VSub_Name "$prerequisite")}
                                          spids: [1642]
                                        )
                                      ]
                                      spids: [1642]
                                    )
                                  ]
                                  spids: [-1 1639]
                                )
                              ]
                              else_action: [
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:missing_prereq)
                                      op: Equal
                                      rhs: 
                                        {
                                          (DQ ($ VSub_Name "$prerequisite") (",") 
                                            ($ VSub_Name "$missing_prereq")
                                          )
                                        }
                                      spids: [1649]
                                    )
                                  ]
                                  spids: [1649]
                                )
                              ]
                              spids: [1646 1657]
                            )
                          ]
                          spids: [1607 1608 -1 1660]
                        )
                      ]
                      spids: [1574 1582 1660]
                    )
                  ]
                  spids: [1380 1663]
                )
              spids: [-1 -1]
            )
            (C {(test)} {($ VSub_Name "$total_prereq")} {(Lit_Other "=")} {($ VSub_Name "$ok_prereq")})
          ]
          spids: [1336]
        )
      spids: [1331 1335]
    )
    (FuncDef
      name: test_declared_prereq
      body: 
        (BraceGroup
          children: [
            (Case
              to_match: {(DQ (",") ($ VSub_Name "$test_prereq") (","))}
              arms: [
                (case_arm
                  pat_list: [
                    {(Lit_Other "*") (Lit_Comma ",") ($ VSub_Number "$1") (Lit_Comma ",") 
                      (Lit_Other "*")
                    }
                  ]
                  action: [(ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})]
                  spids: [1697 1702 1710 -1]
                )
              ]
              spids: [1686 1694 1713]
            )
            (ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})
          ]
          spids: [1683]
        )
      spids: [1678 1682]
    )
    (FuncDef
      name: test_verify_prereq
      body: 
        (BraceGroup
          children: [
            (AndOr
              children: [
                (C {(test)} {(-z)} {(DQ ($ VSub_Name "$test_prereq"))})
                (AndOr
                  children: [
                    (SimpleCommand
                      words: [
                        {(expr)}
                        {(DQ ($ VSub_Name "$test_prereq"))}
                        {(Lit_Other ":")}
                        {(SQ <"[A-Z0-9_,!]*$">)}
                      ]
                      redirects: [(Redir op_id:Redir_Great fd:-1 arg_word:{(/dev/null)} spids:[1744])]
                    )
                    (C {(error)} 
                      {
                        (DQ ("bug in the test script: '") ($ VSub_Name "$test_prereq") 
                          ("' does not look like a prereq")
                        )
                      }
                    )
                  ]
                  op_id: Op_DPipe
                )
              ]
              op_id: Op_DPipe
            )
          ]
          spids: [1728]
        )
      spids: [1723 1727]
    )
    (FuncDef
      name: test_expect_failure
      body: 
        (BraceGroup
          children: [
            (C {(test_start_)})
            (AndOr
              children: [
                (C {(test)} {(DQ ($ VSub_Pound "$#"))} {(Lit_Other "=")} {(3)})
                (AndOr
                  children: [
                    (BraceGroup
                      children: [
                        (Sentence
                          child: 
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:test_prereq)
                                  op: Equal
                                  rhs: {($ VSub_Number "$1")}
                                  spids: [1796]
                                )
                              ]
                              spids: [1796]
                            )
                          terminator: <Op_Semi ";">
                        )
                        (Sentence
                          child: (C {(shift)})
                          terminator: <Op_Semi ";">
                        )
                      ]
                      spids: [1794]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:test_prereq)
                          op: Equal
                          rhs: {(SQ )}
                          spids: [1807]
                        )
                      ]
                      spids: [1807]
                    )
                  ]
                  op_id: Op_DPipe
                )
              ]
              op_id: Op_DAmp
            )
            (AndOr
              children: [
                (C {(test)} {(DQ ($ VSub_Pound "$#"))} {(Lit_Other "=")} {(2)})
                (C {(error)} 
                  {(DQ ("bug in the test script: not 2 or 3 parameters to test-expect-failure"))}
                )
              ]
              op_id: Op_DPipe
            )
            (C {(test_verify_prereq)})
            (C {(export)} {(test_prereq)})
            (If
              arms: [
                (if_arm
                  cond: [(Pipeline children:[(C {(test_skip)} {(DQ ($ VSub_At "$@"))})] negated:True)]
                  action: [
                    (SimpleCommand
                      words: [{(say)} {(DQ ("checking known breakage: ") ($ VSub_Number "$2"))}]
                      redirects: [(Redir op_id:Redir_GreatAnd fd:-1 arg_word:{(3)} spids:[1854])]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [(C {(test_run_)} {(DQ ($ VSub_Number "$2"))} {(expecting_failure)})]
                          action: [(C {(test_known_broken_ok_)} {(DQ ($ VSub_Number "$1"))})]
                          spids: [-1 1874]
                        )
                      ]
                      else_action: [(C {(test_known_broken_failure_)} {(DQ ($ VSub_Number "$1"))})]
                      spids: [1884 1894]
                    )
                  ]
                  spids: [-1 1849]
                )
              ]
              spids: [-1 1897]
            )
            (C {(test_finish_)})
          ]
          spids: [1776]
        )
      spids: [1771 1775]
    )
    (FuncDef
      name: test_expect_success
      body: 
        (BraceGroup
          children: [
            (C {(test_start_)})
            (AndOr
              children: [
                (C {(test)} {(DQ ($ VSub_Pound "$#"))} {(Lit_Other "=")} {(3)})
                (AndOr
                  children: [
                    (BraceGroup
                      children: [
                        (Sentence
                          child: 
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:test_prereq)
                                  op: Equal
                                  rhs: {($ VSub_Number "$1")}
                                  spids: [1930]
                                )
                              ]
                              spids: [1930]
                            )
                          terminator: <Op_Semi ";">
                        )
                        (Sentence
                          child: (C {(shift)})
                          terminator: <Op_Semi ";">
                        )
                      ]
                      spids: [1928]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:test_prereq)
                          op: Equal
                          rhs: {(SQ )}
                          spids: [1941]
                        )
                      ]
                      spids: [1941]
                    )
                  ]
                  op_id: Op_DPipe
                )
              ]
              op_id: Op_DAmp
            )
            (AndOr
              children: [
                (C {(test)} {(DQ ($ VSub_Pound "$#"))} {(Lit_Other "=")} {(2)})
                (C {(error)} 
                  {(DQ ("bug in the test script: not 2 or 3 parameters to test-expect-success"))}
                )
              ]
              op_id: Op_DPipe
            )
            (C {(test_verify_prereq)})
            (C {(export)} {(test_prereq)})
            (If
              arms: [
                (if_arm
                  cond: [(Pipeline children:[(C {(test_skip)} {(DQ ($ VSub_At "$@"))})] negated:True)]
                  action: [
                    (SimpleCommand
                      words: [{(say)} {(DQ ("expecting success: ") ($ VSub_Number "$2"))}]
                      redirects: [(Redir op_id:Redir_GreatAnd fd:-1 arg_word:{(3)} spids:[1988])]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [(C {(test_run_)} {(DQ ($ VSub_Number "$2"))})]
                          action: [(C {(test_ok_)} {(DQ ($ VSub_Number "$1"))})]
                          spids: [-1 2006]
                        )
                      ]
                      else_action: [(C {(test_failure_)} {(DQ ($ VSub_At "$@"))})]
                      spids: [2016 2026]
                    )
                  ]
                  spids: [-1 1983]
                )
              ]
              spids: [-1 2029]
            )
            (C {(test_finish_)})
          ]
          spids: [1910]
        )
      spids: [1905 1909]
    )
    (FuncDef
      name: test_external
      body: 
        (BraceGroup
          children: [
            (AndOr
              children: [
                (C {(test)} {(DQ ($ VSub_Pound "$#"))} {(Lit_Other "=")} {(4)})
                (AndOr
                  children: [
                    (BraceGroup
                      children: [
                        (Sentence
                          child: 
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:test_prereq)
                                  op: Equal
                                  rhs: {($ VSub_Number "$1")}
                                  spids: [2083]
                                )
                              ]
                              spids: [2083]
                            )
                          terminator: <Op_Semi ";">
                        )
                        (Sentence
                          child: (C {(shift)})
                          terminator: <Op_Semi ";">
                        )
                      ]
                      spids: [2081]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:test_prereq)
                          op: Equal
                          rhs: {(SQ )}
                          spids: [2094]
                        )
                      ]
                      spids: [2094]
                    )
                  ]
                  op_id: Op_DPipe
                )
              ]
              op_id: Op_DAmp
            )
            (AndOr
              children: [
                (C {(test)} {(DQ ($ VSub_Pound "$#"))} {(Lit_Other "=")} {(3)})
                (SimpleCommand
                  words: [
                    {(error)}
                    {(DQ ("bug in the test script: not 3 or 4 parameters to test_external"))}
                  ]
                  redirects: [(Redir op_id:Redir_GreatAnd fd:-1 arg_word:{(5)} spids:[2112])]
                )
              ]
              op_id: Op_DPipe
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:descr)
                  op: Equal
                  rhs: {(DQ ($ VSub_Number "$1"))}
                  spids: [2120]
                )
              ]
              spids: [2120]
            )
            (C {(shift)})
            (C {(test_verify_prereq)})
            (C {(export)} {(test_prereq)})
            (If
              arms: [
                (if_arm
                  cond: [
                    (Pipeline
                      children: [(C {(test_skip)} {(DQ ($ VSub_Name "$descr"))} {(DQ ($ VSub_At "$@"))})]
                      negated: True
                    )
                  ]
                  action: [
                    (C {(say_color)} {(DQ )} 
                      {
                        (DQ ("# run ") ($ VSub_Name "$test_count") (": ") ($ VSub_Name "$descr") (" (") 
                          ($ VSub_Star "$*") (")")
                        )
                      }
                    )
                    (C {(export)} {(TEST_DIRECTORY)} {(TRASH_DIRECTORY)} {(GIT_TEST_LONG)})
                    (SimpleCommand
                      words: [{(DQ ($ VSub_At "$@"))}]
                      redirects: [(Redir op_id:Redir_GreatAnd fd:2 arg_word:{(4)} spids:[2212])]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [(C {(test)} {(DQ ($ VSub_QMark "$?"))} {(Lit_Other "=")} {(0)})]
                          action: [
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (C {(test)} {($ VSub_Name "$test_external_has_tap")} {(-eq)} 
                                          {(0)}
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [(C {(test_ok_)} {(DQ ($ VSub_Name "$descr"))})]
                                  spids: [-1 2243]
                                )
                              ]
                              else_action: [
                                (C {(say_color)} {(DQ )} 
                                  {(DQ ("# test_external test ") ($ VSub_Name "$descr") (" was ok"))}
                                )
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:test_success)
                                      op: Equal
                                      rhs: 
                                        {
                                          (ArithSubPart
                                            anode: 
                                              (ArithBinary
                                                op_id: Arith_Plus
                                                left: (ArithWord w:{($ VSub_Name "$test_success")})
                                                right: (ArithWord w:{(Lit_Digits 1)})
                                              )
                                            spids: [2269 2276]
                                          )
                                        }
                                      spids: [2268]
                                    )
                                  ]
                                  spids: [2268]
                                )
                              ]
                              spids: [2253 2279]
                            )
                          ]
                          spids: [-1 2229]
                        )
                      ]
                      else_action: [
                        (If
                          arms: [
                            (if_arm
                              cond: [
                                (Sentence
                                  child: 
                                    (C {(test)} {($ VSub_Name "$test_external_has_tap")} {(-eq)} {(0)})
                                  terminator: <Op_Semi ";">
                                )
                              ]
                              action: [
                                (C {(test_failure_)} {(DQ ($ VSub_Name "$descr"))} 
                                  {(DQ ($ VSub_At "$@"))}
                                )
                              ]
                              spids: [-1 2296]
                            )
                          ]
                          else_action: [
                            (C {(say_color)} {(error)} 
                              {
                                (DQ ("# test_external test ") ($ VSub_Name "$descr") (" failed: ") 
                                  ($ VSub_At "$@")
                                )
                              }
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:test_failure)
                                  op: Equal
                                  rhs: 
                                    {
                                      (ArithSubPart
                                        anode: 
                                          (ArithBinary
                                            op_id: Arith_Plus
                                            left: (ArithWord w:{($ VSub_Name "$test_failure")})
                                            right: (ArithWord w:{(Lit_Digits 1)})
                                          )
                                        spids: [2326 2333]
                                      )
                                    }
                                  spids: [2325]
                                )
                              ]
                              spids: [2325]
                            )
                          ]
                          spids: [2310 2336]
                        )
                      ]
                      spids: [2282 2339]
                    )
                  ]
                  spids: [-1 2152]
                )
              ]
              spids: [-1 2342]
            )
          ]
          spids: [2066]
        )
      spids: [2061 2065]
    )
    (FuncDef
      name: test_external_without_stderr
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:tmp)
                  op: Equal
                  rhs: 
                    {
                      (BracedVarSub
                        token: <VSub_Name TMPDIR>
                        suffix_op: (StringUnary op_id:VTest_ColonHyphen arg_word:{(Lit_Slash /) (tmp)})
                        spids: [2370 2375]
                      )
                    }
                  spids: [2369]
                )
              ]
              spids: [2369]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:stderr)
                  op: Equal
                  rhs: {(DQ ($ VSub_Name "$tmp") (/git-external-stderr.) ($ VSub_Dollar "$$") (.tmp))}
                  spids: [2378]
                )
              ]
              spids: [2378]
            )
            (SimpleCommand
              words: [{(test_external)} {(DQ ($ VSub_At "$@"))}]
              redirects: [
                (Redir
                  op_id: Redir_Great
                  fd: 4
                  arg_word: {(DQ ($ VSub_Name "$stderr"))}
                  spids: [2393]
                )
              ]
            )
            (AndOr
              children: [
                (C {(test)} {(-f)} {(DQ ($ VSub_Name "$stderr"))})
                (C {(error)} {(DQ ("Internal error: ") ($ VSub_Name "$stderr") (" disappeared."))})
              ]
              op_id: Op_DPipe
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:descr)
                  op: Equal
                  rhs: {(DQ ("no stderr: ") ($ VSub_Number "$1"))}
                  spids: [2419]
                )
              ]
              spids: [2419]
            )
            (C {(shift)})
            (SimpleCommand
              words: [{(say)} {(DQ ("# expecting no stderr from previous command"))}]
              redirects: [(Redir op_id:Redir_GreatAnd fd:-1 arg_word:{(3)} spids:[2431])]
            )
            (If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(KW_Bang "!")} {(-s)} {(DQ ($ VSub_Name "$stderr"))})]
                  action: [
                    (C {(rm)} {(DQ ($ VSub_Name "$stderr"))})
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (C {(test)} {($ VSub_Name "$test_external_has_tap")} {(-eq)} {(0)})
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [(C {(test_ok_)} {(DQ ($ VSub_Name "$descr"))})]
                          spids: [-1 2474]
                        )
                      ]
                      else_action: [
                        (C {(say_color)} {(DQ )} 
                          {
                            (DQ ("# test_external_without_stderr test ") ($ VSub_Name "$descr") 
                              (" was ok")
                            )
                          }
                        )
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:test_success)
                              op: Equal
                              rhs: 
                                {
                                  (ArithSubPart
                                    anode: 
                                      (ArithBinary
                                        op_id: Arith_Plus
                                        left: (ArithWord w:{($ VSub_Name "$test_success")})
                                        right: (ArithWord w:{(Lit_Digits 1)})
                                      )
                                    spids: [2500 2507]
                                  )
                                }
                              spids: [2499]
                            )
                          ]
                          spids: [2499]
                        )
                      ]
                      spids: [2484 2510]
                    )
                  ]
                  spids: [-1 2452]
                )
              ]
              else_action: [
                (If
                  arms: [
                    (if_arm
                      cond: [(C {(test)} {(DQ ($ VSub_Name "$verbose"))} {(Lit_Other "=")} {(t)})]
                      action: [
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:output)
                              op: Equal
                              rhs: 
                                {
                                  (CommandSubPart
                                    command_list: 
                                      (CommandList
                                        children: [
                                          (Sentence
                                            child: (C {(echo)})
                                            terminator: <Op_Semi ";">
                                          )
                                          (Sentence
                                            child: (C {(echo)} {(DQ ("# Stderr is:"))})
                                            terminator: <Op_Semi ";">
                                          )
                                          (C {(cat)} {(DQ ($ VSub_Name "$stderr"))})
                                        ]
                                      )
                                    left_token: <Left_CommandSub "$(">
                                    spids: [2533 2549]
                                  )
                                }
                              spids: [2532]
                            )
                          ]
                          spids: [2532]
                        )
                      ]
                      spids: [-1 2529]
                    )
                  ]
                  else_action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:output)
                          op: Equal
                          rhs: {(SQ )}
                          spids: [2555]
                        )
                      ]
                      spids: [2555]
                    )
                  ]
                  spids: [2552 2558]
                )
                (C {(rm)} {(DQ ($ VSub_Name "$stderr"))})
                (If
                  arms: [
                    (if_arm
                      cond: [
                        (Sentence
                          child: (C {(test)} {($ VSub_Name "$test_external_has_tap")} {(-eq)} {(0)})
                          terminator: <Op_Semi ";">
                        )
                      ]
                      action: [
                        (C {(test_failure_)} {(DQ ($ VSub_Name "$descr"))} {(DQ ($ VSub_At "$@"))} 
                          {(DQ ($ VSub_Name "$output"))}
                        )
                      ]
                      spids: [-1 2583]
                    )
                  ]
                  else_action: [
                    (C {(say_color)} {(error)} 
                      {
                        (DQ ("# test_external_without_stderr test ") ($ VSub_Name "$descr") 
                          (" failed: ") ($ VSub_At "$@") (": ") ($ VSub_Name "$output")
                        )
                      }
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:test_failure)
                          op: Equal
                          rhs: 
                            {
                              (ArithSubPart
                                anode: 
                                  (ArithBinary
                                    op_id: Arith_Plus
                                    left: (ArithWord w:{($ VSub_Name "$test_failure")})
                                    right: (ArithWord w:{(Lit_Digits 1)})
                                  )
                                spids: [2619 2626]
                              )
                            }
                          spids: [2618]
                        )
                      ]
                      spids: [2618]
                    )
                  ]
                  spids: [2601 2629]
                )
              ]
              spids: [2513 2632]
            )
          ]
          spids: [2358]
        )
      spids: [2353 2357]
    )
    (FuncDef
      name: test_path_is_file
      body: 
        (BraceGroup
          children: [
            (If
              arms: [
                (if_arm
                  cond: [
                    (Pipeline
                      children: [(C {(test)} {(-f)} {(DQ ($ VSub_Number "$1"))})]
                      negated: True
                    )
                  ]
                  action: [
                    (C {(echo)} 
                      {(DQ ("File ") ($ VSub_Number "$1") (" doesn't exist. ") ($ VSub_Number "$2"))}
                    )
                    (C {(false)})
                  ]
                  spids: [-1 2667]
                )
              ]
              spids: [-1 2683]
            )
          ]
          spids: [2651]
        )
      spids: [2646 2650]
    )
    (FuncDef
      name: test_path_is_dir
      body: 
        (BraceGroup
          children: [
            (If
              arms: [
                (if_arm
                  cond: [
                    (Pipeline
                      children: [(C {(test)} {(-d)} {(DQ ($ VSub_Number "$1"))})]
                      negated: True
                    )
                  ]
                  action: [
                    (C {(echo)} 
                      {
                        (DQ ("Directory ") ($ VSub_Number "$1") (" doesn't exist. ") 
                          ($ VSub_Number "$2")
                        )
                      }
                    )
                    (C {(false)})
                  ]
                  spids: [-1 2709]
                )
              ]
              spids: [-1 2725]
            )
          ]
          spids: [2693]
        )
      spids: [2688 2692]
    )
    (FuncDef
      name: test_dir_is_empty
      body: 
        (BraceGroup
          children: [
            (AndOr
              children: [
                (C {(test_path_is_dir)} {(DQ ($ VSub_Number "$1"))})
                (If
                  arms: [
                    (if_arm
                      cond: [
                        (C {(test)} {(-n)} 
                          {
                            (DQ 
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [
                                      (Pipeline
                                        children: [
                                          (C {(ls)} {(-a1)} {(DQ ($ VSub_Number "$1"))})
                                          (C {(egrep)} {(-v)} {(SQ <"^\\.\\.?$">)})
                                        ]
                                        negated: False
                                      )
                                    ]
                                  )
                                left_token: <Left_CommandSub "$(">
                                spids: [2757 2775]
                              )
                            )
                          }
                        )
                      ]
                      action: [
                        (C {(echo)} 
                          {
                            (DQ ("Directory '") ($ VSub_Number "$1") ("' is not empty, it contains:"))
                          }
                        )
                        (C {(ls)} {(-la)} {(DQ ($ VSub_Number "$1"))})
                        (ControlFlow
                          token: <ControlFlow_Return return>
                          arg_word: {(1)}
                        )
                      ]
                      spids: [-1 2779]
                    )
                  ]
                  spids: [-1 2805]
                )
              ]
              op_id: Op_DAmp
            )
          ]
          spids: [2738]
        )
      spids: [2733 2737]
    )
    (FuncDef
      name: test_path_is_missing
      body: 
        (BraceGroup
          children: [
            (If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(-e)} {(DQ ($ VSub_Number "$1"))})]
                  action: [
                    (C {(echo)} {(DQ ("Path exists:"))})
                    (C {(ls)} {(-ld)} {(DQ ($ VSub_Number "$1"))})
                    (If
                      arms: [
                        (if_arm
                          cond: [(C {(test)} {($ VSub_Pound "$#")} {(-ge)} {(1)})]
                          action: [(C {(echo)} {(DQ ($ VSub_Star "$*"))})]
                          spids: [-1 2859]
                        )
                      ]
                      spids: [-1 2869]
                    )
                    (C {(false)})
                  ]
                  spids: [-1 2829]
                )
              ]
              spids: [-1 2875]
            )
          ]
          spids: [2815]
        )
      spids: [2810 2814]
    )
    (FuncDef
      name: test_line_count
      body: 
        (BraceGroup
          children: [
            (If
              arms: [
                (if_arm
                  cond: [(C {(test)} {($ VSub_Pound "$#")} {(KW_Bang "!") (Lit_Other "=")} {(3)})]
                  action: [
                    (C {(error)} {(DQ ("bug in the test script: not 3 parameters to test_line_count"))})
                  ]
                  spids: [-1 2931]
                )
                (if_arm
                  cond: [
                    (Pipeline
                      children: [
                        (C {(test)} 
                          {
                            (CommandSubPart
                              command_list: 
                                (CommandList
                                  children: [
                                    (SimpleCommand
                                      words: [{(wc)} {(-l)}]
                                      redirects: [
                                        (Redir
                                          op_id: Redir_Less
                                          fd: -1
                                          arg_word: {(DQ ($ VSub_Number "$3"))}
                                          spids: [2952]
                                        )
                                      ]
                                    )
                                  ]
                                )
                              left_token: <Left_CommandSub "$(">
                              spids: [2947 2956]
                            )
                          } {(DQ ($ VSub_Number "$1"))} {(DQ ($ VSub_Number "$2"))}
                        )
                      ]
                      negated: True
                    )
                  ]
                  action: [
                    (C {(echo)} 
                      {
                        (DQ ("test_line_count: line count for ") ($ VSub_Number "$3") (" !") 
                          ($ VSub_Number "$1") (" ") ($ VSub_Number "$2")
                        )
                      }
                    )
                    (C {(cat)} {(DQ ($ VSub_Number "$3"))})
                    (ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})
                  ]
                  spids: [2941 2967]
                )
              ]
              spids: [-1 2994]
            )
          ]
          spids: [2916]
        )
      spids: [2911 2915]
    )
    (FuncDef
      name: list_contains
      body: 
        (BraceGroup
          children: [
            (Case
              to_match: {(DQ (",") ($ VSub_Number "$1") (","))}
              arms: [
                (case_arm
                  pat_list: [
                    {(Lit_Other "*") (Lit_Comma ",") ($ VSub_Number "$2") (Lit_Comma ",") 
                      (Lit_Other "*")
                    }
                  ]
                  action: [(ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})]
                  spids: [3034 3039 3047 -1]
                )
              ]
              spids: [3023 3031 3050]
            )
            (ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})
          ]
          spids: [3020]
        )
      spids: [3015 3019]
    )
    (FuncDef
      name: test_must_fail
      body: 
        (BraceGroup
          children: [
            (Case
              to_match: {(DQ ($ VSub_Number "$1"))}
              arms: [
                (case_arm
                  pat_list: [{(Lit_VarLike "ok=") (Lit_Other "*")}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:_test_ok)
                          op: Equal
                          rhs: 
                            {
                              (BracedVarSub
                                token: <VSub_Number 1>
                                suffix_op: (StringUnary op_id:VOp1_Pound arg_word:{("ok=")})
                                spids: [3117 3121]
                              )
                            }
                          spids: [3116]
                        )
                      ]
                      spids: [3116]
                    )
                    (C {(shift)})
                  ]
                  spids: [3111 3113 3127 -1]
                )
                (case_arm
                  pat_list: [{(Lit_Other "*")}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:_test_ok)
                          op: Equal
                          rhs: {(SQ )}
                          spids: [3134]
                        )
                      ]
                      spids: [3134]
                    )
                  ]
                  spids: [3130 3131 3137 -1]
                )
              ]
              spids: [3102 3108 3140]
            )
            (C {(DQ ($ VSub_At "$@"))})
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:exit_code)
                  op: Equal
                  rhs: {($ VSub_QMark "$?")}
                  spids: [3148]
                )
              ]
              spids: [3148]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (AndOr
                      children: [
                        (C {(test)} {($ VSub_Name "$exit_code")} {(-eq)} {(0)})
                        (Pipeline
                          children: [(C {(list_contains)} {(DQ ($ VSub_Name "$_test_ok"))} {(success)})]
                          negated: True
                        )
                      ]
                      op_id: Op_DAmp
                    )
                  ]
                  action: [
                    (SimpleCommand
                      words: [{(echo)} {(DQ ("test_must_fail: command succeeded: ") ($ VSub_Star "$*"))}]
                      redirects: [(Redir op_id:Redir_GreatAnd fd:-1 arg_word:{(2)} spids:[3180])]
                    )
                    (ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})
                  ]
                  spids: [-1 3175]
                )
                (if_arm
                  cond: [
                    (AndOr
                      children: [
                        (C {(test_match_signal)} {(13)} {($ VSub_Name "$exit_code")})
                        (C {(list_contains)} {(DQ ($ VSub_Name "$_test_ok"))} {(sigpipe)})
                      ]
                      op_id: Op_DAmp
                    )
                  ]
                  action: [(ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})]
                  spids: [3194 3213]
                )
                (if_arm
                  cond: [
                    (AndOr
                      children: [
                        (C {(test)} {($ VSub_Name "$exit_code")} {(-gt)} {(129)})
                        (C {(test)} {($ VSub_Name "$exit_code")} {(-le)} {(192)})
                      ]
                      op_id: Op_DAmp
                    )
                  ]
                  action: [
                    (SimpleCommand
                      words: [
                        {(echo)}
                        {
                          (DQ ("test_must_fail: died by signal ") 
                            (ArithSubPart
                              anode: 
                                (ArithBinary
                                  op_id: Arith_Minus
                                  left: (ArithWord w:{($ VSub_Name "$exit_code")})
                                  right: (ArithWord w:{(Lit_Digits 128)})
                                )
                              spids: [3252 3259]
                            ) (": ") ($ VSub_Star "$*")
                          )
                        }
                      ]
                      redirects: [(Redir op_id:Redir_GreatAnd fd:-1 arg_word:{(2)} spids:[3247])]
                    )
                    (ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})
                  ]
                  spids: [3221 3242]
                )
                (if_arm
                  cond: [(C {(test)} {($ VSub_Name "$exit_code")} {(-eq)} {(127)})]
                  action: [
                    (SimpleCommand
                      words: [{(echo)} {(DQ ("test_must_fail: command not found: ") ($ VSub_Star "$*"))}]
                      redirects: [(Redir op_id:Redir_GreatAnd fd:-1 arg_word:{(2)} spids:[3286])]
                    )
                    (ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})
                  ]
                  spids: [3270 3281]
                )
                (if_arm
                  cond: [(C {(test)} {($ VSub_Name "$exit_code")} {(-eq)} {(126)})]
                  action: [
                    (SimpleCommand
                      words: [{(echo)} {(DQ ("test_must_fail: valgrind error: ") ($ VSub_Star "$*"))}]
                      redirects: [(Redir op_id:Redir_GreatAnd fd:-1 arg_word:{(2)} spids:[3316])]
                    )
                    (ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})
                  ]
                  spids: [3300 3311]
                )
              ]
              spids: [-1 3330]
            )
            (ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
          ]
          spids: [3099]
        )
      spids: [3094 3098]
    )
    (FuncDef
      name: test_might_fail
      body: 
        (BraceGroup
          children: [(C {(test_must_fail)} {(Lit_VarLike "ok=") (success)} {(DQ ($ VSub_At "$@"))})]
          spids: [3376]
        )
      spids: [3371 3375]
    )
    (FuncDef
      name: test_expect_code
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:want_code)
                  op: Equal
                  rhs: {($ VSub_Number "$1")}
                  spids: [3418]
                )
              ]
              spids: [3418]
            )
            (C {(shift)})
            (C {(DQ ($ VSub_At "$@"))})
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:exit_code)
                  op: Equal
                  rhs: {($ VSub_QMark "$?")}
                  spids: [3430]
                )
              ]
              spids: [3430]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (C {(test)} {($ VSub_Name "$exit_code")} {(Lit_Other "=")} 
                      {($ VSub_Name "$want_code")}
                    )
                  ]
                  action: [(ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})]
                  spids: [-1 3445]
                )
              ]
              spids: [-1 3453]
            )
            (SimpleCommand
              words: [
                {(echo)}
                {
                  (DQ ("test_expect_code: command exited with ") ($ VSub_Name "$exit_code") 
                    (", we wanted ") ($ VSub_Name "$want_code") (" ") ($ VSub_Star "$*")
                  )
                }
              ]
              redirects: [(Redir op_id:Redir_GreatAnd fd:-1 arg_word:{(2)} spids:[3459])]
            )
            (ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})
          ]
          spids: [3415]
        )
      spids: [3410 3414]
    )
    (FuncDef
      name: test_cmp
      body: 
        (BraceGroup
          children: [(C {($ VSub_Name "$GIT_TEST_CMP")} {(DQ ($ VSub_At "$@"))})]
          spids: [3520]
        )
      spids: [3516 3519]
    )
    (FuncDef
      name: test_cmp_bin
      body: (BraceGroup children:[(C {(cmp)} {(DQ ($ VSub_At "$@"))})] spids:[3540])
      spids: [3536 3539]
    )
    (FuncDef
      name: verbose
      body: 
        (BraceGroup
          children: [
            (AndOr
              children: [
                (C {(DQ ($ VSub_At "$@"))})
                (ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
              ]
              op_id: Op_DAmp
            )
            (SimpleCommand
              words: [
                {(echo)}
                {
                  (DQ ("command failed: ") 
                    (CommandSubPart
                      command_list: 
                        (CommandList
                          children: [(C {(git)} {(rev-parse)} {(--sq-quote)} {(DQ ($ VSub_At "$@"))})]
                        )
                      left_token: <Left_CommandSub "$(">
                      spids: [3587 3597]
                    )
                  )
                }
              ]
              redirects: [(Redir op_id:Redir_GreatAnd fd:-1 arg_word:{(2)} spids:[3582])]
            )
            (ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})
          ]
          spids: [3566]
        )
      spids: [3561 3565]
    )
    (FuncDef
      name: test_must_be_empty
      body: 
        (BraceGroup
          children: [
            (If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(-s)} {(DQ ($ VSub_Number "$1"))})]
                  action: [
                    (C {(echo)} {(DQ ("'") ($ VSub_Number "$1") ("' is not empty, it contains:"))})
                    (C {(cat)} {(DQ ($ VSub_Number "$1"))})
                    (ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})
                  ]
                  spids: [-1 3634]
                )
              ]
              spids: [-1 3658]
            )
          ]
          spids: [3620]
        )
      spids: [3615 3619]
    )
    (FuncDef
      name: test_cmp_rev
      body: 
        (BraceGroup
          children: [
            (AndOr
              children: [
                (SimpleCommand
                  words: [{(git)} {(rev-parse)} {(--verify)} {(DQ ($ VSub_Number "$1"))}]
                  redirects: [(Redir op_id:Redir_Great fd:-1 arg_word:{(expect.rev)} spids:[3684])]
                )
                (AndOr
                  children: [
                    (SimpleCommand
                      words: [{(git)} {(rev-parse)} {(--verify)} {(DQ ($ VSub_Number "$2"))}]
                      redirects: [
                        (Redir
                          op_id: Redir_Great
                          fd: -1
                          arg_word: {(actual.rev)}
                          spids: [3700]
                        )
                      ]
                    )
                    (C {(test_cmp)} {(expect.rev)} {(actual.rev)})
                  ]
                  op_id: Op_DAmp
                )
              ]
              op_id: Op_DAmp
            )
          ]
          spids: [3671]
        )
      spids: [3666 3670]
    )
    (FuncDef
      name: test_seq
      body: 
        (BraceGroup
          children: [
            (Case
              to_match: {($ VSub_Pound "$#")}
              arms: [
                (case_arm
                  pat_list: [{(1)}]
                  action: [(C {(set)} {(1)} {(DQ ($ VSub_At "$@"))})]
                  spids: [3752 3753 3763 -1]
                )
                (case_arm pat_list:[{(2)}] spids:[376637673769-1])
                (case_arm
                  pat_list: [{(Lit_Other "*")}]
                  action: [
                    (C {(error)} {(DQ ("bug in the test script: not 1 or 2 parameters to test_seq"))})
                  ]
                  spids: [3772 3773 3781 -1]
                )
              ]
              spids: [3745 3749 3784]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:test_seq_counter__)
                  op: Equal
                  rhs: {($ VSub_Number "$1")}
                  spids: [3787]
                )
              ]
              spids: [3787]
            )
            (While
              cond: [
                (C {(test)} {(DQ ($ VSub_Name "$test_seq_counter__"))} {(-le)} {(DQ ($ VSub_Number "$2"))})
              ]
              body: 
                (DoGroup
                  children: [
                    (C {(echo)} {(DQ ($ VSub_Name "$test_seq_counter__"))})
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:test_seq_counter__)
                          op: Equal
                          rhs: 
                            {
                              (ArithSubPart
                                anode: 
                                  (ArithBinary
                                    op_id: Arith_Plus
                                    left: (ArithWord w:{($ VSub_Name "$test_seq_counter__")})
                                    right: (ArithWord w:{(Lit_Digits 1)})
                                  )
                                spids: [3817 3826]
                              )
                            }
                          spids: [3816]
                        )
                      ]
                      spids: [3816]
                    )
                  ]
                  spids: [3806 3829]
                )
            )
          ]
          spids: [3742]
        )
      spids: [3737 3741]
    )
    (FuncDef
      name: test_when_finished
      body: 
        (BraceGroup
          children: [
            (AndOr
              children: [
                (C {(test)} 
                  {
                    (DQ 
                      (BracedVarSub
                        token: <VSub_Name BASH_SUBSHELL>
                        suffix_op: (StringUnary op_id:VTest_Hyphen arg_word:{(0)})
                        spids: [3924 3928]
                      )
                    )
                  } {(Lit_Other "=")} {(0)}
                )
                (C {(error)} 
                  {(DQ ("bug in test script: test_when_finished does nothing in a subshell"))}
                )
              ]
              op_id: Op_DPipe
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:test_cleanup)
                  op: Equal
                  rhs: 
                    {
                      (DQ ("{ ") ($ VSub_Star "$*") ("\n") ("\t\t} && (exit ") 
                        (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) (eval_ret) 
                        (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) ("); eval_ret=") (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) ("?; ") 
                        ($ VSub_Name "$test_cleanup")
                      )
                    }
                  spids: [3945]
                )
              ]
              spids: [3945]
            )
          ]
          spids: [3906]
        )
      spids: [3901 3905]
    )
    (FuncDef
      name: test_create_repo
      body: 
        (BraceGroup
          children: [
            (AndOr
              children: [
                (C {(test)} {(DQ ($ VSub_Pound "$#"))} {(Lit_Other "=")} {(1)})
                (C {(error)} {(DQ ("bug in the test script: not 1 parameter to test-create-repo"))})
              ]
              op_id: Op_DPipe
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:repo)
                  op: Equal
                  rhs: {(DQ ($ VSub_Number "$1"))}
                  spids: [3998]
                )
              ]
              spids: [3998]
            )
            (C {(mkdir)} {(-p)} {(DQ ($ VSub_Name "$repo"))})
            (AndOr
              children: [
                (Subshell
                  child: 
                    (CommandList
                      children: [
                        (AndOr
                          children: [
                            (C {(cd)} {(DQ ($ VSub_Name "$repo"))})
                            (C {(error)} {(DQ ("Cannot setup test environment"))})
                          ]
                          op_id: Op_DPipe
                        )
                        (AndOr
                          children: [
                            (SimpleCommand
                              words: [
                                {(DQ ($ VSub_Name "$GIT_EXEC_PATH") (/git-init))}
                                {
                                  (DQ ("--template=") ($ VSub_Name "$GIT_BUILD_DIR") (/templates/blt/))
                                }
                              ]
                              redirects: [
                                (Redir
                                  op_id: Redir_GreatAnd
                                  fd: -1
                                  arg_word: {(3)}
                                  spids: [4042]
                                )
                                (Redir
                                  op_id: Redir_GreatAnd
                                  fd: 2
                                  arg_word: {(4)}
                                  spids: [4045]
                                )
                              ]
                            )
                            (C {(error)} {(DQ ("cannot run git init -- have you built things yet?"))})
                          ]
                          op_id: Op_DPipe
                        )
                        (C {(mv)} {(.git/hooks)} {(.git/hooks-disabled)})
                      ]
                    )
                  spids: [4013 4065]
                )
                (C {(exit)})
              ]
              op_id: Op_DPipe
            )
          ]
          spids: [3975]
        )
      spids: [3970 3974]
    )
    (FuncDef
      name: test_ln_s_add
      body: 
        (BraceGroup
          children: [
            (If
              arms: [
                (if_arm
                  cond: [(C {(test_have_prereq)} {(SYMLINKS)})]
                  action: [
                    (AndOr
                      children: [
                        (C {(ln)} {(-s)} {(DQ ($ VSub_Number "$1"))} {(DQ ($ VSub_Number "$2"))})
                        (C {(git)} {(update-index)} {(--add)} {(DQ ($ VSub_Number "$2"))})
                      ]
                      op_id: Op_DAmp
                    )
                  ]
                  spids: [-1 4102]
                )
              ]
              else_action: [
                (AndOr
                  children: [
                    (SimpleCommand
                      words: [{(printf)} {(SQ <"%s">)} {(DQ ($ VSub_Number "$1"))}]
                      redirects: [
                        (Redir
                          op_id: Redir_Great
                          fd: -1
                          arg_word: {(DQ ($ VSub_Number "$2"))}
                          spids: [4144]
                        )
                      ]
                    )
                    (AndOr
                      children: [
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:ln_s_obj)
                              op: Equal
                              rhs: 
                                {
                                  (CommandSubPart
                                    command_list: 
                                      (CommandList
                                        children: [
                                          (C {(git)} {(hash-object)} {(-w)} {(DQ ($ VSub_Number "$2"))})
                                        ]
                                      )
                                    left_token: <Left_CommandSub "$(">
                                    spids: [4153 4163]
                                  )
                                }
                              spids: [4152]
                            )
                          ]
                          spids: [4152]
                        )
                        (AndOr
                          children: [
                            (C {(git)} {(update-index)} {(--add)} {(--cacheinfo)} {(120000)} 
                              {($ VSub_Name "$ln_s_obj")} {(DQ ($ VSub_Number "$2"))}
                            )
                            (C {(git)} {(update-index)} {(DQ ($ VSub_Number "$2"))})
                          ]
                          op_id: Op_DAmp
                        )
                      ]
                      op_id: Op_DAmp
                    )
                  ]
                  op_id: Op_DAmp
                )
              ]
              spids: [4131 4200]
            )
          ]
          spids: [4092]
        )
      spids: [4087 4091]
    )
    (FuncDef
      name: test_write_lines
      body: 
        (BraceGroup
          children: [
            (C {(printf)} {(DQ ("%s") (EscapedLiteralPart token:<Lit_EscapedChar "\\n">))} 
              {(DQ ($ VSub_At "$@"))}
            )
          ]
          spids: [4213]
        )
      spids: [4208 4212]
    )
    (FuncDef
      name: perl
      body: 
        (BraceGroup
          children: [(C {(command)} {(DQ ($ VSub_Name "$PERL_PATH"))} {(DQ ($ VSub_At "$@"))})]
          spids: [4235]
        )
      spids: [4230 4234]
    )
    (FuncDef
      name: test_normalize_bool
      body: 
        (BraceGroup
          children: [
            (SimpleCommand
              words: [
                {(git)}
                {(-c)}
                {(magic.variable) (Lit_Other "=") (DQ ($ VSub_Number "$1"))}
                {(config)}
                {(--bool)}
                {(magic.variable)}
              ]
              redirects: [(Redir op_id:Redir_Great fd:2 arg_word:{(/dev/null)} spids:[4278])]
            )
          ]
          spids: [4259]
        )
      spids: [4254 4258]
    )
    (FuncDef
      name: test_tristate
      body: 
        (BraceGroup
          children: [
            (If
              arms: [
                (if_arm
                  cond: [
                    (C {(eval)} 
                      {
                        (DQ ("test x") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) 
                          (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) ("{") ($ VSub_Number "$1") ("+isset}") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) (" = xisset")
                        )
                      }
                    )
                  ]
                  action: [
                    (C {(eval)} 
                      {
                        (DQ ("\n") ("\t\t\tcase ") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) 
                          (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) ($ VSub_Number "$1") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) (" in\n") ("\t\t\t'')\t") 
                          ($ VSub_Number "$1") ("=false ;;\n") ("\t\t\tauto)\t;;\n") ("\t\t\t*)\t") ($ VSub_Number "$1") ("=") 
                          (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) ("(test_normalize_bool ") (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) ($ VSub_Number "$1") 
                          (" || echo true) ;;\n") ("\t\t\tesac\n") ("\t\t")
                        )
                      }
                    )
                  ]
                  spids: [-1 4354]
                )
              ]
              else_action: [(C {(eval)} {(DQ ($ VSub_Number "$1") ("=auto"))})]
              spids: [4388 4399]
            )
          ]
          spids: [4335]
        )
      spids: [4330 4334]
    )
    (FuncDef
      name: test_skip_or_die
      body: 
        (BraceGroup
          children: [
            (Case
              to_match: {(DQ ($ VSub_Number "$1"))}
              arms: [
                (case_arm
                  pat_list: [{(auto)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:skip_all)
                          op: Equal
                          rhs: {($ VSub_Number "$2")}
                          spids: [4446]
                        )
                      ]
                      spids: [4446]
                    )
                    (C {(test_done)})
                  ]
                  spids: [4442 4443 4453 -1]
                )
                (case_arm
                  pat_list: [{(true)}]
                  action: [(C {(error)} {(DQ ($ VSub_Number "$2"))})]
                  spids: [4456 4457 4467 -1]
                )
                (case_arm
                  pat_list: [{(Lit_Other "*")}]
                  action: [
                    (C {(error)} 
                      {
                        (DQ ("BUG: test tristate is '") ($ VSub_Number "$1") ("' (real error: ") 
                          ($ VSub_Number "$2") (")")
                        )
                      }
                    )
                  ]
                  spids: [4470 4471 -1 4485]
                )
              ]
              spids: [4433 4439 4485]
            )
          ]
          spids: [4430]
        )
      spids: [4425 4429]
    )
    (FuncDef
      name: mingw_test_cmp
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (LhsName name:test_cmp_a)
                  op: Equal
                  rhs: {(SQ )}
                  spids: [4521]
                )
                (assign_pair
                  lhs: (LhsName name:test_cmp_b)
                  op: Equal
                  rhs: {(SQ )}
                  spids: [4523]
                )
              ]
              spids: [4519]
            )
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (LhsName name:stdin_for_diff)
                  op: Equal
                  rhs: {(SQ )}
                  spids: [4537]
                )
              ]
              spids: [4535]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (AndOr
                      children: [
                        (C {(test)} {(-s)} {(DQ ($ VSub_Number "$1"))})
                        (C {(test)} {(-s)} {(DQ ($ VSub_Number "$2"))})
                      ]
                      op_id: Op_DAmp
                    )
                  ]
                  action: [
                    (SimpleCommand
                      words: [{(mingw_read_file_strip_cr_)} {(test_cmp_a)}]
                      redirects: [
                        (Redir
                          op_id: Redir_Less
                          fd: -1
                          arg_word: {(DQ ($ VSub_Number "$1"))}
                          spids: [4585]
                        )
                      ]
                    )
                    (SimpleCommand
                      words: [{(mingw_read_file_strip_cr_)} {(test_cmp_b)}]
                      redirects: [
                        (Redir
                          op_id: Redir_Less
                          fd: -1
                          arg_word: {(DQ ($ VSub_Number "$2"))}
                          spids: [4595]
                        )
                      ]
                    )
                  ]
                  spids: [-1 4574]
                )
                (if_arm
                  cond: [
                    (AndOr
                      children: [
                        (C {(test)} {(-s)} {(DQ ($ VSub_Number "$1"))})
                        (C {(test)} {(DQ ($ VSub_Number "$2"))} {(Lit_Other "=")} {(-)})
                      ]
                      op_id: Op_DAmp
                    )
                  ]
                  action: [
                    (SimpleCommand
                      words: [{(mingw_read_file_strip_cr_)} {(test_cmp_a)}]
                      redirects: [
                        (Redir
                          op_id: Redir_Less
                          fd: -1
                          arg_word: {(DQ ($ VSub_Number "$1"))}
                          spids: [4635]
                        )
                      ]
                    )
                    (C {(mingw_read_file_strip_cr_)} {(test_cmp_b)})
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:stdin_for_diff)
                          op: Equal
                          rhs: {(SQ <"<<<\"$test_cmp_b\"">)}
                          spids: [4646]
                        )
                      ]
                      spids: [4646]
                    )
                  ]
                  spids: [4601 4624]
                )
                (if_arm
                  cond: [
                    (AndOr
                      children: [
                        (C {(test)} {(DQ ($ VSub_Number "$1"))} {(Lit_Other "=")} {(-)})
                        (C {(test)} {(-s)} {(DQ ($ VSub_Number "$2"))})
                      ]
                      op_id: Op_DAmp
                    )
                  ]
                  action: [
                    (C {(mingw_read_file_strip_cr_)} {(test_cmp_a)})
                    (SimpleCommand
                      words: [{(mingw_read_file_strip_cr_)} {(test_cmp_b)}]
                      redirects: [
                        (Redir
                          op_id: Redir_Less
                          fd: -1
                          arg_word: {(DQ ($ VSub_Number "$2"))}
                          spids: [4691]
                        )
                      ]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:stdin_for_diff)
                          op: Equal
                          rhs: {(SQ <"<<<\"$test_cmp_a\"">)}
                          spids: [4697]
                        )
                      ]
                      spids: [4697]
                    )
                  ]
                  spids: [4652 4675]
                )
              ]
              spids: [-1 4703]
            )
            (AndOr
              children: [
                (C {(test)} {(-n)} {(DQ ($ VSub_Name "$test_cmp_a"))})
                (AndOr
                  children: [
                    (C {(test)} {(-n)} {(DQ ($ VSub_Name "$test_cmp_b"))})
                    (AndOr
                      children: [
                        (C {(test)} {(DQ ($ VSub_Name "$test_cmp_a"))} {(Lit_Other "=")} 
                          {(DQ ($ VSub_Name "$test_cmp_b"))}
                        )
                        (C {(eval)} 
                          {
                            (DQ ("diff -u ") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) 
                              (EscapedLiteralPart
                                token: <Lit_EscapedChar "\\$">
                              ) ("@") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) (" ") ($ VSub_Name "$stdin_for_diff")
                            )
                          }
                        )
                      ]
                      op_id: Op_DPipe
                    )
                  ]
                  op_id: Op_DAmp
                )
              ]
              op_id: Op_DAmp
            )
          ]
          spids: [4508]
        )
      spids: [4503 4507]
    )
    (FuncDef
      name: mingw_read_file_strip_cr_
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_Local
              pairs: [(assign_pair lhs:(LhsName name:line) op:Equal spids:[4779])]
              spids: [4777]
            )
            (While
              cond: [(C {(Lit_Other ":")})]
              body: 
                (DoGroup
                  children: [
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (SimpleCommand
                              words: [{(read)} {(-r)} {(-d)} {(SQ <Lit_EscapedChar "\\n">)} {(line)}]
                              more_env: [
                                (env_pair
                                  name: IFS
                                  val: {(SQ <Lit_EscapedChar "\\r">)}
                                  spids: [4792]
                                )
                              ]
                            )
                          ]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:line)
                                  op: Equal
                                  rhs: {($ VSub_Name "$line") (SQ <Lit_EscapedChar "\\n">)}
                                  spids: [4817]
                                )
                              ]
                              spids: [4817]
                            )
                          ]
                          spids: [-1 4810]
                        )
                      ]
                      else_action: [
                        (If
                          arms: [
                            (if_arm
                              cond: [(C {(test)} {(-z)} {(DQ ($ VSub_Name "$line"))})]
                              action: [(ControlFlow token:<ControlFlow_Break break>)]
                              spids: [-1 4850]
                            )
                          ]
                          spids: [-1 4860]
                        )
                      ]
                      spids: [4824 4863]
                    )
                    (C {(eval)} 
                      {
                        (DQ ($ VSub_Number "$1") ("=") 
                          (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) ($ VSub_Number "$1") (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) (line)
                        )
                      }
                    )
                  ]
                  spids: [4787 4878]
                )
            )
          ]
          spids: [4766]
        )
      spids: [4761 4765]
    )
    (FuncDef
      name: test_env
      body: 
        (BraceGroup
          children: [
            (Subshell
              child: 
                (While
                  cond: [(C {(test)} {($ VSub_Pound "$#")} {(-gt)} {(0)})]
                  body: 
                    (DoGroup
                      children: [
                        (Case
                          to_match: {(DQ ($ VSub_Number "$1"))}
                          arms: [
                            (case_arm
                              pat_list: [{(Lit_Other "*") (Lit_Other "=") (Lit_Other "*")}]
                              action: [
                                (C {(eval)} 
                                  {
                                    (DQ 
                                      (BracedVarSub
                                        token: <VSub_Number 1>
                                        suffix_op: (StringUnary op_id:VOp1_DPercent arg_word:{("=*")})
                                        spids: [4935 4939]
                                      ) ("=") (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) ("{1#*=}")
                                    )
                                  }
                                )
                                (C {(eval)} 
                                  {
                                    (DQ ("export ") 
                                      (BracedVarSub
                                        token: <VSub_Number 1>
                                        suffix_op: (StringUnary op_id:VOp1_DPercent arg_word:{("=*")})
                                        spids: [4950 4954]
                                      )
                                    )
                                  }
                                )
                                (C {(shift)})
                              ]
                              spids: [4926 4929 4961 -1]
                            )
                            (case_arm
                              pat_list: [{(Lit_Other "*")}]
                              action: [(C {(DQ ($ VSub_At "$@"))}) (C {(exit)})]
                              spids: [4964 4965 4976 -1]
                            )
                          ]
                          spids: [4917 4923 4979]
                        )
                      ]
                      spids: [4914 4982]
                    )
                )
              spids: [4900 4985]
            )
          ]
          spids: [4897]
        )
      spids: [4892 4896]
    )
    (FuncDef
      name: test_match_signal
      body: 
        (BraceGroup
          children: [
            (If
              arms: [
                (if_arm
                  cond: [
                    (C {(test)} {(DQ ($ VSub_Number "$2"))} {(Lit_Other "=")} 
                      {
                        (DQ 
                          (ArithSubPart
                            anode: 
                              (ArithBinary
                                op_id: Arith_Plus
                                left: (ArithWord w:{(Lit_Digits 128)})
                                right: (ArithWord w:{($ VSub_Number "$1")})
                              )
                            spids: [5015 5022]
                          )
                        )
                      }
                    )
                  ]
                  action: [(ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})]
                  spids: [-1 5026]
                )
                (if_arm
                  cond: [
                    (C {(test)} {(DQ ($ VSub_Number "$2"))} {(Lit_Other "=")} 
                      {
                        (DQ 
                          (ArithSubPart
                            anode: 
                              (ArithBinary
                                op_id: Arith_Plus
                                left: (ArithWord w:{(Lit_Digits 256)})
                                right: (ArithWord w:{($ VSub_Number "$1")})
                              )
                            spids: [5049 5056]
                          )
                        )
                      }
                    )
                  ]
                  action: [(ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})]
                  spids: [5038 5060]
                )
              ]
              spids: [-1 5072]
            )
            (ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})
          ]
          spids: [5001]
        )
      spids: [4996 5000]
    )
    (FuncDef
      name: test_copy_bytes
      body: 
        (BraceGroup
          children: [
            (C {(perl)} {(-e)} 
              {
                (SQ <"\n"> <"\t\tmy $len = $ARGV[1];\n"> <"\t\twhile ($len > 0) {\n"> <"\t\t\tmy $s;\n"> 
                  <"\t\t\tmy $nread = sysread(STDIN, $s, $len);\n"> <"\t\t\tdie \"cannot read: $!\" unless defined($nread);\n"> <"\t\t\tprint $s;\n"> 
                  <"\t\t\t$len -= $nread;\n"> <"\t\t}\n"> <"\t">
                )
              } {(-)} {(DQ ($ VSub_Number "$1"))}
            )
          ]
          spids: [5090]
        )
      spids: [5085 5089]
    )
  ]
)