Merge branch 'sb/dashless'

* sb/dashless:
  Make usage strings dash-less
  t/: Use "test_must_fail git" instead of "! git"
  t/test-lib.sh: exit with small negagive int is ok with test_must_fail

Conflicts:
	builtin-blame.c
	builtin-mailinfo.c
	builtin-mailsplit.c
	builtin-shortlog.c
	git-am.sh
	t/t4150-am.sh
	t/t4200-rerere.sh

diff --cc builtin-archive.c
index 88204bf733ebdba79b1ac175da8ec26f6cfec597,5cca460129efd900fb194620a0ac91da5c71e38a..d5e3af879e7935ae3d5a6fad11951071e379855e
--- 1/builtin-archive.c
--- 2/builtin-archive.c
+++ b/builtin-archive.c
@@@ -13,13 -13,16 +13,13 @@@
  #include "attr.h"
  
  static const char archive_usage[] = \
- "git-archive --format=<fmt> [--prefix=<prefix>/] [--verbose] [<extra>] <tree-ish> [path...]";
+ "git archive --format=<fmt> [--prefix=<prefix>/] [--verbose] [<extra>] <tree-ish> [path...]";
  
 -static struct archiver_desc
 -{
 -      const char *name;
 -      write_archive_fn_t write_archive;
 -      parse_extra_args_fn_t parse_extra;
 -} archivers[] = {
 -      { "tar", write_tar_archive, NULL },
 -      { "zip", write_zip_archive, parse_extra_zip_args },
 +#define USES_ZLIB_COMPRESSION 1
 +
 +const struct archiver archivers[] = {
 +      { "tar", write_tar_archive },
 +      { "zip", write_zip_archive, USES_ZLIB_COMPRESSION },
  };
  
  static int run_remote_archiver(const char *remote, int argc,

diff --cc builtin-blame.c
index 8827f1e0c694be107b8c0e8112599c81b1c1c12a,91850a53e1a9a1b8ad9b478829a6cc9b32984b59..9bced3b2626eb72ccb4b8756b47163db4c026540
--- 1/builtin-blame.c
--- 2/builtin-blame.c
+++ b/builtin-blame.c
@@@ -18,16 -18,24 +18,16 @@@
  #include "cache-tree.h"
  #include "path-list.h"
  #include "mailmap.h"
 +#include "parse-options.h"
  
- static char blame_usage[] = "git-blame [options] [rev-opts] [rev] [--] file";
 -static char blame_usage[] =
 -"git blame [-c] [-b] [-l] [--root] [-t] [-f] [-n] [-s] [-p] [-w] [-L n,m] [-S <revs-file>] [-M] [-C] [-C] [--contents <filename>] [--incremental] [commit] [--] file\n"
 -"  -c                  Use the same output mode as git-annotate (Default: off)\n"
 -"  -b                  Show blank SHA-1 for boundary commits (Default: off)\n"
 -"  -l                  Show long commit SHA1 (Default: off)\n"
 -"  --root              Do not treat root commits as boundaries (Default: off)\n"
 -"  -t                  Show raw timestamp (Default: off)\n"
 -"  -f, --show-name     Show original filename (Default: auto)\n"
 -"  -n, --show-number   Show original linenumber (Default: off)\n"
 -"  -s                  Suppress author name and timestamp (Default: off)\n"
 -"  -p, --porcelain     Show in a format designed for machine consumption\n"
 -"  -w                  Ignore whitespace differences\n"
 -"  -L n,m              Process only line range n,m, counting from 1\n"
 -"  -M, -C              Find line movements within and across files\n"
 -"  --incremental       Show blame entries as we find them, incrementally\n"
 -"  --contents file     Use <file>'s contents as the final image\n"
 -"  -S revs-file        Use revisions from revs-file instead of calling git-rev-list\n";
++static char blame_usage[] = "git blame [options] [rev-opts] [rev] [--] file";
 +
 +static const char *blame_opt_usage[] = {
 +      blame_usage,
 +      "",
 +      "[rev-opts] are documented in git-rev-list(1)",
 +      NULL
 +};
  
  static int longest_file;
  static int longest_author;

diff --cc builtin-branch.c
Simple merge

diff --cc builtin-commit.c
Simple merge

diff --cc builtin-describe.c
Simple merge

diff --cc builtin-fmt-merge-msg.c
Simple merge

diff --cc builtin-grep.c
Simple merge

diff --cc builtin-init-db.c
Simple merge

diff --cc builtin-log.c
Simple merge

diff --cc builtin-ls-tree.c
Simple merge

diff --cc builtin-mailinfo.c
index 13f0502b9e0bca9e4119896c01786b99cc54441e,b3d281e36767c18b2a68ccd94154673cfc537272..a4f99c88622ef7ca0fea21b51082271ff237fb46
--- 1/builtin-mailinfo.c
--- 2/builtin-mailinfo.c
+++ b/builtin-mailinfo.c
@@@ -962,7 -960,7 +962,7 @@@ static int mailinfo(FILE *in, FILE *out
  }
  
  static const char mailinfo_usage[] =
-       "git-mailinfo [-k] [-u | --encoding=<encoding> | -n] msg patch <mail >info";
 -      "git mailinfo [-k] [-u | --encoding=<encoding>] msg patch <mail >info";
++      "git mailinfo [-k] [-u | --encoding=<encoding> | -n] msg patch <mail >info";
  
  int cmd_mailinfo(int argc, const char **argv, const char *prefix)
  {

diff --cc builtin-mailsplit.c
index e8cbe678ecdc0863ebe92e6499dd2b1eacf77db6,0dc4cd9a82a37ab94e3922a61595513ebfb57978..13c60c39a402834fbcdb58928c5b5686b7b05a51
--- 1/builtin-mailsplit.c
--- 2/builtin-mailsplit.c
+++ b/builtin-mailsplit.c
@@@ -9,7 -9,7 +9,7 @@@
  #include "path-list.h"
  
  static const char git_mailsplit_usage[] =
- "git-mailsplit [-d<prec>] [-f<n>] [-b] -o<directory> [<mbox>|<Maildir>...]";
 -"git mailsplit [-d<prec>] [-f<n>] [-b] -o<directory> <mbox>|<Maildir>...";
++"git mailsplit [-d<prec>] [-f<n>] [-b] -o<directory> [<mbox>|<Maildir>...]";
  
  static int is_from_line(const char *line, int len)
  {

diff --cc builtin-rerere.c
index 5d40e16932a4d8f3761b9aaebc21b630be904f8a,62ef7cfcf35663f90d724e5aba6dfaaf3b55c0ab..580580502cc0d84400edca8e2bda5ce607b43b58
--- 1/builtin-rerere.c
--- 2/builtin-rerere.c
+++ b/builtin-rerere.c
@@@ -5,8 -4,10 +5,8 @@@
  #include "xdiff/xdiff.h"
  #include "xdiff-interface.h"
  
 -#include <time.h>
 -
  static const char git_rerere_usage[] =
- "git-rerere [clear | status | diff | gc]";
+ "git rerere [clear | status | diff | gc]";
  
  /* these values are days */
  static int cutoff_noresolve = 15;

diff --cc builtin-rev-list.c
Simple merge

diff --cc builtin-revert.c
Simple merge

diff --cc builtin-shortlog.c
index f8bcbfce4009337c4aea0b923a620fc4697e4df3,fcb0da9fc80ca7cd00e44d58113c7fa7f4102a3a..94c4723856924a9643bcaf6c14fd9679667cbbdd
--- 1/builtin-shortlog.c
--- 2/builtin-shortlog.c
+++ b/builtin-shortlog.c
@@@ -7,14 -7,9 +7,14 @@@
  #include "utf8.h"
  #include "mailmap.h"
  #include "shortlog.h"
 +#include "parse-options.h"
  
 -static const char shortlog_usage[] =
 -"git shortlog [-n] [-s] [-e] [-w] [<commit-id>... ]";
 +static char const * const shortlog_usage[] = {
-       "git-shortlog [-n] [-s] [-e] [-w] [rev-opts] [--] [<commit-id>... ]",
++      "git shortlog [-n] [-s] [-e] [-w] [rev-opts] [--] [<commit-id>... ]",
 +      "",
 +      "[rev-opts] are documented in git-rev-list(1)",
 +      NULL
 +};
  
  static int compare_by_number(const void *a1, const void *a2)
  {

diff --cc builtin-tag.c
Simple merge

diff --cc builtin-upload-archive.c
Simple merge

diff --cc contrib/examples/git-merge.sh
index 8026ccff4a459a75148740382646f7fe10b00255,0000000000000000000000000000000000000000..e9588eec33ba5b64d186ff048bb040c18c57e6bc
mode 100755,000000..100755
--- 1/contrib/examples/git-merge.sh
--- /dev/null
+++ b/contrib/examples/git-merge.sh
@@@ -1,554 -1,0 +1,554 @@@
- git-merge [options] <remote>...
- git-merge [options] <msg> HEAD <remote>
 +#!/bin/sh
 +#
 +# Copyright (c) 2005 Junio C Hamano
 +#
 +
 +OPTIONS_KEEPDASHDASH=
 +OPTIONS_SPEC="\
++git merge [options] <remote>...
++git merge [options] <msg> HEAD <remote>
 +--
 +stat                 show a diffstat at the end of the merge
 +n                    don't show a diffstat at the end of the merge
 +summary              (synonym to --stat)
 +log                  add list of one-line log to merge commit message
 +squash               create a single commit instead of doing a merge
 +commit               perform a commit if the merge succeeds (default)
 +ff                   allow fast forward (default)
 +s,strategy=          merge strategy to use
 +m,message=           message to be used for the merge commit (if any)
 +"
 +
 +SUBDIRECTORY_OK=Yes
 +. git-sh-setup
 +require_work_tree
 +cd_to_toplevel
 +
 +test -z "$(git ls-files -u)" ||
 +      die "You are in the middle of a conflicted merge."
 +
 +LF='
 +'
 +
 +all_strategies='recur recursive octopus resolve stupid ours subtree'
 +default_twohead_strategies='recursive'
 +default_octopus_strategies='octopus'
 +no_fast_forward_strategies='subtree ours'
 +no_trivial_strategies='recursive recur subtree ours'
 +use_strategies=
 +
 +allow_fast_forward=t
 +allow_trivial_merge=t
 +squash= no_commit= log_arg=
 +
 +dropsave() {
 +      rm -f -- "$GIT_DIR/MERGE_HEAD" "$GIT_DIR/MERGE_MSG" \
 +               "$GIT_DIR/MERGE_STASH" || exit 1
 +}
 +
 +savestate() {
 +      # Stash away any local modifications.
 +      git stash create >"$GIT_DIR/MERGE_STASH"
 +}
 +
 +restorestate() {
 +        if test -f "$GIT_DIR/MERGE_STASH"
 +      then
 +              git reset --hard $head >/dev/null
 +              git stash apply $(cat "$GIT_DIR/MERGE_STASH")
 +              git update-index --refresh >/dev/null
 +      fi
 +}
 +
 +finish_up_to_date () {
 +      case "$squash" in
 +      t)
 +              echo "$1 (nothing to squash)" ;;
 +      '')
 +              echo "$1" ;;
 +      esac
 +      dropsave
 +}
 +
 +squash_message () {
 +      echo Squashed commit of the following:
 +      echo
 +      git log --no-merges --pretty=medium ^"$head" $remoteheads
 +}
 +
 +finish () {
 +      if test '' = "$2"
 +      then
 +              rlogm="$GIT_REFLOG_ACTION"
 +      else
 +              echo "$2"
 +              rlogm="$GIT_REFLOG_ACTION: $2"
 +      fi
 +      case "$squash" in
 +      t)
 +              echo "Squash commit -- not updating HEAD"
 +              squash_message >"$GIT_DIR/SQUASH_MSG"
 +              ;;
 +      '')
 +              case "$merge_msg" in
 +              '')
 +                      echo "No merge message -- not updating HEAD"
 +                      ;;
 +              *)
 +                      git update-ref -m "$rlogm" HEAD "$1" "$head" || exit 1
 +                      git gc --auto
 +                      ;;
 +              esac
 +              ;;
 +      esac
 +      case "$1" in
 +      '')
 +              ;;
 +      ?*)
 +              if test "$show_diffstat" = t
 +              then
 +                      # We want color (if set), but no pager
 +                      GIT_PAGER='' git diff --stat --summary -M "$head" "$1"
 +              fi
 +              ;;
 +      esac
 +
 +      # Run a post-merge hook
 +        if test -x "$GIT_DIR"/hooks/post-merge
 +        then
 +          case "$squash" in
 +          t)
 +                "$GIT_DIR"/hooks/post-merge 1
 +              ;;
 +          '')
 +                "$GIT_DIR"/hooks/post-merge 0
 +              ;;
 +          esac
 +        fi
 +}
 +
 +merge_name () {
 +      remote="$1"
 +      rh=$(git rev-parse --verify "$remote^0" 2>/dev/null) || return
 +      bh=$(git show-ref -s --verify "refs/heads/$remote" 2>/dev/null)
 +      if test "$rh" = "$bh"
 +      then
 +              echo "$rh               branch '$remote' of ."
 +      elif truname=$(expr "$remote" : '\(.*\)~[1-9][0-9]*$') &&
 +              git show-ref -q --verify "refs/heads/$truname" 2>/dev/null
 +      then
 +              echo "$rh               branch '$truname' (early part) of ."
 +      elif test "$remote" = "FETCH_HEAD" -a -r "$GIT_DIR/FETCH_HEAD"
 +      then
 +              sed -e 's/      not-for-merge   /               /' -e 1q \
 +                      "$GIT_DIR/FETCH_HEAD"
 +      else
 +              echo "$rh               commit '$remote'"
 +      fi
 +}
 +
 +parse_config () {
 +      while test $# != 0; do
 +              case "$1" in
 +              -n|--no-stat|--no-summary)
 +                      show_diffstat=false ;;
 +              --stat|--summary)
 +                      show_diffstat=t ;;
 +              --log|--no-log)
 +                      log_arg=$1 ;;
 +              --squash)
 +                      test "$allow_fast_forward" = t ||
 +                              die "You cannot combine --squash with --no-ff."
 +                      squash=t no_commit=t ;;
 +              --no-squash)
 +                      squash= no_commit= ;;
 +              --commit)
 +                      no_commit= ;;
 +              --no-commit)
 +                      no_commit=t ;;
 +              --ff)
 +                      allow_fast_forward=t ;;
 +              --no-ff)
 +                      test "$squash" != t ||
 +                              die "You cannot combine --squash with --no-ff."
 +                      allow_fast_forward=f ;;
 +              -s|--strategy)
 +                      shift
 +                      case " $all_strategies " in
 +                      *" $1 "*)
 +                              use_strategies="$use_strategies$1 " ;;
 +                      *)
 +                              die "available strategies are: $all_strategies" ;;
 +                      esac
 +                      ;;
 +              -m|--message)
 +                      shift
 +                      merge_msg="$1"
 +                      have_message=t
 +                      ;;
 +              --)
 +                      shift
 +                      break ;;
 +              *)      usage ;;
 +              esac
 +              shift
 +      done
 +      args_left=$#
 +}
 +
 +test $# != 0 || usage
 +
 +have_message=
 +
 +if branch=$(git-symbolic-ref -q HEAD)
 +then
 +      mergeopts=$(git config "branch.${branch#refs/heads/}.mergeoptions")
 +      if test -n "$mergeopts"
 +      then
 +              parse_config $mergeopts --
 +      fi
 +fi
 +
 +parse_config "$@"
 +while test $args_left -lt $#; do shift; done
 +
 +if test -z "$show_diffstat"; then
 +    test "$(git config --bool merge.diffstat)" = false && show_diffstat=false
 +    test "$(git config --bool merge.stat)" = false && show_diffstat=false
 +    test -z "$show_diffstat" && show_diffstat=t
 +fi
 +
 +# This could be traditional "merge <msg> HEAD <commit>..."  and the
 +# way we can tell it is to see if the second token is HEAD, but some
 +# people might have misused the interface and used a committish that
 +# is the same as HEAD there instead.  Traditional format never would
 +# have "-m" so it is an additional safety measure to check for it.
 +
 +if test -z "$have_message" &&
 +      second_token=$(git rev-parse --verify "$2^0" 2>/dev/null) &&
 +      head_commit=$(git rev-parse --verify "HEAD" 2>/dev/null) &&
 +      test "$second_token" = "$head_commit"
 +then
 +      merge_msg="$1"
 +      shift
 +      head_arg="$1"
 +      shift
 +elif ! git rev-parse --verify HEAD >/dev/null 2>&1
 +then
 +      # If the merged head is a valid one there is no reason to
 +      # forbid "git merge" into a branch yet to be born.  We do
 +      # the same for "git pull".
 +      if test 1 -ne $#
 +      then
 +              echo >&2 "Can merge only exactly one commit into empty head"
 +              exit 1
 +      fi
 +
 +      rh=$(git rev-parse --verify "$1^0") ||
 +              die "$1 - not something we can merge"
 +
 +      git update-ref -m "initial pull" HEAD "$rh" "" &&
 +      git read-tree --reset -u HEAD
 +      exit
 +
 +else
 +      # We are invoked directly as the first-class UI.
 +      head_arg=HEAD
 +
 +      # All the rest are the commits being merged; prepare
 +      # the standard merge summary message to be appended to
 +      # the given message.  If remote is invalid we will die
 +      # later in the common codepath so we discard the error
 +      # in this loop.
 +      merge_name=$(for remote
 +              do
 +                      merge_name "$remote"
 +              done | git fmt-merge-msg $log_arg
 +      )
 +      merge_msg="${merge_msg:+$merge_msg$LF$LF}$merge_name"
 +fi
 +head=$(git rev-parse --verify "$head_arg"^0) || usage
 +
 +# All the rest are remote heads
 +test "$#" = 0 && usage ;# we need at least one remote head.
 +set_reflog_action "merge $*"
 +
 +remoteheads=
 +for remote
 +do
 +      remotehead=$(git rev-parse --verify "$remote"^0 2>/dev/null) ||
 +          die "$remote - not something we can merge"
 +      remoteheads="${remoteheads}$remotehead "
 +      eval GITHEAD_$remotehead='"$remote"'
 +      export GITHEAD_$remotehead
 +done
 +set x $remoteheads ; shift
 +
 +case "$use_strategies" in
 +'')
 +      case "$#" in
 +      1)
 +              var="`git config --get pull.twohead`"
 +              if test -n "$var"
 +              then
 +                      use_strategies="$var"
 +              else
 +                      use_strategies="$default_twohead_strategies"
 +              fi ;;
 +      *)
 +              var="`git config --get pull.octopus`"
 +              if test -n "$var"
 +              then
 +                      use_strategies="$var"
 +              else
 +                      use_strategies="$default_octopus_strategies"
 +              fi ;;
 +      esac
 +      ;;
 +esac
 +
 +for s in $use_strategies
 +do
 +      for ss in $no_fast_forward_strategies
 +      do
 +              case " $s " in
 +              *" $ss "*)
 +                      allow_fast_forward=f
 +                      break
 +                      ;;
 +              esac
 +      done
 +      for ss in $no_trivial_strategies
 +      do
 +              case " $s " in
 +              *" $ss "*)
 +                      allow_trivial_merge=f
 +                      break
 +                      ;;
 +              esac
 +      done
 +done
 +
 +case "$#" in
 +1)
 +      common=$(git merge-base --all $head "$@")
 +      ;;
 +*)
 +      common=$(git show-branch --merge-base $head "$@")
 +      ;;
 +esac
 +echo "$head" >"$GIT_DIR/ORIG_HEAD"
 +
 +case "$allow_fast_forward,$#,$common,$no_commit" in
 +?,*,'',*)
 +      # No common ancestors found. We need a real merge.
 +      ;;
 +?,1,"$1",*)
 +      # If head can reach all the merge then we are up to date.
 +      # but first the most common case of merging one remote.
 +      finish_up_to_date "Already up-to-date."
 +      exit 0
 +      ;;
 +t,1,"$head",*)
 +      # Again the most common case of merging one remote.
 +      echo "Updating $(git rev-parse --short $head)..$(git rev-parse --short $1)"
 +      git update-index --refresh 2>/dev/null
 +      msg="Fast forward"
 +      if test -n "$have_message"
 +      then
 +              msg="$msg (no commit created; -m option ignored)"
 +      fi
 +      new_head=$(git rev-parse --verify "$1^0") &&
 +      git read-tree -v -m -u --exclude-per-directory=.gitignore $head "$new_head" &&
 +      finish "$new_head" "$msg" || exit
 +      dropsave
 +      exit 0
 +      ;;
 +?,1,?*"$LF"?*,*)
 +      # We are not doing octopus and not fast forward.  Need a
 +      # real merge.
 +      ;;
 +?,1,*,)
 +      # We are not doing octopus, not fast forward, and have only
 +      # one common.
 +      git update-index --refresh 2>/dev/null
 +      case "$allow_trivial_merge" in
 +      t)
 +              # See if it is really trivial.
 +              git var GIT_COMMITTER_IDENT >/dev/null || exit
 +              echo "Trying really trivial in-index merge..."
 +              if git read-tree --trivial -m -u -v $common $head "$1" &&
 +                 result_tree=$(git write-tree)
 +              then
 +                      echo "Wonderful."
 +                      result_commit=$(
 +                              printf '%s\n' "$merge_msg" |
 +                              git commit-tree $result_tree -p HEAD -p "$1"
 +                      ) || exit
 +                      finish "$result_commit" "In-index merge"
 +                      dropsave
 +                      exit 0
 +              fi
 +              echo "Nope."
 +      esac
 +      ;;
 +*)
 +      # An octopus.  If we can reach all the remote we are up to date.
 +      up_to_date=t
 +      for remote
 +      do
 +              common_one=$(git merge-base --all $head $remote)
 +              if test "$common_one" != "$remote"
 +              then
 +                      up_to_date=f
 +                      break
 +              fi
 +      done
 +      if test "$up_to_date" = t
 +      then
 +              finish_up_to_date "Already up-to-date. Yeeah!"
 +              exit 0
 +      fi
 +      ;;
 +esac
 +
 +# We are going to make a new commit.
 +git var GIT_COMMITTER_IDENT >/dev/null || exit
 +
 +# At this point, we need a real merge.  No matter what strategy
 +# we use, it would operate on the index, possibly affecting the
 +# working tree, and when resolved cleanly, have the desired tree
 +# in the index -- this means that the index must be in sync with
 +# the $head commit.  The strategies are responsible to ensure this.
 +
 +case "$use_strategies" in
 +?*' '?*)
 +    # Stash away the local changes so that we can try more than one.
 +    savestate
 +    single_strategy=no
 +    ;;
 +*)
 +    rm -f "$GIT_DIR/MERGE_STASH"
 +    single_strategy=yes
 +    ;;
 +esac
 +
 +result_tree= best_cnt=-1 best_strategy= wt_strategy=
 +merge_was_ok=
 +for strategy in $use_strategies
 +do
 +    test "$wt_strategy" = '' || {
 +      echo "Rewinding the tree to pristine..."
 +      restorestate
 +    }
 +    case "$single_strategy" in
 +    no)
 +      echo "Trying merge strategy $strategy..."
 +      ;;
 +    esac
 +
 +    # Remember which strategy left the state in the working tree
 +    wt_strategy=$strategy
 +
 +    git-merge-$strategy $common -- "$head_arg" "$@"
 +    exit=$?
 +    if test "$no_commit" = t && test "$exit" = 0
 +    then
 +        merge_was_ok=t
 +      exit=1 ;# pretend it left conflicts.
 +    fi
 +
 +    test "$exit" = 0 || {
 +
 +      # The backend exits with 1 when conflicts are left to be resolved,
 +      # with 2 when it does not handle the given merge at all.
 +
 +      if test "$exit" -eq 1
 +      then
 +          cnt=`{
 +              git diff-files --name-only
 +              git ls-files --unmerged
 +          } | wc -l`
 +          if test $best_cnt -le 0 -o $cnt -le $best_cnt
 +          then
 +              best_strategy=$strategy
 +              best_cnt=$cnt
 +          fi
 +      fi
 +      continue
 +    }
 +
 +    # Automerge succeeded.
 +    result_tree=$(git write-tree) && break
 +done
 +
 +# If we have a resulting tree, that means the strategy module
 +# auto resolved the merge cleanly.
 +if test '' != "$result_tree"
 +then
 +    if test "$allow_fast_forward" = "t"
 +    then
 +        parents=$(git show-branch --independent "$head" "$@")
 +    else
 +        parents=$(git rev-parse "$head" "$@")
 +    fi
 +    parents=$(echo "$parents" | sed -e 's/^/-p /')
 +    result_commit=$(printf '%s\n' "$merge_msg" | git commit-tree $result_tree $parents) || exit
 +    finish "$result_commit" "Merge made by $wt_strategy."
 +    dropsave
 +    exit 0
 +fi
 +
 +# Pick the result from the best strategy and have the user fix it up.
 +case "$best_strategy" in
 +'')
 +      restorestate
 +      case "$use_strategies" in
 +      ?*' '?*)
 +              echo >&2 "No merge strategy handled the merge."
 +              ;;
 +      *)
 +              echo >&2 "Merge with strategy $use_strategies failed."
 +              ;;
 +      esac
 +      exit 2
 +      ;;
 +"$wt_strategy")
 +      # We already have its result in the working tree.
 +      ;;
 +*)
 +      echo "Rewinding the tree to pristine..."
 +      restorestate
 +      echo "Using the $best_strategy to prepare resolving by hand."
 +      git-merge-$best_strategy $common -- "$head_arg" "$@"
 +      ;;
 +esac
 +
 +if test "$squash" = t
 +then
 +      finish
 +else
 +      for remote
 +      do
 +              echo $remote
 +      done >"$GIT_DIR/MERGE_HEAD"
 +      printf '%s\n' "$merge_msg" >"$GIT_DIR/MERGE_MSG"
 +fi
 +
 +if test "$merge_was_ok" = t
 +then
 +      echo >&2 \
 +      "Automatic merge went well; stopped before committing as requested"
 +      exit 0
 +else
 +      {
 +          echo '
 +Conflicts:
 +'
 +              git ls-files --unmerged |
 +              sed -e 's/^[^   ]*      /       /' |
 +              uniq
 +      } >>"$GIT_DIR/MERGE_MSG"
 +      git rerere
 +      die "Automatic merge failed; fix conflicts and then commit the result."
 +fi

