rebase: avoid redundant merges (issue1301)

hgext/rebase.py

@@ -1,391 +1,421
 # rebase.py - rebasing feature for mercurial
 #
 # Copyright 2008 Stefano Tortarolo <stefano.tortarolo at gmail dot com>
 #
 # This software may be used and distributed according to the terms
 # of the GNU General Public License, incorporated herein by reference.
 
 '''move sets of revisions to a different ancestor
 
 This extension lets you rebase changesets in an existing Mercurial repository.
 
 For more information:
 http://www.selenic.com/mercurial/wiki/index.cgi/RebaseProject
 '''
 
-from mercurial import util, repair, merge, cmdutil, dispatch, commands, extensions
+from mercurial import util, repair, merge, cmdutil, dispatch, commands
+from mercurial import extensions, ancestor
 from mercurial.commands import templateopts
 from mercurial.node import nullrev
 from mercurial.i18n import _
 import os, errno
 
+def rebasemerge(repo, rev, first=False):
+    'return the correct ancestor'
+    oldancestor = ancestor.ancestor
+    
+    def newancestor(a, b, pfunc):
+        ancestor.ancestor = oldancestor
+        anc = ancestor.ancestor(a, b, pfunc)
+        if b == rev:
+            return repo[rev].parents()[0].rev()
+        return ancestor.ancestor(a, b, pfunc)
+
+    if not first:
+        ancestor.ancestor = newancestor
+    else:
+        repo.ui.debug(_("First revision, do not change ancestor\n"))
+    stats = merge.update(repo, rev, True, True, False)
+    return stats
+
 def rebase(ui, repo, **opts):
     """move changeset (and descendants) to a different branch
 
     Rebase uses repeated merging to graft changesets from one part of history
     onto another. This can be useful for linearizing local changes relative to
     a master development tree.
 
     If a rebase is interrupted to manually resolve a merge, it can be continued
     with --continue or aborted with --abort.
     """
     originalwd = target = source = None
     external = nullrev
     state = skipped = {}
 
     lock = wlock = None
     try:
         lock = repo.lock()
         wlock = repo.wlock()
 
         # Validate input and define rebasing points
         destf = opts.get('dest', None)
         srcf = opts.get('source', None)
         basef = opts.get('base', None)
         contf = opts.get('continue')
         abortf = opts.get('abort')
         collapsef = opts.get('collapse', False)
         if contf or abortf:
             if contf and abortf:
                 raise dispatch.ParseError('rebase',
                                     _('cannot use both abort and continue'))
             if collapsef:
                 raise dispatch.ParseError('rebase',
                         _('cannot use collapse with continue or abort'))
 
             if (srcf or basef or destf):
                 raise dispatch.ParseError('rebase',
                     _('abort and continue do not allow specifying revisions'))
 
             originalwd, target, state, collapsef, external = restorestatus(repo)
             if abortf:
                 abort(repo, originalwd, target, state)
                 return
         else:
             if srcf and basef:
                 raise dispatch.ParseError('rebase', _('cannot specify both a '
                                                         'revision and a base'))
             cmdutil.bail_if_changed(repo)
             result = buildstate(repo, destf, srcf, basef, collapsef)
             if result:
                 originalwd, target, state, external = result
             else: # Empty state built, nothing to rebase
                 repo.ui.status(_('nothing to rebase\n'))
                 return
 
         # Rebase
         targetancestors = list(repo.changelog.ancestors(target))
         targetancestors.append(target)
 
         for rev in util.sort(state):
             if state[rev] == -1:
                 storestatus(repo, originalwd, target, state, collapsef,
                                                                 external)
                 rebasenode(repo, rev, target, state, skipped, targetancestors,
                                                                 collapsef)
         ui.note(_('rebase merging completed\n'))
 
         if collapsef:
             p1, p2 = defineparents(repo, min(state), target,
                                                         state, targetancestors)
             concludenode(repo, rev, p1, external, state, collapsef,
                                                 last=True, skipped=skipped)
 
         if 'qtip' in repo.tags():
             updatemq(repo, state, skipped, **opts)
 
         if not opts.get('keep'):
             # Remove no more useful revisions
             if (util.set(repo.changelog.descendants(min(state)))
                                                     - util.set(state.keys())):
                 ui.warn(_("warning: new changesets detected on source branch, "
                                                         "not stripping\n"))
             else:
                 repair.strip(repo.ui, repo, repo[min(state)].node(), "strip")
 
         clearstatus(repo)
         ui.status(_("rebase completed\n"))
         if os.path.exists(repo.sjoin('undo')):
             util.unlink(repo.sjoin('undo'))
         if skipped:
             ui.note(_("%d revisions have been skipped\n") % len(skipped))
     finally:
         del lock, wlock
 
 def concludenode(repo, rev, p1, p2, state, collapse, last=False, skipped={}):
     """Skip commit if collapsing has been required and rev is not the last
     revision, commit otherwise
     """
