(command.CommandList
  children: [
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:test_description spids:[12])
          op: Equal
          rhs: {(SQ <'Test git check-ref-format'>)}
          spids: [12]
        )
      ]
      spids: [12]
    )
    (C {(.)} {(./test-lib.sh)})
    (command.FuncDef
      name: valid_ref
      body: 
        (command.BraceGroup
          children: [
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:prereq spids:[30])
                  op: Equal
                  rhs: (word.EmptyWord)
                  spids: [30]
                )
              ]
              spids: [30]
            )
            (command.Case
              to_match: {($ VSub_Number '$1')}
              arms: [
                (case_arm
                  pat_list: [{(Lit_Other '[') (A-Z) (KW_Bang '!') (Lit_Other ']') (Lit_Other '*')}]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:prereq spids:[48])
                          op: Equal
                          rhs: {($ VSub_Number '$1')}
                          spids: [48]
                        )
                      ]
                      spids: [48]
                    )
                    (C {(shift)})
                  ]
                  spids: [40 45 16777215 55]
                )
              ]
              spids: [33 37 55]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:desc spids:[58])
                  op: Equal
                  rhs: 
                    {
                      (DQ ("ref name '") ($ VSub_Number '$1') ("' is valid") 
                        (word_part.BracedVarSub
                          token: <VSub_Number 2>
                          suffix_op: 
                            (suffix_op.StringUnary
                              op_id: VTest_ColonPlus
                              arg_word: {(' with options ') ($ VSub_Number '$2')}
                            )
                          spids: [63 68]
                        )
                      )
                    }
                  spids: [58]
                )
              ]
              spids: [58]
            )
            (C {(test_expect_success)} {($ VSub_Name '$prereq')} {(DQ ($ VSub_Name '$desc'))} 
              {
                (DQ ('\n') ('\t\tgit check-ref-format ') ($ VSub_Number '$2') (" '") ($ VSub_Number '$1') 
                  ("'\n") ('\t')
                )
              }
            )
          ]
          spids: [27]
        )
      spids: [23 26]
    )
    (command.FuncDef
      name: invalid_ref
      body: 
        (command.BraceGroup
          children: [
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:prereq spids:[99])
                  op: Equal
                  rhs: (word.EmptyWord)
                  spids: [99]
                )
              ]
              spids: [99]
            )
            (command.Case
              to_match: {($ VSub_Number '$1')}
              arms: [
                (case_arm
                  pat_list: [{(Lit_Other '[') (A-Z) (KW_Bang '!') (Lit_Other ']') (Lit_Other '*')}]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:prereq spids:[117])
                          op: Equal
                          rhs: {($ VSub_Number '$1')}
                          spids: [117]
                        )
                      ]
                      spids: [117]
                    )
                    (C {(shift)})
                  ]
                  spids: [109 114 16777215 124]
                )
              ]
              spids: [102 106 124]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:desc spids:[127])
                  op: Equal
                  rhs: 
                    {
                      (DQ ("ref name '") ($ VSub_Number '$1') ("' is invalid") 
                        (word_part.BracedVarSub
                          token: <VSub_Number 2>
                          suffix_op: 
                            (suffix_op.StringUnary
                              op_id: VTest_ColonPlus
                              arg_word: {(' with options ') ($ VSub_Number '$2')}
                            )
                          spids: [132 137]
                        )
                      )
                    }
                  spids: [127]
                )
              ]
              spids: [127]
            )
            (C {(test_expect_success)} {($ VSub_Name '$prereq')} {(DQ ($ VSub_Name '$desc'))} 
              {
                (DQ ('\n') ('\t\ttest_must_fail git check-ref-format ') ($ VSub_Number '$2') (" '") 
                  ($ VSub_Number '$1') ("'\n") ('\t')
                )
              }
            )
          ]
          spids: [96]
        )
      spids: [92 95]
    )
    (C {(invalid_ref)} {(SQ )})
    (C {(invalid_ref)} {(KW_Bang '!') (MINGW)} {(SQ </>)})
    (C {(invalid_ref)} {(KW_Bang '!') (MINGW)} {(SQ </>)} {(--allow-onelevel)})
    (C {(invalid_ref)} {(KW_Bang '!') (MINGW)} {(SQ </>)} {(--normalize)})
    (C {(invalid_ref)} {(KW_Bang '!') (MINGW)} {(SQ </>)} {(SQ <'--allow-onelevel --normalize'>)})
    (C {(valid_ref)} {(SQ <foo/bar/baz>)})
    (C {(valid_ref)} {(SQ <foo/bar/baz>)} {(--normalize)})
    (C {(invalid_ref)} {(SQ <refs///heads/foo>)})
    (C {(valid_ref)} {(SQ <refs///heads/foo>)} {(--normalize)})
    (C {(invalid_ref)} {(SQ <heads/foo/>)})
    (C {(invalid_ref)} {(KW_Bang '!') (MINGW)} {(SQ </heads/foo>)})
    (C {(valid_ref)} {(KW_Bang '!') (MINGW)} {(SQ </heads/foo>)} {(--normalize)})
    (C {(invalid_ref)} {(SQ <///heads/foo>)})
    (C {(valid_ref)} {(SQ <///heads/foo>)} {(--normalize)})
    (C {(invalid_ref)} {(SQ <./foo>)})
    (C {(invalid_ref)} {(SQ <./foo/bar>)})
    (C {(invalid_ref)} {(SQ <foo/./bar>)})
    (C {(invalid_ref)} {(SQ <foo/bar/.>)})
    (C {(invalid_ref)} {(SQ <.refs/foo>)})
    (C {(invalid_ref)} {(SQ <refs/heads/foo.>)})
    (C {(invalid_ref)} {(SQ <heads/foo..bar>)})
    (C {(invalid_ref)} {(SQ <'heads/foo?bar'>)})
    (C {(valid_ref)} {(SQ <foo./bar>)})
    (C {(invalid_ref)} {(SQ <heads/foo.lock>)})
    (C {(invalid_ref)} {(SQ <heads///foo.lock>)})
    (C {(invalid_ref)} {(SQ <foo.lock/bar>)})
    (C {(invalid_ref)} {(SQ <foo.lock///bar>)})
    (C {(valid_ref)} {(SQ <'heads/foo@bar'>)})
    (C {(invalid_ref)} {(SQ <'heads/v@{ation'>)})
    (C {(invalid_ref)} {(SQ <'heads/foo\\bar'>)})
    (C {(invalid_ref)} 
      {
        (DQ 
          (word_part.CommandSubPart
            command_list: (command.CommandList children:[(C {(printf)} {(SQ <'heads/foo\\t'>)})])
            left_token: <Left_CommandSub '$('>
            spids: [378 384]
          )
        )
      }
    )
    (C {(invalid_ref)} 
      {
        (DQ 
          (word_part.CommandSubPart
            command_list: (command.CommandList children:[(C {(printf)} {(SQ <'heads/foo\\177'>)})])
            left_token: <Left_CommandSub '$('>
            spids: [390 396]
          )
        )
      }
    )
    (C {(valid_ref)} 
      {
        (DQ 
          (word_part.CommandSubPart
            command_list: 
              (command.CommandList
                children: [(C {(printf)} {(SQ <'heads/fu\\303\\237'>)})]
              )
            left_token: <Left_CommandSub '$('>
            spids: [402 408]
          )
        )
      }
    )
    (C {(valid_ref)} {(SQ <'heads/*foo/bar'>)} {(--refspec-pattern)})
    (C {(valid_ref)} {(SQ <'heads/foo*/bar'>)} {(--refspec-pattern)})
    (C {(valid_ref)} {(SQ <'heads/f*o/bar'>)} {(--refspec-pattern)})
    (C {(invalid_ref)} {(SQ <'heads/f*o*/bar'>)} {(--refspec-pattern)})
    (C {(invalid_ref)} {(SQ <'heads/foo*/bar*'>)} {(--refspec-pattern)})
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:ref spids:[452])
          op: Equal
          rhs: {(SQ <foo>)}
          spids: [452]
        )
      ]
      spids: [452]
    )
    (C {(invalid_ref)} {(DQ ($ VSub_Name '$ref'))})
    (C {(valid_ref)} {(DQ ($ VSub_Name '$ref'))} {(--allow-onelevel)})
    (C {(invalid_ref)} {(DQ ($ VSub_Name '$ref'))} {(--refspec-pattern)})
    (C {(valid_ref)} {(DQ ($ VSub_Name '$ref'))} {(SQ <'--refspec-pattern --allow-onelevel'>)})
    (C {(invalid_ref)} {(DQ ($ VSub_Name '$ref'))} {(--normalize)})
    (C {(valid_ref)} {(DQ ($ VSub_Name '$ref'))} {(SQ <'--allow-onelevel --normalize'>)})
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:ref spids:[508])
          op: Equal
          rhs: {(SQ <foo/bar>)}
          spids: [508]
        )
      ]
      spids: [508]
    )
    (C {(valid_ref)} {(DQ ($ VSub_Name '$ref'))})
    (C {(valid_ref)} {(DQ ($ VSub_Name '$ref'))} {(--allow-onelevel)})
    (C {(valid_ref)} {(DQ ($ VSub_Name '$ref'))} {(--refspec-pattern)})
    (C {(valid_ref)} {(DQ ($ VSub_Name '$ref'))} {(SQ <'--refspec-pattern --allow-onelevel'>)})
    (C {(valid_ref)} {(DQ ($ VSub_Name '$ref'))} {(--normalize)})
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:ref spids:[554])
          op: Equal
          rhs: {(SQ <'foo/*'>)}
          spids: [554]
        )
      ]
      spids: [554]
    )
    (C {(invalid_ref)} {(DQ ($ VSub_Name '$ref'))})
    (C {(invalid_ref)} {(DQ ($ VSub_Name '$ref'))} {(--allow-onelevel)})
    (C {(valid_ref)} {(DQ ($ VSub_Name '$ref'))} {(--refspec-pattern)})
    (C {(valid_ref)} {(DQ ($ VSub_Name '$ref'))} {(SQ <'--refspec-pattern --allow-onelevel'>)})
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:ref spids:[592])
          op: Equal
          rhs: {(SQ <'*/foo'>)}
          spids: [592]
        )
      ]
      spids: [592]
    )
    (C {(invalid_ref)} {(DQ ($ VSub_Name '$ref'))})
    (C {(invalid_ref)} {(DQ ($ VSub_Name '$ref'))} {(--allow-onelevel)})
    (C {(valid_ref)} {(DQ ($ VSub_Name '$ref'))} {(--refspec-pattern)})
    (C {(valid_ref)} {(DQ ($ VSub_Name '$ref'))} {(SQ <'--refspec-pattern --allow-onelevel'>)})
    (C {(invalid_ref)} {(DQ ($ VSub_Name '$ref'))} {(--normalize)})
    (C {(valid_ref)} {(DQ ($ VSub_Name '$ref'))} {(SQ <'--refspec-pattern --normalize'>)})
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:ref spids:[648])
          op: Equal
          rhs: {(SQ <'foo/*/bar'>)}
          spids: [648]
        )
      ]
      spids: [648]
    )
    (C {(invalid_ref)} {(DQ ($ VSub_Name '$ref'))})
    (C {(invalid_ref)} {(DQ ($ VSub_Name '$ref'))} {(--allow-onelevel)})
    (C {(valid_ref)} {(DQ ($ VSub_Name '$ref'))} {(--refspec-pattern)})
    (C {(valid_ref)} {(DQ ($ VSub_Name '$ref'))} {(SQ <'--refspec-pattern --allow-onelevel'>)})
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:ref spids:[686])
          op: Equal
          rhs: {(SQ <'*'>)}
          spids: [686]
        )
      ]
      spids: [686]
    )
    (C {(invalid_ref)} {(DQ ($ VSub_Name '$ref'))})
    (C {(invalid_ref)} {(DQ ($ VSub_Name '$ref'))} {(--allow-onelevel)})
    (C {(invalid_ref)} {(DQ ($ VSub_Name '$ref'))} {(--refspec-pattern)})
    (C {(valid_ref)} {(DQ ($ VSub_Name '$ref'))} {(SQ <'--refspec-pattern --allow-onelevel'>)})
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:ref spids:[724])
          op: Equal
          rhs: {(SQ <'foo/*/*'>)}
          spids: [724]
        )
      ]
      spids: [724]
    )
    (C {(invalid_ref)} {(DQ ($ VSub_Name '$ref'))} {(--refspec-pattern)})
    (C {(invalid_ref)} {(DQ ($ VSub_Name '$ref'))} {(SQ <'--refspec-pattern --allow-onelevel'>)})
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:ref spids:[748])
          op: Equal
          rhs: {(SQ <'*/foo/*'>)}
          spids: [748]
        )
      ]
      spids: [748]
    )
    (C {(invalid_ref)} {(DQ ($ VSub_Name '$ref'))} {(--refspec-pattern)})
    (C {(invalid_ref)} {(DQ ($ VSub_Name '$ref'))} {(SQ <'--refspec-pattern --allow-onelevel'>)})
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:ref spids:[772])
          op: Equal
          rhs: {(SQ <'*/*/foo'>)}
          spids: [772]
        )
      ]
      spids: [772]
    )
    (C {(invalid_ref)} {(DQ ($ VSub_Name '$ref'))} {(--refspec-pattern)})
    (C {(invalid_ref)} {(DQ ($ VSub_Name '$ref'))} {(SQ <'--refspec-pattern --allow-onelevel'>)})
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:ref spids:[796])
          op: Equal
          rhs: {(SQ </foo>)}
          spids: [796]
        )
      ]
      spids: [796]
    )
    (C {(invalid_ref)} {(KW_Bang '!') (MINGW)} {(DQ ($ VSub_Name '$ref'))})
    (C {(invalid_ref)} {(KW_Bang '!') (MINGW)} {(DQ ($ VSub_Name '$ref'))} {(--allow-onelevel)})
    (C {(invalid_ref)} {(KW_Bang '!') (MINGW)} {(DQ ($ VSub_Name '$ref'))} {(--refspec-pattern)})
    (C {(invalid_ref)} {(KW_Bang '!') (MINGW)} {(DQ ($ VSub_Name '$ref'))} 
      {(SQ <'--refspec-pattern --allow-onelevel'>)}
    )
    (C {(invalid_ref)} {(KW_Bang '!') (MINGW)} {(DQ ($ VSub_Name '$ref'))} {(--normalize)})
    (C {(valid_ref)} {(KW_Bang '!') (MINGW)} {(DQ ($ VSub_Name '$ref'))} 
      {(SQ <'--allow-onelevel --normalize'>)}
    )
    (C {(invalid_ref)} {(KW_Bang '!') (MINGW)} {(DQ ($ VSub_Name '$ref'))} 
      {(SQ <'--refspec-pattern --normalize'>)}
    )
    (C {(valid_ref)} {(KW_Bang '!') (MINGW)} {(DQ ($ VSub_Name '$ref'))} 
      {(SQ <'--refspec-pattern --allow-onelevel --normalize'>)}
    )
    (C {(test_expect_success)} {(DQ ('check-ref-format --branch @{-1}'))} 
      {
        (SQ <'\n'> <'\tT=$(git write-tree) &&\n'> <'\tsha1=$(echo A | git commit-tree $T) &&\n'> 
          <'\tgit update-ref refs/heads/master $sha1 &&\n'> <'\tgit update-ref refs/remotes/origin/master $sha1 &&\n'> <'\tgit checkout master &&\n'> 
          <'\tgit checkout origin/master &&\n'> <'\tgit checkout master &&\n'> <'\trefname=$(git check-ref-format --branch @{-1}) &&\n'> 
          <'\ttest "$refname" = "$sha1" &&\n'> <'\trefname2=$(git check-ref-format --branch @{-2}) &&\n'> <'\ttest "$refname2" = master'>
        )
      }
    )
    (C {(test_expect_success)} {(SQ <'check-ref-format --branch from subdir'>)} 
      {
        (SQ <'\n'> <'\tmkdir subdir &&\n'> <'\n'> <'\tT=$(git write-tree) &&\n'> 
          <'\tsha1=$(echo A | git commit-tree $T) &&\n'> <'\tgit update-ref refs/heads/master $sha1 &&\n'> 
          <'\tgit update-ref refs/remotes/origin/master $sha1 &&\n'> <'\tgit checkout master &&\n'> <'\tgit checkout origin/master &&\n'> <'\tgit checkout master &&\n'> 
          <'\trefname=$(\n'> <'\t\tcd subdir &&\n'> <'\t\tgit check-ref-format --branch @{-1}\n'> <'\t) &&\n'> 
          <'\ttest "$refname" = "$sha1"\n'>
        )
      }
    )
    (command.FuncDef
      name: valid_ref_normalized
      body: 
        (command.BraceGroup
          children: [
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:prereq spids:[950])
                  op: Equal
                  rhs: (word.EmptyWord)
                  spids: [950]
                )
              ]
              spids: [950]
            )
            (command.Case
              to_match: {($ VSub_Number '$1')}
              arms: [
                (case_arm
                  pat_list: [{(Lit_Other '[') (A-Z) (KW_Bang '!') (Lit_Other ']') (Lit_Other '*')}]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:prereq spids:[968])
                          op: Equal
                          rhs: {($ VSub_Number '$1')}
                          spids: [968]
                        )
                      ]
                      spids: [968]
                    )
                    (C {(shift)})
                  ]
                  spids: [960 965 16777215 975]
                )
              ]
              spids: [953 957 975]
            )
            (C {(test_expect_success)} {($ VSub_Name '$prereq')} 
              {
                (DQ ("ref name '") ($ VSub_Number '$1') ("' simplifies to '") ($ VSub_Number '$2') ("'"))
              } 
              {
                (DQ ('\n') ('\t\trefname=') (word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\$'>) 
                  ("(git check-ref-format --normalize '") ($ VSub_Number '$1') ("') &&\n") ('\t\ttest ') 
                  (word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\"'>) (word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\$'>) (refname) 
                  (word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\"'>) (" = '") ($ VSub_Number '$2') ("'\n") ('\t')
                )
              }
            )
          ]
          spids: [947]
        )
      spids: [943 946]
    )
    (command.FuncDef
      name: invalid_ref_normalized
      body: 
        (command.BraceGroup
          children: [
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:prereq spids:[1017])
                  op: Equal
                  rhs: (word.EmptyWord)
                  spids: [1017]
                )
              ]
              spids: [1017]
            )
            (command.Case
              to_match: {($ VSub_Number '$1')}
              arms: [
                (case_arm
                  pat_list: [{(Lit_Other '[') (A-Z) (KW_Bang '!') (Lit_Other ']') (Lit_Other '*')}]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:prereq spids:[1035])
                          op: Equal
                          rhs: {($ VSub_Number '$1')}
                          spids: [1035]
                        )
                      ]
                      spids: [1035]
                    )
                    (C {(shift)})
                  ]
                  spids: [1027 1032 16777215 1042]
                )
              ]
              spids: [1020 1024 1042]
            )
            (C {(test_expect_success)} {($ VSub_Name '$prereq')} 
              {(DQ ("check-ref-format --normalize rejects '") ($ VSub_Number '$1') ("'"))} 
              {
                (DQ ('\n') ("\t\ttest_must_fail git check-ref-format --normalize '") 
                  ($ VSub_Number '$1') ("'\n") ('\t')
                )
              }
            )
          ]
          spids: [1014]
        )
      spids: [1010 1013]
    )
    (C {(valid_ref_normalized)} {(SQ <heads/foo>)} {(SQ <heads/foo>)})
    (C {(valid_ref_normalized)} {(SQ <refs///heads/foo>)} {(SQ <refs/heads/foo>)})
    (C {(valid_ref_normalized)} {(KW_Bang '!') (MINGW)} {(SQ </heads/foo>)} {(SQ <heads/foo>)})
    (C {(valid_ref_normalized)} {(SQ <///heads/foo>)} {(SQ <heads/foo>)})
    (C {(invalid_ref_normalized)} {(SQ <foo>)})
    (C {(invalid_ref_normalized)} {(KW_Bang '!') (MINGW)} {(SQ </foo>)})
    (C {(invalid_ref_normalized)} {(SQ <heads/foo/../bar>)})
    (C {(invalid_ref_normalized)} {(SQ <heads/./foo>)})
    (C {(invalid_ref_normalized)} {(SQ <'heads\\foo'>)})
    (C {(invalid_ref_normalized)} {(SQ <heads/foo.lock>)})
    (C {(invalid_ref_normalized)} {(SQ <heads///foo.lock>)})
    (C {(invalid_ref_normalized)} {(SQ <foo.lock/bar>)})
    (C {(invalid_ref_normalized)} {(SQ <foo.lock///bar>)})
    (C {(test_done)})
  ]
)