diff --cc git-am.sh
index cc8787b460e601889fd90c5dba2055e9eb85bc22,14578ceb57645502fe9af25c4c1cfd757a852b68..c5b0039d860d6820769488ed8f22272c9a25fdb7
--- 1/git-am.sh
--- 2/git-am.sh
+++ b/git-am.sh
@@@ -5,9 -5,9 +5,9 @@@
  SUBDIRECTORY_OK=Yes
  OPTIONS_KEEPDASHDASH=
  OPTIONS_SPEC="\
- git-am [options] [<mbox>|<Maildir>...]
- git-am [options] --resolved
- git-am [options] --skip
 -git am [options] <mbox>|<Maildir>...
++git am [options] [<mbox>|<Maildir>...]
+ git am [options] --resolved
+ git am [options] --skip
  --
  d,dotest=       (removed -- do not use)
  i,interactive   run interactively

diff --cc git-cvsserver.perl
Simple merge

diff --cc git-quiltimport.sh
Simple merge

diff --cc git-svn.perl
Simple merge

diff --cc help.c
Simple merge

diff --cc index-pack.c
Simple merge

diff --cc t/t4150-am.sh
index 5cbd5ef6798bcef1c011893a4759cac4047dc6b7,476f20b50a402f6843b4588d93d3acfdacf3603b..98ba020d895f05c269fbba2a91c66d874245b145
--- 1/t/t4150-am.sh
--- 2/t/t4150-am.sh
+++ b/t/t4150-am.sh
@@@ -182,8 -182,8 +182,8 @@@ test_expect_success 'am -3 falls back t
  
  test_expect_success 'am pauses on conflict' '
        git checkout lorem2^^ &&