-    repo.dirstate.setparents(repo[p1].node(), repo[p2].node())
+    repo.ui.debug(_(" set parents\n"))
+    if collapse and not last:
+        repo.dirstate.setparents(repo[p1].node())
+        return None
 
-    if collapse and not last:
-        return None
+    repo.dirstate.setparents(repo[p1].node(), repo[p2].node())
 
     # Commit, record the old nodeid
     m, a, r = repo.status()[:3]
     newrev = nullrev
     try:
         if last:
             commitmsg = 'Collapsed revision'
             for rebased in state:
                 if rebased not in skipped:
                     commitmsg += '\n* %s' % repo[rebased].description()
             commitmsg = repo.ui.edit(commitmsg, repo.ui.username())
         else:
             commitmsg = repo[rev].description()
         # Commit might fail if unresolved files exist
         newrev = repo.commit(m+a+r,
                             text=commitmsg,
                             user=repo[rev].user(),
                             date=repo[rev].date(),
                             extra={'rebase_source': repo[rev].hex()})
         return newrev
     except util.Abort:
         # Invalidate the previous setparents
         repo.dirstate.invalidate()
         raise
 
 def rebasenode(repo, rev, target, state, skipped, targetancestors, collapse):
     'Rebase a single revision'
-    repo.ui.debug(_("rebasing %d:%s\n") % (rev, repo[rev].node()))
+    repo.ui.debug(_("rebasing %d:%s\n") % (rev, repo[rev]))
 
     p1, p2 = defineparents(repo, rev, target, state, targetancestors)
 
+    repo.ui.debug(_(" future parents are %d and %d\n") % (repo[p1].rev(), 
+                                                            repo[p2].rev()))
+    
     # Merge phase
     if len(repo.parents()) != 2:
         # Update to target and merge it with local
-        merge.update(repo, p1, False, True, False)
+        if repo['.'].rev() != repo[p1].rev():
+            repo.ui.debug(_(" update to %d:%s\n") % (repo[p1].rev(), repo[p1]))
+            merge.update(repo, p1, False, True, False)
+        else:
+            repo.ui.debug(_(" already in target\n"))
         repo.dirstate.write()
