(command.CommandList
  children: [
    (command.ShAssignment
      left: <Id.Lit_VarLike 'test_description='>
      pairs: [
        (AssignPair
          left: <Id.Lit_VarLike 'test_description='>
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'test_description='> name:test_description)
          op: assign_op.Equal
          rhs: 
            {
              (SQ <'Test updating submodules\n'> <'\n'> 
                <'This test verifies that "git submodule update" detaches the HEAD of the\n'> <'submodule and "git submodule update --rebase/--merge" does not detach the HEAD.\n'>
              )
            }
        )
      ]
      redirects: []
    )
    (command.Simple
      blame_tok: <.>
      more_env: []
      words: [{<.>} {<'./test-lib.sh'>}]
      redirects: []
      do_fork: T
    )
    (command.ShFunction
      name_tok: <compare_head>
      name: compare_head
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.ShAssignment
              left: <Id.Lit_VarLike 'sha_master='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'sha_master='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'sha_master='> name:sha_master)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (CommandSub
                        left_token: <Id.Left_DollarParen '$('>
                        child: 
                          (command.Simple
                            blame_tok: <git>
                            more_env: []
                            words: [
                              {<git>}
                              {<rev-list>}
                              {<--max-count> <Id.Lit_Equals '='> <1>}
                              {<master>}
                            ]
                            redirects: []
                            do_fork: T
                          )
                        right: <Id.Eof_RParen _>
                      )
                    }
                )
              ]
              redirects: []
            )
            (command.ShAssignment
              left: <Id.Lit_VarLike 'sha_head='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'sha_head='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'sha_head='> name:sha_head)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (CommandSub
                        left_token: <Id.Left_DollarParen '$('>
                        child: 
                          (command.Simple
                            blame_tok: <git>
                            more_env: []
                            words: [{<git>} {<rev-list>} {<--max-count> <Id.Lit_Equals '='> <1>} {<HEAD>}]
                            redirects: []
                            do_fork: T
                          )
                        right: <Id.Eof_RParen _>
                      )
                    }
                )
              ]
              redirects: []
            )
            (command.Simple
              blame_tok: <test>
              more_env: []
              words: [
                {<test>}
                {(DQ ($ Id.VSub_DollarName sha_master))}
                {<Id.Lit_Equals '='>}
                {(DQ ($ Id.VSub_DollarName sha_head))}
              ]
              redirects: []
              do_fork: T
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'setup a submodule tree'>)}
        {
          (SQ <'\n'> <'\techo file > file &&\n'> <'\tgit add file &&\n'> <'\ttest_tick &&\n'> 
            <'\tgit commit -m upstream &&\n'> <'\tgit clone . super &&\n'> <'\tgit clone super submodule &&\n'> <'\tgit clone super rebasing &&\n'> 
            <'\tgit clone super merging &&\n'> <'\tgit clone super none &&\n'> <'\t(cd super &&\n'> 
            <'\t git submodule add ../submodule submodule &&\n'> <'\t test_tick &&\n'> <'\t git commit -m "submodule" &&\n'> <'\t git submodule init submodule\n'> 
            <'\t) &&\n'> <'\t(cd submodule &&\n'> <'\techo "line2" > file &&\n'> <'\tgit add file &&\n'> 
            <'\tgit commit -m "Commit 2"\n'> <'\t) &&\n'> <'\t(cd super &&\n'> <'\t (cd submodule &&\n'> <'\t  git pull --rebase origin\n'> 
            <'\t ) &&\n'> <'\t git add submodule &&\n'> <'\t git commit -m "submodule update"\n'> <'\t) &&\n'> 
            <'\t(cd super &&\n'> <'\t git submodule add ../rebasing rebasing &&\n'> <'\t test_tick &&\n'> 
            <'\t git commit -m "rebasing"\n'> <'\t) &&\n'> <'\t(cd super &&\n'> <'\t git submodule add ../merging merging &&\n'> <'\t test_tick &&\n'> 
            <'\t git commit -m "rebasing"\n'> <'\t) &&\n'> <'\t(cd super &&\n'> <'\t git submodule add ../none none &&\n'> <'\t test_tick &&\n'> 
            <'\t git commit -m "none"\n'> <'\t) &&\n'> <'\tgit clone . recursivesuper &&\n'> <'\t( cd recursivesuper\n'> 
            <'\t git submodule add ../super super\n'> <'\t)\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'submodule update detaching the HEAD '>)}
        {
          (SQ <'\n'> <'\t(cd super/submodule &&\n'> <'\t git reset --hard HEAD~1\n'> <'\t) &&\n'> 
            <'\t(cd super &&\n'> <'\t (cd submodule &&\n'> <'\t  compare_head\n'> <'\t ) &&\n'> 
            <'\t git submodule update submodule &&\n'> <'\t cd submodule &&\n'> <'\t ! compare_head\n'> <'\t)\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'submodule update from subdirectory'>)}
        {
          (SQ <'\n'> <'\t(cd super/submodule &&\n'> <'\t git reset --hard HEAD~1\n'> <'\t) &&\n'> 
            <'\tmkdir super/sub &&\n'> <'\t(cd super/sub &&\n'> <'\t (cd ../submodule &&\n'> <'\t  compare_head\n'> <'\t ) &&\n'> 
            <'\t git submodule update ../submodule &&\n'> <'\t cd ../submodule &&\n'> <'\t ! compare_head\n'> <'\t)\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.ShAssignment
      left: <Id.Lit_VarLike 'supersha1='>
      pairs: [
        (AssignPair
          left: <Id.Lit_VarLike 'supersha1='>
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'supersha1='> name:supersha1)
          op: assign_op.Equal
          rhs: 
            {
              (CommandSub
                left_token: <Id.Left_DollarParen '$('>
                child: 
                  (command.Simple
                    blame_tok: <git>
                    more_env: []
                    words: [{<git>} {<-C>} {<super>} {<rev-parse>} {<HEAD>}]
                    redirects: []
                    do_fork: T
                  )
                right: <Id.Eof_RParen _>
              )
            }
        )
      ]
      redirects: []
    )
    (command.ShAssignment
      left: <Id.Lit_VarLike 'mergingsha1='>
      pairs: [
        (AssignPair
          left: <Id.Lit_VarLike 'mergingsha1='>
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'mergingsha1='> name:mergingsha1)
          op: assign_op.Equal
          rhs: 
            {
              (CommandSub
                left_token: <Id.Left_DollarParen '$('>
                child: 
                  (command.Simple
                    blame_tok: <git>
                    more_env: []
                    words: [{<git>} {<-C>} {<'super/merging'>} {<rev-parse>} {<HEAD>}]
                    redirects: []
                    do_fork: T
                  )
                right: <Id.Eof_RParen _>
              )
            }
        )
      ]
      redirects: []
    )
    (command.ShAssignment
      left: <Id.Lit_VarLike 'nonesha1='>
      pairs: [
        (AssignPair
          left: <Id.Lit_VarLike 'nonesha1='>
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'nonesha1='> name:nonesha1)
          op: assign_op.Equal
          rhs: 
            {
              (CommandSub
                left_token: <Id.Left_DollarParen '$('>
                child: 
                  (command.Simple
                    blame_tok: <git>
                    more_env: []
                    words: [{<git>} {<-C>} {<'super/none'>} {<rev-parse>} {<HEAD>}]
                    redirects: []
                    do_fork: T
                  )
                right: <Id.Eof_RParen _>
              )
            }
        )
      ]
      redirects: []
    )
    (command.ShAssignment
      left: <Id.Lit_VarLike 'rebasingsha1='>
      pairs: [
        (AssignPair
          left: <Id.Lit_VarLike 'rebasingsha1='>
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'rebasingsha1='> name:rebasingsha1)
          op: assign_op.Equal
          rhs: 
            {
              (CommandSub
                left_token: <Id.Left_DollarParen '$('>
                child: 
                  (command.Simple
                    blame_tok: <git>
                    more_env: []
                    words: [{<git>} {<-C>} {<'super/rebasing'>} {<rev-parse>} {<HEAD>}]
                    redirects: []
                    do_fork: T
                  )
                right: <Id.Eof_RParen _>
              )
            }
        )
      ]
      redirects: []
    )
    (command.ShAssignment
      left: <Id.Lit_VarLike 'submodulesha1='>
      pairs: [
        (AssignPair
          left: <Id.Lit_VarLike 'submodulesha1='>
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'submodulesha1='> name:submodulesha1)
          op: assign_op.Equal
          rhs: 
            {
              (CommandSub
                left_token: <Id.Left_DollarParen '$('>
                child: 
                  (command.Simple
                    blame_tok: <git>
                    more_env: []
                    words: [{<git>} {<-C>} {<'super/submodule'>} {<rev-parse>} {<HEAD>}]
                    redirects: []
                    do_fork: T
                  )
                right: <Id.Eof_RParen _>
              )
            }
        )
      ]
      redirects: []
    )
    (command.ShAssignment
      left: <Id.Lit_VarLike 'pwd='>
      pairs: [
        (AssignPair
          left: <Id.Lit_VarLike 'pwd='>
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'pwd='> name:pwd)
          op: assign_op.Equal
          rhs: 
            {
              (CommandSub
                left_token: <Id.Left_DollarParen '$('>
                child: 
                  (command.Simple
                    blame_tok: <pwd>
                    more_env: []
                    words: [{<pwd>}]
                    redirects: []
                    do_fork: T
                  )
                right: <Id.Eof_RParen _>
              )
            }
        )
      ]
      redirects: []
    )
    (command.Simple
      blame_tok: <cat>
      more_env: []
      words: [{<cat>}]
      redirects: [
        (Redir
          op: <Id.Redir_DLess '<<'>
          loc: (redir_loc.Fd fd:0)
          arg: 
            (redir_param.HereDoc
              here_begin: {<EOF>}
              here_end_tok: <Id.Undefined_Tok ''>
              stdin_parts: [
                <'Submodule path \'../super\': checked out \''>
                ($ Id.VSub_DollarName supersha1)
                <'\'\n'>
                <'Submodule path \'../super/merging\': checked out \''>
                ($ Id.VSub_DollarName mergingsha1)
                <'\'\n'>
                <'Submodule path \'../super/none\': checked out \''>
                ($ Id.VSub_DollarName nonesha1)
                <'\'\n'>
                <'Submodule path \'../super/rebasing\': checked out \''>
                ($ Id.VSub_DollarName rebasingsha1)
                <'\'\n'>
                <'Submodule path \'../super/submodule\': checked out \''>
                ($ Id.VSub_DollarName submodulesha1)
                <'\'\n'>
              ]
            )
        )
        (Redir op:<Id.Redir_Great '>'> loc:(redir_loc.Fd fd:1) arg:{<expect>})
      ]
      do_fork: T
    )
    (command.Simple
      blame_tok: <cat>
      more_env: []
      words: [{<cat>}]
      redirects: [
        (Redir
          op: <Id.Redir_DLess '<<'>
          loc: (redir_loc.Fd fd:0)
          arg: 
            (redir_param.HereDoc
              here_begin: {<EOF>}
              here_end_tok: <Id.Undefined_Tok ''>
              stdin_parts: [
                <'Submodule \'merging\' ('>
                ($ Id.VSub_DollarName pwd)
                <'/merging) registered for path \'../super/merging\'\n'>
                <'Submodule \'none\' ('>
                ($ Id.VSub_DollarName pwd)
                <'/none) registered for path \'../super/none\'\n'>
                <'Submodule \'rebasing\' ('>
                ($ Id.VSub_DollarName pwd)
                <'/rebasing) registered for path \'../super/rebasing\'\n'>
                <'Submodule \'submodule\' ('>
                ($ Id.VSub_DollarName pwd)
                <'/submodule) registered for path \'../super/submodule\'\n'>
                <'Cloning into \''>
                ($ Id.VSub_DollarName pwd)
                <'/recursivesuper/super/merging\'...\n'>
                <'done.\n'>
                <'Cloning into \''>
                ($ Id.VSub_DollarName pwd)
                <'/recursivesuper/super/none\'...\n'>
                <'done.\n'>
                <'Cloning into \''>
                ($ Id.VSub_DollarName pwd)
                <'/recursivesuper/super/rebasing\'...\n'>
                <'done.\n'>
                <'Cloning into \''>
                ($ Id.VSub_DollarName pwd)
                <'/recursivesuper/super/submodule\'...\n'>
                <'done.\n'>
              ]
            )
        )
        (Redir op:<Id.Redir_Great '>'> loc:(redir_loc.Fd fd:1) arg:{<expect2>})
      ]
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'submodule update --init --recursive from subdirectory'>)}
        {
          (SQ <'\n'> <'\tgit -C recursivesuper/super reset --hard HEAD^ &&\n'> 
            <'\t(cd recursivesuper &&\n'> <'\t mkdir tmp &&\n'> <'\t cd tmp &&\n'> 
            <'\t git submodule update --init --recursive ../super >../../actual 2>../../actual2\n'> <'\t) &&\n'> <'\ttest_i18ncmp expect actual &&\n'> <'\ttest_i18ncmp expect2 actual2\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Sentence
      child: 
        (command.ShAssignment
          left: <Id.Lit_VarLike 'apos='>
          pairs: [
            (AssignPair
              left: <Id.Lit_VarLike 'apos='>
              lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'apos='> name:apos)
              op: assign_op.Equal
              rhs: {(DQ <'\''>)}
            )
          ]
          redirects: []
        )
      terminator: <Id.Op_Semi _>
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'submodule update does not fetch already present commits'>)}
        {
          (SQ <'\n'> <'\t(cd submodule &&\n'> <'\t  echo line3 >> file &&\n'> <'\t  git add file &&\n'> 
            <'\t  test_tick &&\n'> <'\t  git commit -m "upstream line3"\n'> <'\t) &&\n'> <'\t(cd super/submodule &&\n'> 
            <'\t  head=$(git rev-parse --verify HEAD) &&\n'> 
            <
'\t  echo "Submodule path ${apos}submodule$apos: checked out $apos$head$apos" > ../../expected &&\n'
            > <'\t  git reset --hard HEAD~1\n'> <'\t) &&\n'> <'\t(cd super &&\n'> 
            <'\t  git submodule update > ../actual 2> ../actual.err\n'> <'\t) &&\n'> <'\ttest_i18ncmp expected actual &&\n'> <'\t! test -s actual.err\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'submodule update should fail due to local changes'>)}
        {
          (SQ <'\n'> <'\t(cd super/submodule &&\n'> <'\t git reset --hard HEAD~1 &&\n'> 
            <'\t echo "local change" > file\n'> <'\t) &&\n'> <'\t(cd super &&\n'> <'\t (cd submodule &&\n'> <'\t  compare_head\n'> <'\t ) &&\n'> 
            <'\t test_must_fail git submodule update submodule\n'> <'\t)\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'submodule update should throw away changes with --force '>)}
        {
          (SQ <'\n'> <'\t(cd super &&\n'> <'\t (cd submodule &&\n'> <'\t  compare_head\n'> <'\t ) &&\n'> 
            <'\t git submodule update --force submodule &&\n'> <'\t cd submodule &&\n'> <'\t ! compare_head\n'> <'\t)\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'submodule update --force forcibly checks out submodules'>)}
        {
          (SQ <'\n'> <'\t(cd super &&\n'> <'\t (cd submodule &&\n'> <'\t  rm -f file\n'> <'\t ) &&\n'> 
            <'\t git submodule update --force submodule &&\n'> <'\t (cd submodule &&\n'> <'\t  test "$(git status -s file)" = ""\n'> <'\t )\n'> <'\t)\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'submodule update --remote should fetch upstream changes'>)}
        {
          (SQ <'\n'> <'\t(cd submodule &&\n'> <'\t echo line4 >> file &&\n'> <'\t git add file &&\n'> 
            <'\t test_tick &&\n'> <'\t git commit -m "upstream line4"\n'> <'\t) &&\n'> <'\t(cd super &&\n'> 
            <'\t git submodule update --remote --force submodule &&\n'> <'\t cd submodule &&\n'> 
            <
'\t test "$(git log -1 --oneline)" = "$(GIT_DIR=../../submodule/.git git log -1 --oneline)"\n'
            > <'\t)\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'submodule update --remote should fetch upstream changes with .'>)}
        {
          (SQ <'\n'> <'\t(\n'> <'\t\tcd super &&\n'> 
            <'\t\tgit config -f .gitmodules submodule."submodule".branch "." &&\n'> <'\t\tgit add .gitmodules &&\n'> 
            <'\t\tgit commit -m "submodules: update from the respective superproject branch"\n'> <'\t) &&\n'> <'\t(\n'> <'\t\tcd submodule &&\n'> <'\t\techo line4a >> file &&\n'> 
            <'\t\tgit add file &&\n'> <'\t\ttest_tick &&\n'> <'\t\tgit commit -m "upstream line4a" &&\n'> 
            <'\t\tgit checkout -b test-branch &&\n'> <'\t\ttest_commit on-test-branch\n'> <'\t) &&\n'> <'\t(\n'> <'\t\tcd super &&\n'> 
            <'\t\tgit submodule update --remote --force submodule &&\n'> <'\t\tgit -C submodule log -1 --oneline >actual\n'> 
            <'\t\tgit -C ../submodule log -1 --oneline master >expect\n'> <'\t\ttest_cmp expect actual &&\n'> <'\t\tgit checkout -b test-branch &&\n'> 
            <'\t\tgit submodule update --remote --force submodule &&\n'> <'\t\tgit -C submodule log -1 --oneline >actual\n'> 
            <'\t\tgit -C ../submodule log -1 --oneline test-branch >expect\n'> <'\t\ttest_cmp expect actual &&\n'> <'\t\tgit checkout master &&\n'> 
            <'\t\tgit branch -d test-branch &&\n'> <'\t\tgit reset --hard HEAD^\n'> <'\t)\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'local config should override .gitmodules branch'>)}
        {
          (SQ <'\n'> <'\t(cd submodule &&\n'> <'\t git checkout test-branch &&\n'> 
            <'\t echo line5 >> file &&\n'> <'\t git add file &&\n'> <'\t test_tick &&\n'> <'\t git commit -m "upstream line5" &&\n'> 
            <'\t git checkout master\n'> <'\t) &&\n'> <'\t(cd super &&\n'> <'\t git config submodule.submodule.branch test-branch &&\n'> 
            <'\t git submodule update --remote --force submodule &&\n'> <'\t cd submodule &&\n'> 
            <
'\t test "$(git log -1 --oneline)" = "$(GIT_DIR=../../submodule/.git git log -1 --oneline test-branch)"\n'
            > <'\t)\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'submodule update --rebase staying on master'>)}
        {
          (SQ <'\n'> <'\t(cd super/submodule &&\n'> <'\t  git checkout master\n'> <'\t) &&\n'> 
            <'\t(cd super &&\n'> <'\t (cd submodule &&\n'> <'\t  compare_head\n'> <'\t ) &&\n'> 
            <'\t git submodule update --rebase submodule &&\n'> <'\t cd submodule &&\n'> <'\t compare_head\n'> <'\t)\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'submodule update --merge staying on master'>)}
        {
          (SQ <'\n'> <'\t(cd super/submodule &&\n'> <'\t  git reset --hard HEAD~1\n'> <'\t) &&\n'> 
            <'\t(cd super &&\n'> <'\t (cd submodule &&\n'> <'\t  compare_head\n'> <'\t ) &&\n'> 
            <'\t git submodule update --merge submodule &&\n'> <'\t cd submodule &&\n'> <'\t compare_head\n'> <'\t)\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'submodule update - rebase in .git/config'>)}
        {
          (SQ <'\n'> <'\t(cd super &&\n'> <'\t git config submodule.submodule.update rebase\n'> 
            <'\t) &&\n'> <'\t(cd super/submodule &&\n'> <'\t  git reset --hard HEAD~1\n'> <'\t) &&\n'> <'\t(cd super &&\n'> 
            <'\t (cd submodule &&\n'> <'\t  compare_head\n'> <'\t ) &&\n'> <'\t git submodule update submodule &&\n'> <'\t cd submodule &&\n'> 
            <'\t compare_head\n'> <'\t)\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'submodule update - checkout in .git/config but --rebase given'>)}
        {
          (SQ <'\n'> <'\t(cd super &&\n'> <'\t git config submodule.submodule.update checkout\n'> 
            <'\t) &&\n'> <'\t(cd super/submodule &&\n'> <'\t  git reset --hard HEAD~1\n'> <'\t) &&\n'> <'\t(cd super &&\n'> 
            <'\t (cd submodule &&\n'> <'\t  compare_head\n'> <'\t ) &&\n'> <'\t git submodule update --rebase submodule &&\n'> 
            <'\t cd submodule &&\n'> <'\t compare_head\n'> <'\t)\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'submodule update - merge in .git/config'>)}
        {
          (SQ <'\n'> <'\t(cd super &&\n'> <'\t git config submodule.submodule.update merge\n'> 
            <'\t) &&\n'> <'\t(cd super/submodule &&\n'> <'\t  git reset --hard HEAD~1\n'> <'\t) &&\n'> <'\t(cd super &&\n'> 
            <'\t (cd submodule &&\n'> <'\t  compare_head\n'> <'\t ) &&\n'> <'\t git submodule update submodule &&\n'> <'\t cd submodule &&\n'> 
            <'\t compare_head\n'> <'\t)\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'submodule update - checkout in .git/config but --merge given'>)}
        {
          (SQ <'\n'> <'\t(cd super &&\n'> <'\t git config submodule.submodule.update checkout\n'> 
            <'\t) &&\n'> <'\t(cd super/submodule &&\n'> <'\t  git reset --hard HEAD~1\n'> <'\t) &&\n'> <'\t(cd super &&\n'> 
            <'\t (cd submodule &&\n'> <'\t  compare_head\n'> <'\t ) &&\n'> <'\t git submodule update --merge submodule &&\n'> 
            <'\t cd submodule &&\n'> <'\t compare_head\n'> <'\t)\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'submodule update - checkout in .git/config'>)}
        {
          (SQ <'\n'> <'\t(cd super &&\n'> <'\t git config submodule.submodule.update checkout\n'> 
            <'\t) &&\n'> <'\t(cd super/submodule &&\n'> <'\t  git reset --hard HEAD^\n'> <'\t) &&\n'> <'\t(cd super &&\n'> 
            <'\t (cd submodule &&\n'> <'\t  compare_head\n'> <'\t ) &&\n'> <'\t git submodule update submodule &&\n'> <'\t cd submodule &&\n'> 
            <'\t ! compare_head\n'> <'\t)\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'submodule update - command in .git/config'>)}
        {
          (SQ <'\n'> <'\t(cd super &&\n'> 
            <'\t git config submodule.submodule.update "!git checkout"\n'> <'\t) &&\n'> <'\t(cd super/submodule &&\n'> <'\t  git reset --hard HEAD^\n'> <'\t) &&\n'> 
            <'\t(cd super &&\n'> <'\t (cd submodule &&\n'> <'\t  compare_head\n'> <'\t ) &&\n'> 
            <'\t git submodule update submodule &&\n'> <'\t cd submodule &&\n'> <'\t ! compare_head\n'> <'\t)\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <cat>
      more_env: []
      words: [{<cat>}]
      redirects: [
        (Redir
          op: <Id.Redir_DLess '<<'>
          loc: (redir_loc.Fd fd:0)
          arg: 
            (redir_param.HereDoc
              here_begin: {<EOF>}
              here_end_tok: <Id.Undefined_Tok ''>
              stdin_parts: [
                <'Execution of \'false '>
                ($ Id.VSub_DollarName submodulesha1)
                <'\' failed in submodule path \'submodule\'\n'>
              ]
            )
        )
        (Redir op:<Id.Redir_Great '>'> loc:(redir_loc.Fd fd:1) arg:{<expect>})
      ]
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'submodule update - command in .git/config catches failure'>)}
        {
          (SQ <'\n'> <'\t(cd super &&\n'> <'\t git config submodule.submodule.update "!false"\n'> 
            <'\t) &&\n'> <'\t(cd super/submodule &&\n'> <'\t  git reset --hard $submodulesha1^\n'> <'\t) &&\n'> 
            <'\t(cd super &&\n'> <'\t test_must_fail git submodule update submodule 2>../actual\n'> <'\t) &&\n'> 
            <'\ttest_i18ncmp actual expect\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <cat>
      more_env: []
      words: [{<cat>}]
      redirects: [
        (Redir
          op: <Id.Redir_DLess '<<'>
          loc: (redir_loc.Fd fd:0)
          arg: 
            (redir_param.HereDoc
              here_begin: {<EOF>}
              here_end_tok: <Id.Undefined_Tok ''>
              stdin_parts: [
                <'Execution of \'false '>
                ($ Id.VSub_DollarName submodulesha1)
                <'\' failed in submodule path \'../submodule\'\n'>
              ]
            )
        )
        (Redir op:<Id.Redir_Great '>'> loc:(redir_loc.Fd fd:1) arg:{<expect>})
      ]
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'submodule update - command in .git/config catches failure -- subdirectory'>)}
        {
          (SQ <'\n'> <'\t(cd super &&\n'> <'\t git config submodule.submodule.update "!false"\n'> 
            <'\t) &&\n'> <'\t(cd super/submodule &&\n'> <'\t  git reset --hard $submodulesha1^\n'> <'\t) &&\n'> 
            <'\t(cd super &&\n'> <'\t mkdir tmp && cd tmp &&\n'> 
            <'\t test_must_fail git submodule update ../submodule 2>../../actual\n'> <'\t) &&\n'> <'\ttest_i18ncmp actual expect\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <cat>
      more_env: []
      words: [{<cat>}]
      redirects: [
        (Redir
          op: <Id.Redir_DLess '<<'>
          loc: (redir_loc.Fd fd:0)
          arg: 
            (redir_param.HereDoc
              here_begin: {<EOF>}
              here_end_tok: <Id.Undefined_Tok ''>
              stdin_parts: [
                <'Execution of \'false '>
                ($ Id.VSub_DollarName submodulesha1)
                <'\' failed in submodule path \'../super/submodule\'\n'>
                <'Failed to recurse into submodule path \'../super\'\n'>
              ]
            )
        )
        (Redir op:<Id.Redir_Great '>'> loc:(redir_loc.Fd fd:1) arg:{<expect>})
      ]
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'recursive submodule update - command in .git/config catches failure -- subdirectory'>)}
        {
          (SQ <'\n'> <'\t(cd recursivesuper &&\n'> <'\t git submodule update --remote super &&\n'> 
            <'\t git add super &&\n'> <'\t git commit -m "update to latest to have more than one commit in submodules"\n'> <'\t) &&\n'> 
            <'\tgit -C recursivesuper/super config submodule.submodule.update "!false" &&\n'> <'\tgit -C recursivesuper/super/submodule reset --hard $submodulesha1^ &&\n'> 
            <'\t(cd recursivesuper &&\n'> <'\t mkdir -p tmp && cd tmp &&\n'> 
            <'\t test_must_fail git submodule update --recursive ../super 2>../../actual\n'> <'\t) &&\n'> <'\ttest_i18ncmp actual expect\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'submodule init does not copy command into .git/config'>)}
        {
          (SQ <'\n'> <'\t(cd super &&\n'> <'\t H=$(git ls-files -s submodule | cut -d" " -f2) &&\n'> 
            <'\t mkdir submodule1 &&\n'> <'\t git update-index --add --cacheinfo 160000 $H submodule1 &&\n'> 
            <'\t git config -f .gitmodules submodule.submodule1.path submodule1 &&\n'> <'\t git config -f .gitmodules submodule.submodule1.url ../submodule &&\n'> 
            <'\t git config -f .gitmodules submodule.submodule1.update !false &&\n'> <'\t git submodule init submodule1 &&\n'> <'\t echo "none" >expect &&\n'> 
            <'\t git config submodule.submodule1.update >actual &&\n'> <'\t test_cmp expect actual\n'> <'\t)\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'submodule init picks up rebase'>)}
        {
          (SQ <'\n'> <'\t(cd super &&\n'> 
            <'\t git config -f .gitmodules submodule.rebasing.update rebase &&\n'> <'\t git submodule init rebasing &&\n'> 
            <'\t test "rebase" = "$(git config submodule.rebasing.update)"\n'> <'\t)\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'submodule init picks up merge'>)}
        {
          (SQ <'\n'> <'\t(cd super &&\n'> 
            <'\t git config -f .gitmodules submodule.merging.update merge &&\n'> <'\t git submodule init merging &&\n'> 
            <'\t test "merge" = "$(git config submodule.merging.update)"\n'> <'\t)\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'submodule update --merge  - ignores --merge  for new submodules'>)}
        {
          (SQ <'\n'> <'\t(cd super &&\n'> <'\t rm -rf submodule &&\n'> 
            <'\t git submodule update submodule &&\n'> <'\t git status -s submodule >expect &&\n'> <'\t rm -rf submodule &&\n'> 
            <'\t git submodule update --merge submodule &&\n'> <'\t git status -s submodule >actual &&\n'> <'\t test_cmp expect actual\n'> <'\t)\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'submodule update --rebase - ignores --rebase for new submodules'>)}
        {
          (SQ <'\n'> <'\t(cd super &&\n'> <'\t rm -rf submodule &&\n'> 
            <'\t git submodule update submodule &&\n'> <'\t git status -s submodule >expect &&\n'> <'\t rm -rf submodule &&\n'> 
            <'\t git submodule update --rebase submodule &&\n'> <'\t git status -s submodule >actual &&\n'> <'\t test_cmp expect actual\n'> <'\t)\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'submodule update ignores update=merge config for new submodules'>)}
        {
          (SQ <'\n'> <'\t(cd super &&\n'> <'\t rm -rf submodule &&\n'> 
            <'\t git submodule update submodule &&\n'> <'\t git status -s submodule >expect &&\n'> <'\t rm -rf submodule &&\n'> 
            <'\t git config submodule.submodule.update merge &&\n'> <'\t git submodule update submodule &&\n'> <'\t git status -s submodule >actual &&\n'> 
            <'\t git config --unset submodule.submodule.update &&\n'> <'\t test_cmp expect actual\n'> <'\t)\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'submodule update ignores update=rebase config for new submodules'>)}
        {
          (SQ <'\n'> <'\t(cd super &&\n'> <'\t rm -rf submodule &&\n'> 
            <'\t git submodule update submodule &&\n'> <'\t git status -s submodule >expect &&\n'> <'\t rm -rf submodule &&\n'> 
            <'\t git config submodule.submodule.update rebase &&\n'> <'\t git submodule update submodule &&\n'> <'\t git status -s submodule >actual &&\n'> 
            <'\t git config --unset submodule.submodule.update &&\n'> <'\t test_cmp expect actual\n'> <'\t)\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'submodule init picks up update=none'>)}
        {
          (SQ <'\n'> <'\t(cd super &&\n'> 
            <'\t git config -f .gitmodules submodule.none.update none &&\n'> <'\t git submodule init none &&\n'> <'\t test "none" = "$(git config submodule.none.update)"\n'> 
            <'\t)\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'submodule update - update=none in .git/config'>)}
        {
          (SQ <'\n'> <'\t(cd super &&\n'> <'\t git config submodule.submodule.update none &&\n'> 
            <'\t (cd submodule &&\n'> <'\t  git checkout master &&\n'> <'\t  compare_head\n'> <'\t ) &&\n'> 
            <'\t git diff --raw | grep "\tsubmodule" &&\n'> <'\t git submodule update &&\n'> <'\t git diff --raw | grep "\tsubmodule" &&\n'> 
            <'\t (cd submodule &&\n'> <'\t  compare_head\n'> <'\t ) &&\n'> <'\t git config --unset submodule.submodule.update &&\n'> 
            <'\t git submodule update submodule\n'> <'\t)\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'submodule update - update=none in .git/config but --checkout given'>)}
        {
          (SQ <'\n'> <'\t(cd super &&\n'> <'\t git config submodule.submodule.update none &&\n'> 
            <'\t (cd submodule &&\n'> <'\t  git checkout master &&\n'> <'\t  compare_head\n'> <'\t ) &&\n'> 
            <'\t git diff --raw | grep "\tsubmodule" &&\n'> <'\t git submodule update --checkout &&\n'> 
            <'\t test_must_fail git diff --raw \\| grep "\tsubmodule" &&\n'> <'\t (cd submodule &&\n'> <'\t  test_must_fail compare_head\n'> <'\t ) &&\n'> 
            <'\t git config --unset submodule.submodule.update\n'> <'\t)\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'submodule update --init skips submodule with update=none'>)}
        {
          (SQ <'\n'> <'\t(cd super &&\n'> <'\t git add .gitmodules &&\n'> 
            <'\t git commit -m ".gitmodules"\n'> <'\t) &&\n'> <'\tgit clone super cloned &&\n'> <'\t(cd cloned &&\n'> 
            <'\t git submodule update --init &&\n'> <'\t test -e submodule/.git &&\n'> <'\t test_must_fail test -e none/.git\n'> <'\t)\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'submodule update continues after checkout error'>)}
        {
          (SQ <'\n'> <'\t(cd super &&\n'> <'\t git reset --hard HEAD &&\n'> 
            <'\t git submodule add ../submodule submodule2 &&\n'> <'\t git submodule init &&\n'> <'\t git commit -am "new_submodule" &&\n'> <'\t (cd submodule2 &&\n'> 
            <'\t  git rev-parse --verify HEAD >../expect\n'> <'\t ) &&\n'> <'\t (cd submodule &&\n'> <'\t  test_commit "update_submodule" file\n'> <'\t ) &&\n'> 
            <'\t (cd submodule2 &&\n'> <'\t  test_commit "update_submodule2" file\n'> <'\t ) &&\n'> <'\t git add submodule &&\n'> 
            <'\t git add submodule2 &&\n'> <'\t git commit -m "two_new_submodule_commits" &&\n'> <'\t (cd submodule &&\n'> 
            <'\t  echo "" > file\n'> <'\t ) &&\n'> <'\t git checkout HEAD^ &&\n'> <'\t test_must_fail git submodule update &&\n'> 
            <'\t (cd submodule2 &&\n'> <'\t  git rev-parse --verify HEAD >../actual\n'> <'\t ) &&\n'> <'\t test_cmp expect actual\n'> <'\t)\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'submodule update continues after recursive checkout error'>)}
        {
          (SQ <'\n'> <'\t(cd super &&\n'> <'\t git reset --hard HEAD &&\n'> 
            <'\t git checkout master &&\n'> <'\t git submodule update &&\n'> <'\t (cd submodule &&\n'> 
            <'\t  git submodule add ../submodule subsubmodule &&\n'> <'\t  git submodule init &&\n'> <'\t  git commit -m "new_subsubmodule"\n'> <'\t ) &&\n'> 
            <'\t git add submodule &&\n'> <'\t git commit -m "update_submodule" &&\n'> <'\t (cd submodule &&\n'> <'\t  (cd subsubmodule &&\n'> 
            <'\t   test_commit "update_subsubmodule" file\n'> <'\t  ) &&\n'> <'\t  git add subsubmodule &&\n'> <'\t  test_commit "update_submodule_again" file &&\n'> 
            <'\t  (cd subsubmodule &&\n'> <'\t   test_commit "update_subsubmodule_again" file\n'> <'\t  ) &&\n'> 
            <'\t  test_commit "update_submodule_again_again" file\n'> <'\t ) &&\n'> <'\t (cd submodule2 &&\n'> <'\t  git rev-parse --verify HEAD >../expect &&\n'> 
            <'\t  test_commit "update_submodule2_again" file\n'> <'\t ) &&\n'> <'\t git add submodule &&\n'> <'\t git add submodule2 &&\n'> 
            <'\t git commit -m "new_commits" &&\n'> <'\t git checkout HEAD^ &&\n'> <'\t (cd submodule &&\n'> <'\t  git checkout HEAD^ &&\n'> 
            <'\t  (cd subsubmodule &&\n'> <'\t   echo "" > file\n'> <'\t  )\n'> <'\t ) &&\n'> 
            <'\t test_must_fail git submodule update --recursive &&\n'> <'\t (cd submodule2 &&\n'> <'\t  git rev-parse --verify HEAD >../actual\n'> <'\t ) &&\n'> 
            <'\t test_cmp expect actual\n'> <'\t)\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'submodule update exit immediately in case of merge conflict'>)}
        {
          (SQ <'\n'> <'\t(cd super &&\n'> <'\t git checkout master &&\n'> 
            <'\t git reset --hard HEAD &&\n'> <'\t (cd submodule &&\n'> <'\t  (cd subsubmodule &&\n'> <'\t   git reset --hard HEAD\n'> <'\t  )\n'> 
            <'\t ) &&\n'> <'\t git submodule update --recursive &&\n'> <'\t (cd submodule &&\n'> 
            <'\t  test_commit "update_submodule_2" file\n'> <'\t ) &&\n'> <'\t (cd submodule2 &&\n'> <'\t  test_commit "update_submodule2_2" file\n'> <'\t ) &&\n'> 
            <'\t git add submodule &&\n'> <'\t git add submodule2 &&\n'> <'\t git commit -m "two_new_submodule_commits" &&\n'> 
            <'\t (cd submodule &&\n'> <'\t  git checkout master &&\n'> <'\t  test_commit "conflict" file &&\n'> 
            <'\t  echo "conflict" > file\n'> <'\t ) &&\n'> <'\t git checkout HEAD^ &&\n'> <'\t (cd submodule2 &&\n'> 
            <'\t  git rev-parse --verify HEAD >../expect\n'> <'\t ) &&\n'> <'\t git config submodule.submodule.update merge &&\n'> 
            <'\t test_must_fail git submodule update &&\n'> <'\t (cd submodule2 &&\n'> <'\t  git rev-parse --verify HEAD >../actual\n'> <'\t ) &&\n'> 
            <'\t test_cmp expect actual\n'> <'\t)\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'submodule update exit immediately after recursive rebase error'>)}
        {
          (SQ <'\n'> <'\t(cd super &&\n'> <'\t git checkout master &&\n'> 
            <'\t git reset --hard HEAD &&\n'> <'\t (cd submodule &&\n'> <'\t  git reset --hard HEAD &&\n'> <'\t  git submodule update --recursive\n'> 
            <'\t ) &&\n'> <'\t (cd submodule &&\n'> <'\t  test_commit "update_submodule_3" file\n'> <'\t ) &&\n'> 
            <'\t (cd submodule2 &&\n'> <'\t  test_commit "update_submodule2_3" file\n'> <'\t ) &&\n'> <'\t git add submodule &&\n'> 
            <'\t git add submodule2 &&\n'> <'\t git commit -m "two_new_submodule_commits" &&\n'> <'\t (cd submodule &&\n'> 
            <'\t  git checkout master &&\n'> <'\t  test_commit "conflict2" file &&\n'> <'\t  echo "conflict" > file\n'> <'\t ) &&\n'> 
            <'\t git checkout HEAD^ &&\n'> <'\t (cd submodule2 &&\n'> <'\t  git rev-parse --verify HEAD >../expect\n'> <'\t ) &&\n'> 
            <'\t git config submodule.submodule.update rebase &&\n'> <'\t test_must_fail git submodule update &&\n'> <'\t (cd submodule2 &&\n'> 
            <'\t  git rev-parse --verify HEAD >../actual\n'> <'\t ) &&\n'> <'\t test_cmp expect actual\n'> <'\t)\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'add different submodules to the same path'>)}
        {
          (SQ <'\n'> <'\t(cd super &&\n'> <'\t git submodule add ../submodule s1 &&\n'> 
            <'\t test_must_fail git submodule add ../merging s1\n'> <'\t)\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'submodule add places git-dir in superprojects git-dir'>)}
        {
          (SQ <'\n'> <'\t(cd super &&\n'> <'\t mkdir deeper &&\n'> 
            <'\t git submodule add ../submodule deeper/submodule &&\n'> <'\t (cd deeper/submodule &&\n'> <'\t  git log > ../../expected\n'> <'\t ) &&\n'> 
            <'\t (cd .git/modules/deeper/submodule &&\n'> <'\t  git log > ../../../../actual\n'> <'\t ) &&\n'> <'\t test_cmp actual expected\n'> <'\t)\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'submodule update places git-dir in superprojects git-dir'>)}
        {
          (SQ <'\n'> <'\t(cd super &&\n'> <'\t git commit -m "added submodule"\n'> <'\t) &&\n'> 
            <'\tgit clone super super2 &&\n'> <'\t(cd super2 &&\n'> <'\t git submodule init deeper/submodule &&\n'> <'\t git submodule update &&\n'> 
            <'\t (cd deeper/submodule &&\n'> <'\t  git log > ../../expected\n'> <'\t ) &&\n'> <'\t (cd .git/modules/deeper/submodule &&\n'> 
            <'\t  git log > ../../../../actual\n'> <'\t ) &&\n'> <'\t test_cmp actual expected\n'> <'\t)\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'submodule add places git-dir in superprojects git-dir recursive'>)}
        {
          (SQ <'\n'> <'\t(cd super2 &&\n'> <'\t (cd deeper/submodule &&\n'> 
            <'\t  git submodule add ../submodule subsubmodule &&\n'> <'\t  (cd subsubmodule &&\n'> <'\t   git log > ../../../expected\n'> <'\t  ) &&\n'> 
            <'\t  git commit -m "added subsubmodule" &&\n'> <'\t  git push origin :\n'> <'\t ) &&\n'> 
            <'\t (cd .git/modules/deeper/submodule/modules/subsubmodule &&\n'> <'\t  git log > ../../../../../actual\n'> <'\t ) &&\n'> <'\t git add deeper/submodule &&\n'> 
            <'\t git commit -m "update submodule" &&\n'> <'\t git push origin : &&\n'> <'\t test_cmp actual expected\n'> <'\t)\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'submodule update places git-dir in superprojects git-dir recursive'>)}
        {
          (SQ <'\n'> <'\tmkdir super_update_r &&\n'> <'\t(cd super_update_r &&\n'> 
            <'\t git init --bare\n'> <'\t) &&\n'> <'\tmkdir subsuper_update_r &&\n'> <'\t(cd subsuper_update_r &&\n'> 
            <'\t git init --bare\n'> <'\t) &&\n'> <'\tmkdir subsubsuper_update_r &&\n'> <'\t(cd subsubsuper_update_r &&\n'> 
            <'\t git init --bare\n'> <'\t) &&\n'> <'\tgit clone subsubsuper_update_r subsubsuper_update_r2 &&\n'> 
            <'\t(cd subsubsuper_update_r2 &&\n'> <'\t test_commit "update_subsubsuper" file &&\n'> <'\t git push origin master\n'> <'\t) &&\n'> 
            <'\tgit clone subsuper_update_r subsuper_update_r2 &&\n'> <'\t(cd subsuper_update_r2 &&\n'> <'\t test_commit "update_subsuper" file &&\n'> 
            <'\t git submodule add ../subsubsuper_update_r subsubmodule &&\n'> <'\t git commit -am "subsubmodule" &&\n'> <'\t git push origin master\n'> <'\t) &&\n'> 
            <'\tgit clone super_update_r super_update_r2 &&\n'> <'\t(cd super_update_r2 &&\n'> <'\t test_commit "update_super" file &&\n'> 
            <'\t git submodule add ../subsuper_update_r submodule &&\n'> <'\t git commit -am "submodule" &&\n'> <'\t git push origin master\n'> <'\t) &&\n'> 
            <'\trm -rf super_update_r2 &&\n'> <'\tgit clone super_update_r super_update_r2 &&\n'> <'\t(cd super_update_r2 &&\n'> 
            <'\t git submodule update --init --recursive >actual &&\n'> <'\t test_i18ngrep "Submodule path .submodule/subsubmodule.: checked out" actual &&\n'> 
            <'\t (cd submodule/subsubmodule &&\n'> <'\t  git log > ../../expected\n'> <'\t ) &&\n'> 
            <'\t (cd .git/modules/submodule/modules/subsubmodule\n'> <'\t  git log > ../../../../../actual\n'> <'\t )\n'> <'\t test_cmp actual expected\n'> <'\t)\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'submodule add properly re-creates deeper level submodules'>)}
        {
          (SQ <'\n'> <'\t(cd super &&\n'> <'\t git reset --hard master &&\n'> <'\t rm -rf deeper/ &&\n'> 
            <'\t git submodule add --force ../submodule deeper/submodule\n'> <'\t)\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'submodule update properly revives a moved submodule'>)}
        {
          (SQ <'\n'> <'\t(cd super &&\n'> <'\t H=$(git rev-parse --short HEAD) &&\n'> 
            <'\t git commit -am "pre move" &&\n'> <'\t H2=$(git rev-parse --short HEAD) &&\n'> <'\t git status | sed "s/$H/XXX/" >expect &&\n'> 
            <'\t H=$(cd submodule2; git rev-parse HEAD) &&\n'> <'\t git rm --cached submodule2 &&\n'> <'\t rm -rf submodule2 &&\n'> 
            <'\t mkdir -p "moved/sub module" &&\n'> <'\t git update-index --add --cacheinfo 160000 $H "moved/sub module" &&\n'> 
            <'\t git config -f .gitmodules submodule.submodule2.path "moved/sub module"\n'> <'\t git commit -am "post move" &&\n'> <'\t git submodule update &&\n'> 
            <'\t git status | sed "s/$H2/XXX/" >actual &&\n'> <'\t test_cmp expect actual\n'> <'\t)\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {<SYMLINKS>}
        {(SQ <'submodule update can handle symbolic links in pwd'>)}
        {
          (SQ <'\n'> <'\tmkdir -p linked/dir &&\n'> <'\tln -s linked/dir linkto &&\n'> 
            <'\t(cd linkto &&\n'> <'\t git clone "$TRASH_DIRECTORY"/super_update_r2 super &&\n'> <'\t (cd super &&\n'> 
            <'\t  git submodule update --init --recursive\n'> <'\t )\n'> <'\t)\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'submodule update clone shallow submodule'>)}
        {
          (SQ <'\n'> <'\ttest_when_finished "rm -rf super3" &&\n'> 
            <'\tfirst=$(git -C cloned submodule status submodule |cut -c2-41) &&\n'> <'\tsecond=$(git -C submodule rev-parse HEAD) &&\n'> 
            <'\tcommit_count=$(git -C submodule rev-list --count $first^..$second) &&\n'> <'\tgit clone cloned super3 &&\n'> <'\tpwd=$(pwd) &&\n'> <'\t(\n'> <'\t\tcd super3 &&\n'> 
            <'\t\tsed -e "s#url = ../#url = file://$pwd/#" <.gitmodules >.gitmodules.tmp &&\n'> <'\t\tmv -f .gitmodules.tmp .gitmodules &&\n'> 
            <'\t\tgit submodule update --init --depth=$commit_count &&\n'> <'\t\ttest 1 = $(git -C submodule log --oneline | wc -l)\n'> <'\t)\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'submodule update clone shallow submodule outside of depth'>)}
        {
          (SQ <'\n'> <'\ttest_when_finished "rm -rf super3" &&\n'> <'\tgit clone cloned super3 &&\n'> 
            <'\tpwd=$(pwd) &&\n'> <'\t(\n'> <'\t\tcd super3 &&\n'> 
            <'\t\tsed -e "s#url = ../#url = file://$pwd/#" <.gitmodules >.gitmodules.tmp &&\n'> <'\t\tmv -f .gitmodules.tmp .gitmodules &&\n'> 
            <'\t\ttest_must_fail git submodule update --init --depth=1 2>actual &&\n'> <'\t\ttest_i18ngrep "Direct fetching of that commit failed." actual &&\n'> 
            <'\t\tgit -C ../submodule config uploadpack.allowReachableSHA1InWant true &&\n'> <'\t\tgit submodule update --init --depth=1 >actual &&\n'> 
            <'\t\ttest 1 = $(git -C submodule log --oneline | wc -l)\n'> <'\t)\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'submodule update --recursive drops module name before recursing'>)}
        {
          (SQ <'\n'> <'\t(cd super2 &&\n'> <'\t (cd deeper/submodule/subsubmodule &&\n'> 
            <'\t  git checkout HEAD^\n'> <'\t ) &&\n'> <'\t git submodule update --recursive deeper/submodule >actual &&\n'> 
            <
'\t test_i18ngrep "Submodule path .deeper/submodule/subsubmodule.: checked out" actual\n'
            > <'\t)\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'submodule update can be run in parallel'>)}
        {
          (SQ <'\n'> <'\t(cd super2 &&\n'> 
            <'\t GIT_TRACE=$(pwd)/trace.out git submodule update --jobs 7 &&\n'> <'\t grep "7 tasks" trace.out &&\n'> <'\t git config submodule.fetchJobs 8 &&\n'> 
            <'\t GIT_TRACE=$(pwd)/trace.out git submodule update &&\n'> <'\t grep "8 tasks" trace.out &&\n'> 
            <'\t GIT_TRACE=$(pwd)/trace.out git submodule update --jobs 9 &&\n'> <'\t grep "9 tasks" trace.out\n'> <'\t)\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_expect_success>
      more_env: []
      words: [
        {<test_expect_success>}
        {(SQ <'git clone passes the parallel jobs config on to submodules'>)}
        {
          (SQ <'\n'> <'\ttest_when_finished "rm -rf super4" &&\n'> 
            <'\tGIT_TRACE=$(pwd)/trace.out git clone --recurse-submodules --jobs 7 . super4 &&\n'> <'\tgrep "7 tasks" trace.out &&\n'> <'\trm -rf super4 &&\n'> 
            <'\tgit config --global submodule.fetchJobs 8 &&\n'> <'\tGIT_TRACE=$(pwd)/trace.out git clone --recurse-submodules . super4 &&\n'> 
            <'\tgrep "8 tasks" trace.out &&\n'> <'\trm -rf super4 &&\n'> 
            <'\tGIT_TRACE=$(pwd)/trace.out git clone --recurse-submodules --jobs 9 . super4 &&\n'> <'\tgrep "9 tasks" trace.out &&\n'> <'\trm -rf super4\n'>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <test_done>
      more_env: []
      words: [{<test_done>}]
      redirects: []
      do_fork: T
    )
  ]
)