-       ! git am lorem-move.patch &&
+       test_must_fail git am lorem-move.patch &&
 -      test -d .dotest
 +      test -d .git/rebase
  '
  
  test_expect_success 'am --skip works' '
@@@ -195,8 -195,8 +195,8 @@@
  
  test_expect_success 'am --resolved works' '
        git checkout lorem2^^ &&
-       ! git am lorem-move.patch &&
+       test_must_fail git am lorem-move.patch &&
 -      test -d .dotest &&
 +      test -d .git/rebase &&
        echo resolved >>file &&
        git add file &&
        git am --resolved &&
@@@ -212,15 -212,15 +212,15 @@@ test_expect_success 'am takes patches f
  '
  
  test_expect_success 'am fails on mail without patch' '
-       ! git am <failmail &&
+       test_must_fail git am <failmail &&
 -      rm -r .dotest/
 +      rm -r .git/rebase/
  '
  
  test_expect_success 'am fails on empty patch' '
        echo "---" >>failmail &&
-       ! git am <failmail &&
+       test_must_fail git am <failmail &&
        git am --skip &&
 -      ! test -d .dotest
 +      ! test -d .git/rebase
  '
  
  test_expect_success 'am works from stdin in subdirectory' '

diff --cc t/t4200-rerere.sh
index b5a4202998f51cd282ae46c7caec6e615ee47e3f,746d61f8451d42b8a62d2e7afb9bde5256ff592b..b68ab11f2915789cd04ac6bd43363aeab2079198
--- 1/t/t4200-rerere.sh
--- 2/t/t4200-rerere.sh
+++ b/t/t4200-rerere.sh
@@@ -54,19 -50,19 +54,19 @@@ test_expect_success 'conflicting merge
        git reset --hard &&
        mkdir .git/rr-cache &&
        git config --unset rerere.enabled &&