-        stats = merge.update(repo, rev, True, False, False)
+        repo.ui.debug(_(" merge against %d:%s\n") % (repo[rev].rev(), repo[rev]))
+        first = repo[rev].rev() == repo[min(state)].rev()
+        stats = rebasemerge(repo, rev, first)
 
         if stats[3] > 0:
             raise util.Abort(_('fix unresolved conflicts with hg resolve then '
                                                 'run hg rebase --continue'))
     else: # we have an interrupted rebase
         repo.ui.debug(_('resuming interrupted rebase\n'))
 
 
     newrev = concludenode(repo, rev, p1, p2, state, collapse)
 
     # Update the state
     if newrev is not None:
         state[rev] = repo[newrev].rev()
     else:
         if not collapse:
             repo.ui.note(_('no changes, revision %d skipped\n') % rev)
             repo.ui.debug(_('next revision set to %s\n') % p1)
             skipped[rev] = True
         state[rev] = p1
 
 def defineparents(repo, rev, target, state, targetancestors):
     'Return the new parent relationship of the revision that will be rebased'
     parents = repo[rev].parents()
     p1 = p2 = nullrev
 
     P1n = parents[0].rev()
     if P1n in targetancestors:
         p1 = target
     elif P1n in state:
         p1 = state[P1n]
     else: # P1n external
         p1 = target
         p2 = P1n
 
     if len(parents) == 2 and parents[1].rev() not in targetancestors:
         P2n = parents[1].rev()
         # interesting second parent
         if P2n in state:
             if p1 == target: # P1n in targetancestors or external
                 p1 = state[P2n]
             else:
                 p2 = state[P2n]
         else: # P2n external
             if p2 != nullrev: # P1n external too => rev is a merged revision
                 raise util.Abort(_('cannot use revision %d as base, result '
                         'would have 3 parents') % rev)
             p2 = P2n
     return p1, p2
 
 def updatemq(repo, state, skipped, **opts):
     'Update rebased mq patches - finalize and then import them'
     mqrebase = {}
     for p in repo.mq.applied:
         if repo[p.rev].rev() in state:
             repo.ui.debug(_('revision %d is an mq patch (%s), finalize it.\n') %
                                         (repo[p.rev].rev(), p.name))
             mqrebase[repo[p.rev].rev()] = p.name
 
     if mqrebase:
         repo.mq.finish(repo, mqrebase.keys())
 
         # We must start import from the newest revision
         mq = mqrebase.keys()
         mq.sort()
         mq.reverse()
         for rev in mq:
             if rev not in skipped:
                 repo.ui.debug(_('import mq patch %d (%s)\n')
                               % (state[rev], mqrebase[rev]))
                 repo.mq.qimport(repo, (), patchname=mqrebase[rev],
                             git=opts.get('git', False),rev=[str(state[rev])])
         repo.mq.save_dirty()
 
 def storestatus(repo, originalwd, target, state, collapse, external):
     'Store the current status to allow recovery'
     f = repo.opener("rebasestate", "w")
     f.write(repo[originalwd].hex() + '\n')
     f.write(repo[target].hex() + '\n')
     f.write(repo[external].hex() + '\n')
     f.write('%d\n' % int(collapse))
     for d, v in state.items():
         oldrev = repo[d].hex()
         newrev = repo[v].hex()
         f.write("%s:%s\n" % (oldrev, newrev))
     f.close()
     repo.ui.debug(_('rebase status stored\n'))
 
 def clearstatus(repo):
     'Remove the status files'
     if os.path.exists(repo.join("rebasestate")):
         util.unlink(repo.join("rebasestate"))
 
 def restorestatus(repo):
     'Restore a previously stored status'
     try:
         target = None
         collapse = False
         external = nullrev
         state = {}
         f = repo.opener("rebasestate")
         for i, l in enumerate(f.read().splitlines()):
             if i == 0:
                 originalwd = repo[l].rev()
             elif i == 1:
                 target = repo[l].rev()
             elif i == 2:
                 external = repo[l].rev()
             elif i == 3:
                 collapse = bool(int(l))
             else:
                 oldrev, newrev = l.split(':')
                 state[repo[oldrev].rev()] = repo[newrev].rev()
         repo.ui.debug(_('rebase status resumed\n'))
         return originalwd, target, state, collapse, external
     except IOError, err:
         if err.errno != errno.ENOENT:
             raise
         raise util.Abort(_('no rebase in progress'))
 
 def abort(repo, originalwd, target, state):
     'Restore the repository to its original state'
     if util.set(repo.changelog.descendants(target)) - util.set(state.values()):
         repo.ui.warn(_("warning: new changesets detected on target branch, "
                                                     "not stripping\n"))
     else:
         # Strip from the first rebased revision
         merge.update(repo, repo[originalwd].rev(), False, True, False)
         rebased = filter(lambda x: x > -1, state.values())
         if rebased:
             strippoint = min(rebased)
             repair.strip(repo.ui, repo, repo[strippoint].node(), "strip")
         clearstatus(repo)
         repo.ui.status(_('rebase aborted\n'))
 
 def buildstate(repo, dest, src, base, collapse):
     'Define which revisions are going to be rebased and where'
     state = {}
     targetancestors = util.set()
 
     if not dest:
          # Destination defaults to the latest revision in the current branch
         branch = repo[None].branch()
         dest = repo[branch].rev()
     else:
         if 'qtip' in repo.tags() and (repo[dest].hex() in
                                 [s.rev for s in repo.mq.applied]):
             raise util.Abort(_('cannot rebase onto an applied mq patch'))
         dest = repo[dest].rev()
 
     if src:
         commonbase = repo[src].ancestor(repo[dest])
         if commonbase == repo[src]:
             raise util.Abort(_('cannot rebase an ancestor'))
         if commonbase == repo[dest]:
             raise util.Abort(_('cannot rebase a descendant'))
         source = repo[src].rev()
     else:
         if base:
             cwd = repo[base].rev()
         else:
             cwd = repo['.'].rev()
 
         if cwd == dest:
             repo.ui.debug(_('already working on current\n'))
             return None
 
         targetancestors = util.set(repo.changelog.ancestors(dest))
         if cwd in targetancestors:
             repo.ui.debug(_('already working on the current branch\n'))
             return None
 
         cwdancestors = util.set(repo.changelog.ancestors(cwd))
         cwdancestors.add(cwd)
         rebasingbranch = cwdancestors - targetancestors
         source = min(rebasingbranch)
 
     repo.ui.debug(_('rebase onto %d starting from %d\n') % (dest, source))
     state = dict.fromkeys(repo.changelog.descendants(source), nullrev)
     external = nullrev
     if collapse:
         if not targetancestors:
             targetancestors = util.set(repo.changelog.ancestors(dest))
         for rev in state:
             # Check externals and fail if there are more than one
             for p in repo[rev].parents():
                 if (p.rev() not in state and p.rev() != source
                             and p.rev() not in targetancestors):
                     if external != nullrev:
                         raise util.Abort(_('unable to collapse, there is more '
                                 'than one external parent'))
                     external = p.rev()
 
     state[source] = nullrev
     return repo['.'].rev(), repo[dest].rev(), state, external
 
 def pullrebase(orig, ui, repo, *args, **opts):
     'Call rebase after pull if the latter has been invoked with --rebase'
     if opts.get('rebase'):
         if opts.get('update'):
             raise util.Abort(_('--update and --rebase are not compatible'))
 
         cmdutil.bail_if_changed(repo)
         revsprepull = len(repo)
         orig(ui, repo, *args, **opts)
         revspostpull = len(repo)
         if revspostpull > revsprepull:
             rebase(ui, repo, **opts)
     else:
         orig(ui, repo, *args, **opts)
 
 def uisetup(ui):
     'Replace pull with a decorator to provide --rebase option'
     entry = extensions.wrapcommand(commands.table, 'pull', pullrebase)
     entry[1].append(('', 'rebase', None,
                      _("rebase working directory to branch head"))
 )
 
 cmdtable = {
 "rebase":
         (rebase,
         [
         ('', 'keep', False, _('keep original revisions')),
         ('s', 'source', '', _('rebase from a given revision')),
         ('b', 'base', '', _('rebase from the base of a given revision')),
         ('d', 'dest', '', _('rebase onto a given revision')),
         ('', 'collapse', False, _('collapse the rebased revisions')),
         ('c', 'continue', False, _('continue an interrupted rebase')),
         ('a', 'abort', False, _('abort an interrupted rebase')),] +
          templateopts,
         _('hg rebase [-s rev | -b rev] [-d rev] [--collapse] | [-c] | [-a] | '
                                                                 '[--keep]')),
 }

tests/test-rebase-collapse

@@ -1,91 +1,180
 #!/bin/sh
 
 echo "[extensions]" >> $HGRCPATH
 echo "graphlog=" >> $HGRCPATH
 echo "rebase=" >> $HGRCPATH
 
 BASE=`pwd`
 
 addcommit () {
     echo $1 > $1
     hg add $1
     hg commit -d "${2} 0" -u test -m $1
 }
 
 commit () {
     hg commit -d "${2} 0" -u test -m $1
 }
 
 createrepo () {
     cd $BASE
     rm -rf a
     hg init a
     cd a
     addcommit "A" 0
     addcommit "B" 1
     addcommit "C" 2
     addcommit "D" 3
 
     hg update -C 0
     addcommit "E" 4
 
     hg update -C 0
     addcommit "F" 5
 
     hg merge -r 4
     commit "G" 6
 
     hg update -C 5
     addcommit "H" 7
 }
 
 createrepo > /dev/null 2>&1
 hg glog  --template '{rev}: {desc}\n'
-echo '% Rebasing'
+echo '% Rebasing B onto H'
 hg up -C 3
 hg rebase --collapse 2>&1 | sed 's/\(saving bundle to \).*/\1/'
 hg glog  --template '{rev}: {desc}\n'
+echo "Expected A, B, C, D, F, H"
+hg manifest
 
 createrepo > /dev/null 2>&1