-       ! git merge first
+       test_must_fail git merge first
  '
  
 -sha1=$(sed -e 's/     .*//' .git/rr-cache/MERGE_RR)
 +sha1=$(sed -e 's/     .*//' .git/MERGE_RR)
  rr=.git/rr-cache/$sha1
 -test_expect_success 'recorded preimage' "grep ======= $rr/preimage"
 +test_expect_success 'recorded preimage' "grep ^=======$ $rr/preimage"
  
  test_expect_success 'rerere.enabled works, too' '
        rm -rf .git/rr-cache &&
        git config rerere.enabled true &&
        git reset --hard &&
-       ! git merge first &&
+       test_must_fail git merge first &&
 -      grep ======= $rr/preimage
 +      grep ^=======$ $rr/preimage
  '
  
  test_expect_success 'no postimage or thisimage yet' \
@@@ -189,8 -175,8 +189,8 @@@ test_expect_success 'file2 added differ
        echo Bello > file2 &&
        git add file2 &&
        git commit -m version2 &&
-       ! git merge fourth &&
+       test_must_fail git merge fourth &&
 -      sha1=$(sed -e "s/       .*//" .git/rr-cache/MERGE_RR) &&
 +      sha1=$(sed -e "s/       .*//" .git/MERGE_RR) &&
        rr=.git/rr-cache/$sha1 &&
        echo Cello > file2 &&
        git add file2 &&

diff --cc t/t7600-merge.sh
Simple merge

diff --cc t/t9106-git-svn-commit-diff-clobber.sh
Simple merge