-echo '% Rebasing'
+echo
+echo '% Rebasing G onto H'
 hg rebase --base 6 --collapse 2>&1 | sed 's/\(saving bundle to \).*/\1/'
 hg glog  --template '{rev}: {desc}\n'
+echo "Expected A, E, F, H"
+hg manifest
 
 createrepocomplex () {
     cd $BASE
     rm -rf a
     hg init a
     cd a
     addcommit "A" 0
     addcommit "B" 1
 
     hg up 0
     addcommit "C" 2
     hg merge
     commit "D" 3
 
     hg up 1
     addcommit "E" 4
 
     addcommit "F" 5
 
     hg merge
     commit "G" 6
 
     hg up 0
     addcommit "H" 7
 }
 
+echo
 createrepocomplex > /dev/null 2>&1
 hg glog  --template '{rev}: {desc}\n'
 
 echo
 echo '% Rebase and collapse - more than one external (fail)'
 hg rebase -s 2 --collapse
 
 echo
-echo '% Rebase and collapse'
+echo '% Rebase and collapse - E onto H'
 hg rebase -s 4 --collapse 2>&1 | sed 's/\(saving bundle to \).*/\1/'
 hg glog  --template '{rev}: {desc}\n'
+echo "Expected A, B, C, E, F, H"
+hg manifest
 
+createrepocomplex () {
+    cd $BASE
+    rm -rf a
+    hg init a
+    cd a
+    addcommit "A" 0
+    addcommit "B" 1
+
+    hg up 0
+    addcommit "C" 2
+    hg merge
+    commit "D" 3
+
+    hg up 1
+    addcommit "E" 4
+    
+    echo "F" > E
+    commit "F" 5
+
+    addcommit "G" 6
+
+    hg merge
+    commit "H" 7
+
+    hg up 0
+    addcommit "I" 8
+}
+
+echo
+createrepocomplex > /dev/null 2>&1
+hg glog  --template '{rev}: {desc}\n'
+
+echo
+echo '% Rebase and collapse - E onto I'
+hg rebase -s 4 --collapse 
+
+echo '% Fix conflict and continue'
+echo 'Resolved merge' > E
+hg resolve -m E
+hg rebase -c 2>&1 | sed 's/\(saving bundle to \).*/\1/'
+
+hg glog  --template '{rev}: {desc}\n'
+
+echo "Expected A, B, C, E, G, I"
+hg manifest
+
+echo 'Cat E:'
+cat E
+
+createrepocomplex () {
+    cd $BASE
+    rm -rf a
+    hg init a
+    cd a
+    addcommit "A" 0
+    addcommit "B" 1
+
+    addcommit "C" 2
+    hg up 1
+
+    addcommit "D" 3
+    
+    hg merge
+    commit "E" 4
+
+    hg up 0
+    addcommit "F" 5
+}
+
+echo
+createrepocomplex > /dev/null 2>&1
+hg glog  --template '{rev}: {desc}\n'
+
+echo
+echo '% Rebase and collapse - B onto F'
+hg rebase -s 1 --collapse 2>&1 | sed 's/\(saving bundle to \).*/\1/'
+
+hg glog  --template '{rev}: {desc}\n'
+
+echo "Expected A, B, C, D, F"
+hg manifest
 exit 0

tests/test-rebase-collapse.out

@@ -1,104 +1,219
 @  7: H
 |
 | o  6: G
 |/|
 o |  5: F
 | |
 | o  4: E
 |/
 | o  3: D
 | |
 | o  2: C
 | |
 | o  1: B
 |/
 o  0: A
 
-% Rebasing
+% Rebasing B onto H
 3 files updated, 0 files merged, 2 files removed, 0 files unresolved
 saving bundle to 
 adding branch
 adding changesets
 adding manifests
 adding file changes
 added 5 changesets with 6 changes to 6 files (+1 heads)
 rebase completed
 @  5: Collapsed revision
 |  * B
 |  * C
 |  * D
 o  4: H
 |
 | o  3: G
 |/|
 o |  2: F
 | |
 | o  1: E
 |/
 o  0: A
 
-% Rebasing
+Expected A, B, C, D, F, H
+A
+B
+C
+D
+F
+H
+
+% Rebasing G onto H
 saving bundle to 
 adding branch
 adding changesets
 adding manifests
 adding file changes
 added 3 changesets with 3 changes to 3 files (+1 heads)
 rebase completed
 @  6: Collapsed revision
 |  * E
 |  * G
 o  5: H
 |
 o  4: F
 |
 | o  3: D
 | |
 | o  2: C
 | |
 | o  1: B
 |/
 o  0: A
 
+Expected A, E, F, H
+A
+E
+F
+H
+
 @  7: H
 |
 | o    6: G
 | |\
 | | o  5: F
 | | |
 | | o  4: E
 | | |
 | o |  3: D
 | |\|
 | o |  2: C
 |/ /
 | o  1: B
 |/
 o  0: A
 
 
 % Rebase and collapse - more than one external (fail)
 abort: unable to collapse, there is more than one external parent
 
-% Rebase and collapse
+% Rebase and collapse - E onto H
 saving bundle to 
 adding branch
 adding changesets
 adding manifests
 adding file changes
 added 2 changesets with 3 changes to 3 files
 rebase completed
 @    5: Collapsed revision
 |\   * E
 | |  * F
 | |  * G
 | o  4: H
 | |
 o |    3: D
 |\ \
 | o |  2: C
 | |/
 o /  1: B
 |/
 o  0: A
 
+Expected A, B, C, E, F, H
+A
+B
+C
+E
+F
+H
+
+@  8: I
+|
+| o    7: H
+| |\
+| | o  6: G
+| | |
+| | o  5: F
+| | |
+| | o  4: E
+| | |
+| o |  3: D
+| |\|
+| o |  2: C
+|/ /
+| o  1: B
+|/
+o  0: A
+
+
+% Rebase and collapse - E onto I
+merging E
+warning: conflicts during merge.
+merging E failed!
+abort: fix unresolved conflicts with hg resolve then run hg rebase --continue
+% Fix conflict and continue
+saving bundle to 
+adding branch
+adding changesets
+adding manifests
+adding file changes
+added 2 changesets with 3 changes to 3 files
+rebase completed
+@    5: Collapsed revision
+|\   * E
+| |  * F
+| |  * G
+| |  * H
+| o  4: I
+| |
+o |    3: D
+|\ \
+| o |  2: C
+| |/
+o /  1: B
+|/
+o  0: A
+
+Expected A, B, C, E, G, I
+A
+B
+C
+E
+G
+I
+Cat E:
+Resolved merge
+
+@  5: F
+|
+| o    4: E
+| |\
+| | o  3: D
+| | |
+| o |  2: C
+| |/
+| o  1: B
+|/
+o  0: A
+
+
+% Rebase and collapse - B onto F
+saving bundle to 
+adding branch
+adding changesets
+adding manifests
+adding file changes
+added 2 changesets with 4 changes to 4 files
+rebase completed
+@  2: Collapsed revision
+|  * B
+|  * C
+|  * D
+|  * E
+o  1: F
+|
+o  0: A
+
+Expected A, B, C, D, F
+A
+B
+C
+D
+F

tests/test-rebase-conflicts

@@ -1,55 +1,78
 #!/bin/sh
 
 echo "[extensions]" >> $HGRCPATH
 echo "graphlog=" >> $HGRCPATH
 echo "rebase=" >> $HGRCPATH
 
 cleanoutput () {
     sed -e 's/\(Rebase status stored to\).*/\1/'  \
         -e 's/\(Rebase status restored from\).*/\1/' \
         -e 's/\(saving bundle to \).*/\1/'
 }
 
 hg init a
 cd a
 echo 'c1' >common
 hg add common
 hg commit -d '0 0' -u test -m "C1"
 
 echo 'c2' >>common
 hg commit -d '1 0' -u test -m "C2"
 
 echo 'c3' >>common
 hg commit -d '2 0' -u test -m "C3"
 
 hg update -C 1
 echo 'l1' >>extra
 hg add extra
 hg commit -d '3 0' -u test -m "L1"
 
 sed -e 's/c2/l2/' common > common.new
 mv common.new common
 hg commit -d '4 0' -u test -m "L2"
 
+echo 'l3' >> extra2
+hg add extra2
+hg commit -d '5 0' -u test -m "L3"
+
 hg glog  --template '{rev}: {desc}\n'
 
 echo
 echo '% Try to call --continue'
 hg rebase --continue
 
 echo
 echo '% Conflicting rebase'
 hg rebase -s 3 -d 2
 
 echo
 echo '% Try to continue without solving the conflict'
 hg rebase --continue 
 
 echo
 echo '% Conclude rebase'
-echo 'solved merge' >common
+echo 'resolved merge' >common
 hg resolve -m common
 hg rebase --continue 2>&1 | cleanoutput
 
+hg glog  --template '{rev}: {desc}\n'
 
-hg glog  --template '{rev}: {desc}\n'
+echo
+echo '% Check correctness'
+echo '  - Rev. 0'
+hg cat -r 0 common
+
+echo '  - Rev. 1'
+hg cat -r 1 common
+
+echo '  - Rev. 2'
+hg cat -r 2 common
+
+echo '  - Rev. 3'
+hg cat -r 3 common
+
+echo '  - Rev. 4'
+hg cat -r 4 common
+
+echo '  - Rev. 5'
+hg cat -r 5 common

tests/test-rebase-conflicts.out

@@ -1,43 +1,66
 1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 created new head
-@  4: L2
+@  5: L3
+|
+o  4: L2
 |
 o  3: L1
 |
 | o  2: C3
 |/
 o  1: C2
 |
 o  0: C1
 
 
 % Try to call --continue
 abort: no rebase in progress
 
 % Conflicting rebase
 merging common
 warning: conflicts during merge.
 merging common failed!
 abort: fix unresolved conflicts with hg resolve then run hg rebase --continue
 
 % Try to continue without solving the conflict
 abort: unresolved merge conflicts (see hg resolve)
 
 % Conclude rebase
 saving bundle to 
 adding branch
 adding changesets
 adding manifests
 adding file changes
-added 2 changesets with 2 changes to 2 files
+added 3 changesets with 3 changes to 3 files
 rebase completed
-@  4: L2
+@  5: L3
+|
+o  4: L2
 |
 o  3: L1
 |
 o  2: C3
 |
 o  1: C2
 |
 o  0: C1
 
+
+% Check correctness
+  - Rev. 0
+c1
+  - Rev. 1
+c1
+c2
+  - Rev. 2
+c1
+c2
+c3
+  - Rev. 3
+c1
+c2
+c3
+  - Rev. 4
+resolved merge
+  - Rev. 5
+resolved merge