This is an archive of the discontinued Mercurial Phabricator instance.

Differential D9167

errors: introduce InputError and use it from commands and cmdutil
ClosedPublic

Authored by martinvonz on Oct 7 2020, 2:10 AM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHG8d72e29ad1e0: errors: introduce InputError and use it from commands and cmdutil
Summary

This patch introduces a InputError class and replaces many uses of
error.Abort by it in commands and cmdutil. This is a part of
https://www.mercurial-scm.org/wiki/ErrorCategoriesPlan. There will
later be a different class for state errors (to raise e.g. when
there's an unfinished operation). It's not always clear when one
should report an input error and when it should be a state error. We
can always adjust later if I got something wrong in this patch (but
feel free to point out any you notice now).

Diff Detail

Repository
rHG Mercurial
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

Event Timeline

martinvonz created this revision.Oct 7 2020, 2:10 AM
martinvonz updated this revision to Diff 23073.Oct 7 2020, 2:17 AM
pulkit added a subscriber: pulkit.Oct 7 2020, 7:53 AM

The plan page mentions InputError instead of UserError which I think is more fine-grained and better suited in some cases. Reading the relevant email thread titled Proposal for cleaning up error reporting, it seems that we have not finalized these names.

martinvonz added a comment.Oct 7 2020, 11:12 AM
In D9167#137680, @pulkit wrote:

The plan page mentions InputError instead of UserError which I think is more fine-grained and better suited in some cases.

I felt like InputError made it sounds like it was specifically for errors in input when hg was asking for input, not including inputs given on the command line. I'm fine with using the proposed InputError, though. I'll wait a bit to hear other people's opinions first.

Reading the relevant email thread titled Proposal for cleaning up error reporting, it seems that we have not finalized these names.

Sorry, I clearly should have reviewed that thread first. I thought the thread ended with Augie's message about forcing opinions from non-Googlers by sending a patch. I also remember saying that I was skeptical about changing error statuses. Apparently both those memories were incorrect :) However, the thread I reviewed just now doesn't seem to talk about the names at all. Were there several threads?

martinvonz retitled this revision from errors: introduce UserError and use it from commands and cmdutil to errors: introduce InputError and use it from commands and cmdutil.Oct 12 2020, 2:29 PM
martinvonz edited the summary of this revision. (Show Details)
martinvonz updated this revision to Diff 23177.
martinvonz added a comment.Oct 12 2020, 2:30 PM

I've renamed the exception to InputError to unblock this. Let me know if there was anything else blocking. I wasn't sure if you wanted to see more discussion about the name on thread before we decide.

pulkit added a comment.Oct 14 2020, 3:45 AM
In D9167#138132, @martinvonz wrote:

I've renamed the exception to InputError to unblock this. Let me know if there was anything else blocking. I wasn't sure if you wanted to see more discussion about the name on thread before we decide.

Thank you. I am thinking to get back to this (queue this maybe) once we cut the upcoming RC (after 3 days). I agree that there are no BC changes but doing this will make things easier as then we can try to have all these changes in one release. Doesn't yield much but sounds like a good idea to me. Let me know if you prefer it to be queued before.

martinvonz added a comment.Oct 14 2020, 11:33 AM
In D9167#138287, @pulkit wrote:
In D9167#138132, @martinvonz wrote:

I've renamed the exception to InputError to unblock this. Let me know if there was anything else blocking. I wasn't sure if you wanted to see more discussion about the name on thread before we decide.

Thank you. I am thinking to get back to this (queue this maybe) once we cut the upcoming RC (after 3 days). I agree that there are no BC changes but doing this will make things easier as then we can try to have all these changes in one release. Doesn't yield much but sounds like a good idea to me. Let me know if you prefer it to be queued before.

That sounds reasonable. There's no rush with this from our side. Thanks.

martinvonz planned changes to this revision.Oct 22 2020, 11:37 AM

Actually, let me insert a patch before this one that adds the config that gives us more detailed exit codes. That way we can see the impact on tests in this patch.

martinvonz updated this revision to Diff 23370.Oct 29 2020, 4:39 PM
martinvonz updated this revision to Diff 23417.Nov 3 2020, 11:45 PM
martinvonz added a commit: rHG8d72e29ad1e0: errors: introduce InputError and use it from commands and cmdutil.Nov 9 2020, 7:37 PM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHG8d72e29ad1e0: errors: introduce InputError and use it from commands and cmdutil (authored by martinvonz). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mmercurial/cmdutil.py (82 lines)
Mmercurial/commands.py (206 lines)
Mmercurial/error.py (7 lines)
Mmercurial/scmutil.py (2 lines)
Mtests/test-add.t (2 lines)
Mtests/test-amend.t (6 lines)
Mtests/test-archive.t (2 lines)
Mtests/test-backout.t (16 lines)
Mtests/test-bisect.t (30 lines)
Mtests/test-bookmarks-pushpull.t (6 lines)
Mtests/test-bookmarks.t (22 lines)
Mtests/test-branch-change.t (12 lines)
Mtests/test-branches.t (10 lines)
Mtests/test-bundle-r.t (4 lines)
Mtests/test-bundle-type.t (8 lines)
Mtests/test-bundle.t (6 lines)
Mtests/test-clone-update-order.t (2 lines)
Mtests/test-clone.t (2 lines)
Mtests/test-commandserver.t (2 lines)
Mtests/test-commit-amend.t (8 lines)
Mtests/test-commit-interactive.t (14 lines)
Mtests/test-commit-unresolved.t (6 lines)
Mtests/test-commit.t (14 lines)
Mtests/test-config.t (2 lines)
Mtests/test-confused-revert.t (2 lines)
Mtests/test-copy.t (8 lines)
Mtests/test-dirstate-backup.t (2 lines)
Mtests/test-export.t (2 lines)
Mtests/test-fix-topology.t (2 lines)
Mtests/test-graft-interrupted.t (22 lines)
Mtests/test-graft.t (10 lines)
Mtests/test-identify.t (8 lines)
Mtests/test-import-bypass.t (10 lines)
Mtests/test-import.t (10 lines)
Mtests/test-keyword.t (4 lines)
Mtests/test-largefiles.t (2 lines)
Mtests/test-log-linerange.t (4 lines)
Mtests/test-manifest.t (2 lines)
Mtests/test-merge-default.t (4 lines)
Mtests/test-merge2.t (2 lines)
Mtests/test-merge9.t (2 lines)
Mtests/test-missing-capability.t (2 lines)
Mtests/test-mq-qrefresh-interactive.t (6 lines)
Mtests/test-newbranch.t (6 lines)
Mtests/test-parents.t (4 lines)
Mtests/test-push-warn.t (2 lines)
Mtests/test-push.t (4 lines)
Mtests/test-rebase-inmemory.t (10 lines)
Mtests/test-rebase-obsolete.t (6 lines)
Mtests/test-rebase-parameters.t (10 lines)
Mtests/test-record.t (2 lines)
Mtests/test-remotefilelog-prefetch.t (2 lines)
Mtests/test-rename-after-merge.t (4 lines)
Mtests/test-rename-rev.t (8 lines)
Mtests/test-rename.t (4 lines)
Mtests/test-resolve.t (8 lines)
Mtests/test-revert.t (4 lines)
Mtests/test-share-safe.t (2 lines)
Mtests/test-shelve.t (20 lines)
Mtests/test-simple-update.t (4 lines)
Mtests/test-status-terse.t (4 lines)
Mtests/test-subrepo-recursion.t (2 lines)
Mtests/test-tag.t (26 lines)
Mtests/test-tags.t (10 lines)
Mtests/test-transplant.t (4 lines)
Mtests/test-uncommit.t (4 lines)
Mtests/test-update-dest.t (4 lines)

Diff 23449

mercurial/cmdutil.py

def to_display(name): def to_display(name):
return pycompat.sysbytes(name).replace(b'_', b'-') return pycompat.sysbytes(name).replace(b'_', b'-')
previous = None previous = None
for x in args: for x in args:
if opts.get(x): if opts.get(x):
if previous: if previous:
raise error.Abort( raise error.InputError(
_(b'cannot specify both --%s and --%s') _(b'cannot specify both --%s and --%s')
% (to_display(previous), to_display(x)) % (to_display(previous), to_display(x))
) )
previous = x previous = x
return previous return previous
def check_incompatible_arguments(opts, first, others): def check_incompatible_arguments(opts, first, others):
def checknotesize(ui, opts): def checknotesize(ui, opts):
""" make sure note is of valid format """ """ make sure note is of valid format """
note = opts.get(b'note') note = opts.get(b'note')
if not note: if not note:
return return
if len(note) > 255: if len(note) > 255:
raise error.Abort(_(b"cannot store a note of more than 255 bytes")) raise error.InputError(_(b"cannot store a note of more than 255 bytes"))
if b'\n' in note: if b'\n' in note:
raise error.Abort(_(b"note cannot contain a newline")) raise error.InputError(_(b"note cannot contain a newline"))
def ishunk(x): def ishunk(x):
hunkclasses = (crecordmod.uihunk, patch.recordhunk) hunkclasses = (crecordmod.uihunk, patch.recordhunk)
return isinstance(x, hunkclasses) return isinstance(x, hunkclasses)
def newandmodified(chunks, originalchunks): def newandmodified(chunks, originalchunks):
ui, repo, commitfunc, cmdsuggest, backupall, filterfn, *pats, **opts ui, repo, commitfunc, cmdsuggest, backupall, filterfn, *pats, **opts
): ):
opts = pycompat.byteskwargs(opts) opts = pycompat.byteskwargs(opts)
if not ui.interactive(): if not ui.interactive():
if cmdsuggest: if cmdsuggest:
msg = _(b'running non-interactively, use %s instead') % cmdsuggest msg = _(b'running non-interactively, use %s instead') % cmdsuggest
else: else:
msg = _(b'running non-interactively') msg = _(b'running non-interactively')
raise error.Abort(msg) raise error.InputError(msg)
# make sure username is set before going interactive # make sure username is set before going interactive
if not opts.get(b'user'): if not opts.get(b'user'):
ui.username() # raise exception, username not provided ui.username() # raise exception, username not provided
def recordfunc(ui, repo, message, match, opts): def recordfunc(ui, repo, message, match, opts):
"""This is generic record driver. """This is generic record driver.
Its job is to interactively filter local changes, and Its job is to interactively filter local changes, and
accordingly prepare working directory into a state in which the accordingly prepare working directory into a state in which the
job can be delegated to a non-interactive commit command such as job can be delegated to a non-interactive commit command such as
'commit' or 'qrefresh'. 'commit' or 'qrefresh'.
After the actual job is done by non-interactive command, the After the actual job is done by non-interactive command, the
working directory is restored to its original state. working directory is restored to its original state.
In the end we'll record interesting changes, and everything else In the end we'll record interesting changes, and everything else
will be left in place, so the user can continue working. will be left in place, so the user can continue working.
""" """
if not opts.get(b'interactive-unshelve'): if not opts.get(b'interactive-unshelve'):
checkunfinished(repo, commit=True) checkunfinished(repo, commit=True)
wctx = repo[None] wctx = repo[None]
merge = len(wctx.parents()) > 1 merge = len(wctx.parents()) > 1
if merge: if merge:
raise error.Abort( raise error.InputError(
_( _(
b'cannot partially commit a merge ' b'cannot partially commit a merge '
b'(use "hg commit" instead)' b'(use "hg commit" instead)'
) )
) )
def fail(f, msg): def fail(f, msg):
raise error.Abort(b'%s: %s' % (f, msg)) raise error.Abort(b'%s: %s' % (f, msg))
originaldiff = patch.diff(repo, changes=status, opts=diffopts) originaldiff = patch.diff(repo, changes=status, opts=diffopts)
originalchunks = patch.parsepatch(originaldiff) originalchunks = patch.parsepatch(originaldiff)
match = scmutil.match(repo[None], pats) match = scmutil.match(repo[None], pats)
# 1. filter patch, since we are intending to apply subset of it # 1. filter patch, since we are intending to apply subset of it
try: try:
chunks, newopts = filterfn(ui, originalchunks, match) chunks, newopts = filterfn(ui, originalchunks, match)
except error.PatchError as err: except error.PatchError as err:
raise error.Abort(_(b'error parsing patch: %s') % err) raise error.InputError(_(b'error parsing patch: %s') % err)
opts.update(newopts) opts.update(newopts)
# We need to keep a backup of files that have been newly added and # We need to keep a backup of files that have been newly added and
# modified during the recording process because there is a previous # modified during the recording process because there is a previous
# version without the edit in the workdir. We also will need to restore # version without the edit in the workdir. We also will need to restore
# files that were the sources of renames so that the patch application # files that were the sources of renames so that the patch application
# works. # works.
newlyaddedandmodifiedfiles, alsorestore = newandmodified( newlyaddedandmodifiedfiles, alsorestore = newandmodified(
# 3b. (apply) # 3b. (apply)
if dopatch: if dopatch:
try: try:
ui.debug(b'applying patch\n') ui.debug(b'applying patch\n')
ui.debug(fp.getvalue()) ui.debug(fp.getvalue())
patch.internalpatch(ui, repo, fp, 1, eolmode=None) patch.internalpatch(ui, repo, fp, 1, eolmode=None)
except error.PatchError as err: except error.PatchError as err:
raise error.Abort(pycompat.bytestr(err)) raise error.InputError(pycompat.bytestr(err))
del fp del fp
# 4. We prepared working directory according to filtered # 4. We prepared working directory according to filtered
# patch. Now is the time to delegate the job to # patch. Now is the time to delegate the job to
# commit/qrefresh or the like! # commit/qrefresh or the like!
# Make all of the pathnames absolute. # Make all of the pathnames absolute.
newfiles = [repo.wjoin(nf) for nf in newfiles] newfiles = [repo.wjoin(nf) for nf in newfiles]
directory or not. directory or not.
""" """
# the order matters here as that is used to produce final list # the order matters here as that is used to produce final list
allst = (b'm', b'a', b'r', b'd', b'u', b'i', b'c') allst = (b'm', b'a', b'r', b'd', b'u', b'i', b'c')
# checking the argument validity # checking the argument validity
for s in pycompat.bytestr(terseargs): for s in pycompat.bytestr(terseargs):
if s not in allst: if s not in allst:
raise error.Abort(_(b"'%s' not recognized") % s) raise error.InputError(_(b"'%s' not recognized") % s)
# creating a dirnode object for the root of the repo # creating a dirnode object for the root of the repo
rootobj = dirnode(b'') rootobj = dirnode(b'')
pstatus = ( pstatus = (
b'modified', b'modified',
b'added', b'added',
b'deleted', b'deleted',
b'clean', b'clean',
def changebranch(ui, repo, revs, label, opts): def changebranch(ui, repo, revs, label, opts):
""" Change the branch name of given revs to label """ """ Change the branch name of given revs to label """
with repo.wlock(), repo.lock(), repo.transaction(b'branches'): with repo.wlock(), repo.lock(), repo.transaction(b'branches'):
# abort in case of uncommitted merge or dirty wdir # abort in case of uncommitted merge or dirty wdir
bailifchanged(repo) bailifchanged(repo)
revs = scmutil.revrange(repo, revs) revs = scmutil.revrange(repo, revs)
if not revs: if not revs:
raise error.Abort(b"empty revision set") raise error.InputError(b"empty revision set")
roots = repo.revs(b'roots(%ld)', revs) roots = repo.revs(b'roots(%ld)', revs)
if len(roots) > 1: if len(roots) > 1:
raise error.Abort( raise error.InputError(
_(b"cannot change branch of non-linear revisions") _(b"cannot change branch of non-linear revisions")
) )
rewriteutil.precheck(repo, revs, b'change branch of') rewriteutil.precheck(repo, revs, b'change branch of')
root = repo[roots.first()] root = repo[roots.first()]
rpb = {parent.branch() for parent in root.parents()} rpb = {parent.branch() for parent in root.parents()}
if ( if (
not opts.get(b'force') not opts.get(b'force')
and label not in rpb and label not in rpb
and label in repo.branchmap() and label in repo.branchmap()
): ):
raise error.Abort(_(b"a branch of the same name already exists")) raise error.InputError(
_(b"a branch of the same name already exists")
)
if repo.revs(b'obsolete() and %ld', revs): if repo.revs(b'obsolete() and %ld', revs):
raise error.Abort( raise error.InputError(
_(b"cannot change branch of a obsolete changeset") _(b"cannot change branch of a obsolete changeset")
) )
# make sure only topological heads # make sure only topological heads
if repo.revs(b'heads(%ld) - head()', revs): if repo.revs(b'heads(%ld) - head()', revs):
raise error.Abort(_(b"cannot change branch in middle of a stack")) raise error.InputError(
_(b"cannot change branch in middle of a stack")
)
replacements = {} replacements = {}
# avoid import cycle mercurial.cmdutil -> mercurial.context -> # avoid import cycle mercurial.cmdutil -> mercurial.context ->
# mercurial.subrepo -> mercurial.cmdutil # mercurial.subrepo -> mercurial.cmdutil
from . import context from . import context
for rev in revs: for rev in revs:
ctx = repo[rev] ctx = repo[rev]
if file_: if file_:
msg = _(b'cannot specify filename with --changelog or --manifest') msg = _(b'cannot specify filename with --changelog or --manifest')
elif not repo: elif not repo:
msg = _( msg = _(
b'cannot specify --changelog or --manifest or --dir ' b'cannot specify --changelog or --manifest or --dir '
b'without a repository' b'without a repository'
) )
if msg: if msg:
raise error.Abort(msg) raise error.InputError(msg)
r = None r = None
if repo: if repo:
if cl: if cl:
r = repo.unfiltered().changelog r = repo.unfiltered().changelog
elif dir: elif dir:
if not scmutil.istreemanifest(repo): if not scmutil.istreemanifest(repo):
raise error.Abort( raise error.InputError(
_( _(
b"--dir can only be used on repos with " b"--dir can only be used on repos with "
b"treemanifest enabled" b"treemanifest enabled"
) )
) )
if not dir.endswith(b'/'): if not dir.endswith(b'/'):
dir = dir + b'/' dir = dir + b'/'
dirlog = repo.manifestlog.getstorage(dir) dirlog = repo.manifestlog.getstorage(dir)
# Not all storage may be revlogs. If requested, try to return an actual # Not all storage may be revlogs. If requested, try to return an actual
# revlog instance. # revlog instance.
if returnrevlog: if returnrevlog:
if isinstance(r, revlog.revlog): if isinstance(r, revlog.revlog):
pass pass
elif util.safehasattr(r, b'_revlog'): elif util.safehasattr(r, b'_revlog'):
r = r._revlog # pytype: disable=attribute-error r = r._revlog # pytype: disable=attribute-error
elif r is not None: elif r is not None:
raise error.Abort(_(b'%r does not appear to be a revlog') % r) raise error.InputError(
_(b'%r does not appear to be a revlog') % r
)
if not r: if not r:
if not returnrevlog: if not returnrevlog:
raise error.Abort(_(b'cannot give path to non-revlog')) raise error.InputError(_(b'cannot give path to non-revlog'))
if not file_: if not file_:
raise error.CommandError(cmd, _(b'invalid arguments')) raise error.CommandError(cmd, _(b'invalid arguments'))
if not os.path.isfile(file_): if not os.path.isfile(file_):
raise error.Abort(_(b"revlog '%s' not found") % file_) raise error.InputError(_(b"revlog '%s' not found") % file_)
r = revlog.revlog( r = revlog.revlog(
vfsmod.vfs(encoding.getcwd(), audit=False), file_[:-2] + b".i" vfsmod.vfs(encoding.getcwd(), audit=False), file_[:-2] + b".i"
) )
return r return r
def openrevlog(repo, cmd, file_, opts): def openrevlog(repo, cmd, file_, opts):
"""Obtain a revlog backing storage of an item. """Obtain a revlog backing storage of an item.
forget = opts.get(b"forget") forget = opts.get(b"forget")
after = opts.get(b"after") after = opts.get(b"after")
dryrun = opts.get(b"dry_run") dryrun = opts.get(b"dry_run")
rev = opts.get(b'at_rev') rev = opts.get(b'at_rev')
if rev: if rev:
if not forget and not after: if not forget and not after:
# TODO: Remove this restriction and make it also create the copy # TODO: Remove this restriction and make it also create the copy
# targets (and remove the rename source if rename==True). # targets (and remove the rename source if rename==True).
raise error.Abort(_(b'--at-rev requires --after')) raise error.InputError(_(b'--at-rev requires --after'))
ctx = scmutil.revsingle(repo, rev) ctx = scmutil.revsingle(repo, rev)
if len(ctx.parents()) > 1: if len(ctx.parents()) > 1:
raise error.Abort(_(b'cannot mark/unmark copy in merge commit')) raise error.InputError(
_(b'cannot mark/unmark copy in merge commit')
)
else: else:
ctx = repo[None] ctx = repo[None]
pctx = ctx.p1() pctx = ctx.p1()
uipathfn = scmutil.getuipathfn(repo, legacyrelativevalue=True) uipathfn = scmutil.getuipathfn(repo, legacyrelativevalue=True)
if forget: if forget:
if ctx.rev() is None: if ctx.rev() is None:
new_ctx = ctx new_ctx = ctx
else: else:
if len(ctx.parents()) > 1: if len(ctx.parents()) > 1:
raise error.Abort(_(b'cannot unmark copy in merge commit')) raise error.InputError(_(b'cannot unmark copy in merge commit'))
# avoid cycle context -> subrepo -> cmdutil # avoid cycle context -> subrepo -> cmdutil
from . import context from . import context
rewriteutil.precheck(repo, [ctx.rev()], b'uncopy') rewriteutil.precheck(repo, [ctx.rev()], b'uncopy')
new_ctx = context.overlayworkingctx(repo) new_ctx = context.overlayworkingctx(repo)
new_ctx.setbase(ctx.p1()) new_ctx.setbase(ctx.p1())
mergemod.graft(repo, ctx, wctx=new_ctx) mergemod.graft(repo, ctx, wctx=new_ctx)
scmutil.cleanupnodes( scmutil.cleanupnodes(
repo, replacements, b'uncopy', fixphase=True repo, replacements, b'uncopy', fixphase=True
) )
return return
pats = scmutil.expandpats(pats) pats = scmutil.expandpats(pats)
if not pats: if not pats:
raise error.Abort(_(b'no source or destination specified')) raise error.InputError(_(b'no source or destination specified'))
if len(pats) == 1: if len(pats) == 1:
raise error.Abort(_(b'no destination specified')) raise error.InputError(_(b'no destination specified'))
dest = pats.pop() dest = pats.pop()
def walkpat(pat): def walkpat(pat):
srcs = [] srcs = []
# TODO: Inline and simplify the non-working-copy version of this code # TODO: Inline and simplify the non-working-copy version of this code
# since it shares very little with the working-copy version of it. # since it shares very little with the working-copy version of it.
ctx_to_walk = ctx if ctx.rev() is None else pctx ctx_to_walk = ctx if ctx.rev() is None else pctx
m = scmutil.match(ctx_to_walk, [pat], opts, globbed=True) m = scmutil.match(ctx_to_walk, [pat], opts, globbed=True)
# rel: ossep # rel: ossep
srcs.append((abs, rel, exact)) srcs.append((abs, rel, exact))
return srcs return srcs
if ctx.rev() is not None: if ctx.rev() is not None:
rewriteutil.precheck(repo, [ctx.rev()], b'uncopy') rewriteutil.precheck(repo, [ctx.rev()], b'uncopy')
absdest = pathutil.canonpath(repo.root, cwd, dest) absdest = pathutil.canonpath(repo.root, cwd, dest)
if ctx.hasdir(absdest): if ctx.hasdir(absdest):
raise error.Abort( raise error.InputError(
_(b'%s: --at-rev does not support a directory as destination') _(b'%s: --at-rev does not support a directory as destination')
% uipathfn(absdest) % uipathfn(absdest)
) )
if absdest not in ctx: if absdest not in ctx:
raise error.Abort( raise error.InputError(
_(b'%s: copy destination does not exist in %s') _(b'%s: copy destination does not exist in %s')
% (uipathfn(absdest), ctx) % (uipathfn(absdest), ctx)
) )
# avoid cycle context -> subrepo -> cmdutil # avoid cycle context -> subrepo -> cmdutil
from . import context from . import context
copylist = [] copylist = []
for pat in pats: for pat in pats:
srcs = walkpat(pat) srcs = walkpat(pat)
if not srcs: if not srcs:
continue continue
for abs, rel, exact in srcs: for abs, rel, exact in srcs:
copylist.append(abs) copylist.append(abs)
if not copylist: if not copylist:
raise error.Abort(_(b'no files to copy')) raise error.InputError(_(b'no files to copy'))
# TODO: Add support for `hg cp --at-rev . foo bar dir` and # TODO: Add support for `hg cp --at-rev . foo bar dir` and
# `hg cp --at-rev . dir1 dir2`, preferably unifying the code with the # `hg cp --at-rev . dir1 dir2`, preferably unifying the code with the
# existing functions below. # existing functions below.
if len(copylist) != 1: if len(copylist) != 1:
raise error.Abort(_(b'--at-rev requires a single source')) raise error.InputError(_(b'--at-rev requires a single source'))
new_ctx = context.overlayworkingctx(repo) new_ctx = context.overlayworkingctx(repo)
new_ctx.setbase(ctx.p1()) new_ctx.setbase(ctx.p1())
mergemod.graft(repo, ctx, wctx=new_ctx) mergemod.graft(repo, ctx, wctx=new_ctx)
new_ctx.markcopied(absdest, copylist[0]) new_ctx.markcopied(absdest, copylist[0])
with repo.lock(): with repo.lock():
) )
else: else:
res = lambda p: dest res = lambda p: dest
return res return res
destdirexists = os.path.isdir(dest) and not os.path.islink(dest) destdirexists = os.path.isdir(dest) and not os.path.islink(dest)
if not destdirexists: if not destdirexists:
if len(pats) > 1 or matchmod.patkind(pats[0]): if len(pats) > 1 or matchmod.patkind(pats[0]):
raise error.Abort( raise error.InputError(
_( _(
b'with multiple sources, destination must be an ' b'with multiple sources, destination must be an '
b'existing directory' b'existing directory'
) )
) )
if util.endswithsep(dest): if util.endswithsep(dest):
raise error.Abort(_(b'destination %s is not a directory') % dest) raise error.InputError(
_(b'destination %s is not a directory') % dest
)
tfn = targetpathfn tfn = targetpathfn
if after: if after:
tfn = targetpathafterfn tfn = targetpathafterfn
copylist = [] copylist = []
for pat in pats: for pat in pats:
srcs = walkpat(pat) srcs = walkpat(pat)
if not srcs: if not srcs:
continue continue
copylist.append((tfn(pat, dest, srcs), srcs)) copylist.append((tfn(pat, dest, srcs), srcs))
if not copylist: if not copylist:
raise error.Abort(_(b'no files to copy')) raise error.InputError(_(b'no files to copy'))
errors = 0 errors = 0
for targetpath, srcs in copylist: for targetpath, srcs in copylist:
for abssrc, relsrc, exact in srcs: for abssrc, relsrc, exact in srcs:
if copyfile(abssrc, relsrc, targetpath(abssrc), exact): if copyfile(abssrc, relsrc, targetpath(abssrc), exact):
errors += 1 errors += 1
return errors != 0 return errors != 0
# launch the editor # launch the editor
message = None message = None
ui.debug(b'message:\n%s\n' % (message or b'')) ui.debug(b'message:\n%s\n' % (message or b''))
if len(parents) == 1: if len(parents) == 1:
parents.append(repo[nullid]) parents.append(repo[nullid])
if opts.get(b'exact'): if opts.get(b'exact'):
if not nodeid or not p1: if not nodeid or not p1:
raise error.Abort(_(b'not a Mercurial patch')) raise error.InputError(_(b'not a Mercurial patch'))
p1 = repo[p1] p1 = repo[p1]
p2 = repo[p2 or nullid] p2 = repo[p2 or nullid]
elif p2: elif p2:
try: try:
p1 = repo[p1] p1 = repo[p1]
p2 = repo[p2] p2 = repo[p2]
# Without any options, consider p2 only if the # Without any options, consider p2 only if the
# patch is being applied on top of the recorded # patch is being applied on top of the recorded
def finddate(ui, repo, date): def finddate(ui, repo, date):
"""Find the tipmost changeset that matches the given date spec""" """Find the tipmost changeset that matches the given date spec"""
mrevs = repo.revs(b'date(%s)', date) mrevs = repo.revs(b'date(%s)', date)
try: try:
rev = mrevs.max() rev = mrevs.max()
except ValueError: except ValueError:
raise error.Abort(_(b"revision matching date not found")) raise error.InputError(_(b"revision matching date not found"))
ui.status( ui.status(
_(b"found revision %d from %s\n") _(b"found revision %d from %s\n")
% (rev, dateutil.datestr(repo[rev].date())) % (rev, dateutil.datestr(repo[rev].date()))
) )
return b'%d' % rev return b'%d' % rev
for subpath in ctx.substate: for subpath in ctx.substate:
ctx.sub(subpath).addwebdirpath(serverpath, webconf) ctx.sub(subpath).addwebdirpath(serverpath, webconf)
def forget( def forget(
ui, repo, match, prefix, uipathfn, explicitonly, dryrun, interactive ui, repo, match, prefix, uipathfn, explicitonly, dryrun, interactive
): ):
if dryrun and interactive: if dryrun and interactive:
raise error.Abort(_(b"cannot specify both --dry-run and --interactive")) raise error.InputError(
_(b"cannot specify both --dry-run and --interactive")
)
bad = [] bad = []
badfn = lambda x, y: bad.append(x) or match.bad(x, y) badfn = lambda x, y: bad.append(x) or match.bad(x, y)
wctx = repo[None] wctx = repo[None]
forgot = [] forgot = []
s = repo.status(match=matchmod.badmatch(match, badfn), clean=True) s = repo.status(match=matchmod.badmatch(match, badfn), clean=True)
forget = sorted(s.modified + s.added + s.deleted + s.clean) forget = sorted(s.modified + s.added + s.deleted + s.clean)
if explicitonly: if explicitonly:
text = text[: stripbelow.start()] text = text[: stripbelow.start()]
text = re.sub(b"(?m)^HG:.*(\n|$)", b"", text) text = re.sub(b"(?m)^HG:.*(\n|$)", b"", text)
os.chdir(olddir) os.chdir(olddir)
if finishdesc: if finishdesc:
text = finishdesc(text) text = finishdesc(text)
if not text.strip(): if not text.strip():
raise error.Abort(_(b"empty commit message")) raise error.InputError(_(b"empty commit message"))
if unchangedmessagedetection and editortext == templatetext: if unchangedmessagedetection and editortext == templatetext:
raise error.Abort(_(b"commit message unchanged")) raise error.InputError(_(b"commit message unchanged"))
return text return text
def buildcommittemplate(repo, ctx, subs, extramsg, ref): def buildcommittemplate(repo, ctx, subs, extramsg, ref):
ui = repo.ui ui = repo.ui
spec = formatter.reference_templatespec(ref) spec = formatter.reference_templatespec(ref)
t = logcmdutil.changesettemplater(ui, repo, spec) t = logcmdutil.changesettemplater(ui, repo, spec)

mercurial/commands.py

use --dry-run/-n to dry run the command. use --dry-run/-n to dry run the command.
""" """
dryrun = opts.get('dry_run') dryrun = opts.get('dry_run')
abortstate = cmdutil.getunfinishedstate(repo) abortstate = cmdutil.getunfinishedstate(repo)
if not abortstate: if not abortstate:
raise error.Abort(_(b'no operation in progress')) raise error.Abort(_(b'no operation in progress'))
if not abortstate.abortfunc: if not abortstate.abortfunc:
raise error.Abort( raise error.InputError(
( (
_(b"%s in progress but does not support 'hg abort'") _(b"%s in progress but does not support 'hg abort'")
% (abortstate._opname) % (abortstate._opname)
), ),
hint=abortstate.hint(), hint=abortstate.hint(),
) )
if dryrun: if dryrun:
ui.status( ui.status(
:path: String. Repository-absolute path of the file at that revision. :path: String. Repository-absolute path of the file at that revision.
See :hg:`help templates.operators` for the list expansion syntax. See :hg:`help templates.operators` for the list expansion syntax.
Returns 0 on success. Returns 0 on success.
""" """
opts = pycompat.byteskwargs(opts) opts = pycompat.byteskwargs(opts)
if not pats: if not pats:
raise error.Abort(_(b'at least one filename or pattern is required')) raise error.InputError(
_(b'at least one filename or pattern is required')
)
if opts.get(b'follow'): if opts.get(b'follow'):
# --follow is deprecated and now just an alias for -f/--file # --follow is deprecated and now just an alias for -f/--file
# to mimic the behavior of Mercurial before version 1.5 # to mimic the behavior of Mercurial before version 1.5
opts[b'file'] = True opts[b'file'] = True
if ( if (
not opts.get(b'user') not opts.get(b'user')
and not opts.get(b'changeset') and not opts.get(b'changeset')
and not opts.get(b'date') and not opts.get(b'date')
and not opts.get(b'file') and not opts.get(b'file')
): ):
opts[b'number'] = True opts[b'number'] = True
linenumber = opts.get(b'line_number') is not None linenumber = opts.get(b'line_number') is not None
if ( if (
linenumber linenumber
and (not opts.get(b'changeset')) and (not opts.get(b'changeset'))
and (not opts.get(b'number')) and (not opts.get(b'number'))
): ):
raise error.Abort(_(b'at least one of -n/-c is required for -l')) raise error.InputError(_(b'at least one of -n/-c is required for -l'))
rev = opts.get(b'rev') rev = opts.get(b'rev')
if rev: if rev:
repo = scmutil.unhidehashlikerevs(repo, [rev], b'nowarn') repo = scmutil.unhidehashlikerevs(repo, [rev], b'nowarn')
ctx = scmutil.revsingle(repo, rev) ctx = scmutil.revsingle(repo, rev)
ui.pager(b'annotate') ui.pager(b'annotate')
rootfm = ui.formatter(b'annotate', opts) rootfm = ui.formatter(b'annotate', opts)
''' '''
opts = pycompat.byteskwargs(opts) opts = pycompat.byteskwargs(opts)
rev = opts.get(b'rev') rev = opts.get(b'rev')
if rev: if rev:
repo = scmutil.unhidehashlikerevs(repo, [rev], b'nowarn') repo = scmutil.unhidehashlikerevs(repo, [rev], b'nowarn')
ctx = scmutil.revsingle(repo, rev) ctx = scmutil.revsingle(repo, rev)
if not ctx: if not ctx:
raise error.Abort(_(b'no working directory: please specify a revision')) raise error.InputError(
_(b'no working directory: please specify a revision')
)
node = ctx.node() node = ctx.node()
dest = cmdutil.makefilename(ctx, dest) dest = cmdutil.makefilename(ctx, dest)
if os.path.realpath(dest) == repo.root: if os.path.realpath(dest) == repo.root:
raise error.Abort(_(b'repository root cannot be destination')) raise error.InputError(_(b'repository root cannot be destination'))
kind = opts.get(b'type') or archival.guesskind(dest) or b'files' kind = opts.get(b'type') or archival.guesskind(dest) or b'files'
prefix = opts.get(b'prefix') prefix = opts.get(b'prefix')
if dest == b'-': if dest == b'-':
if kind == b'files': if kind == b'files':
raise error.Abort(_(b'cannot archive plain files to stdout')) raise error.InputError(_(b'cannot archive plain files to stdout'))
dest = cmdutil.makefileobj(ctx, dest) dest = cmdutil.makefileobj(ctx, dest)
if not prefix: if not prefix:
prefix = os.path.basename(repo.root) + b'-%h' prefix = os.path.basename(repo.root) + b'-%h'
prefix = cmdutil.makefilename(ctx, prefix) prefix = cmdutil.makefilename(ctx, prefix)
match = scmutil.match(ctx, [], opts) match = scmutil.match(ctx, [], opts)
archival.archive( archival.archive(
repo, repo,
return _dobackout(ui, repo, node, rev, **opts) return _dobackout(ui, repo, node, rev, **opts)
def _dobackout(ui, repo, node=None, rev=None, **opts): def _dobackout(ui, repo, node=None, rev=None, **opts):
cmdutil.check_incompatible_arguments(opts, 'no_commit', ['commit', 'merge']) cmdutil.check_incompatible_arguments(opts, 'no_commit', ['commit', 'merge'])
opts = pycompat.byteskwargs(opts) opts = pycompat.byteskwargs(opts)
if rev and node: if rev and node:
raise error.Abort(_(b"please specify just one revision")) raise error.InputError(_(b"please specify just one revision"))
if not rev: if not rev:
rev = node rev = node
if not rev: if not rev:
raise error.Abort(_(b"please specify a revision to backout")) raise error.InputError(_(b"please specify a revision to backout"))
date = opts.get(b'date') date = opts.get(b'date')
if date: if date:
opts[b'date'] = dateutil.parsedate(date) opts[b'date'] = dateutil.parsedate(date)
cmdutil.checkunfinished(repo) cmdutil.checkunfinished(repo)
cmdutil.bailifchanged(repo) cmdutil.bailifchanged(repo)
ctx = scmutil.revsingle(repo, rev) ctx = scmutil.revsingle(repo, rev)
node = ctx.node() node = ctx.node()
op1, op2 = repo.dirstate.parents() op1, op2 = repo.dirstate.parents()
if not repo.changelog.isancestor(node, op1): if not repo.changelog.isancestor(node, op1):
raise error.Abort(_(b'cannot backout change that is not an ancestor')) raise error.InputError(
_(b'cannot backout change that is not an ancestor')
)
p1, p2 = repo.changelog.parents(node) p1, p2 = repo.changelog.parents(node)
if p1 == nullid: if p1 == nullid:
raise error.Abort(_(b'cannot backout a change with no parents')) raise error.InputError(_(b'cannot backout a change with no parents'))
if p2 != nullid: if p2 != nullid:
if not opts.get(b'parent'): if not opts.get(b'parent'):
raise error.Abort(_(b'cannot backout a merge changeset')) raise error.InputError(_(b'cannot backout a merge changeset'))
p = repo.lookup(opts[b'parent']) p = repo.lookup(opts[b'parent'])
if p not in (p1, p2): if p not in (p1, p2):
raise error.Abort( raise error.InputError(
_(b'%s is not a parent of %s') % (short(p), short(node)) _(b'%s is not a parent of %s') % (short(p), short(node))
) )
parent = p parent = p
else: else:
if opts.get(b'parent'): if opts.get(b'parent'):
raise error.Abort(_(b'cannot use --parent on non-merge changeset')) raise error.InputError(
_(b'cannot use --parent on non-merge changeset')
)
parent = p1 parent = p1
# the backout should appear on the same branch # the backout should appear on the same branch
branch = repo.dirstate.branch() branch = repo.dirstate.branch()
bheads = repo.branchheads(branch) bheads = repo.branchheads(branch)
rctx = scmutil.revsingle(repo, hex(parent)) rctx = scmutil.revsingle(repo, hex(parent))
if not opts.get(b'merge') and op1 != node: if not opts.get(b'merge') and op1 != node:
with dirstateguard.dirstateguard(repo, b'backout'): with dirstateguard.dirstateguard(repo, b'backout'):
cmd, rev, extra = rev, extra, None cmd, rev, extra = rev, extra, None
if cmd == b"good": if cmd == b"good":
good = True good = True
elif cmd == b"bad": elif cmd == b"bad":
bad = True bad = True
else: else:
reset = True reset = True
elif extra: elif extra:
raise error.Abort(_(b'incompatible arguments')) raise error.InputError(_(b'incompatible arguments'))
incompatibles = { incompatibles = {
b'--bad': bad, b'--bad': bad,
b'--command': bool(command), b'--command': bool(command),
b'--extend': extend, b'--extend': extend,
b'--good': good, b'--good': good,
b'--reset': reset, b'--reset': reset,
b'--skip': skip, b'--skip': skip,
} }
enabled = [x for x in incompatibles if incompatibles[x]] enabled = [x for x in incompatibles if incompatibles[x]]
if len(enabled) > 1: if len(enabled) > 1:
raise error.Abort( raise error.InputError(
_(b'%s and %s are incompatible') % tuple(sorted(enabled)[0:2]) _(b'%s and %s are incompatible') % tuple(sorted(enabled)[0:2])
) )
if reset: if reset:
hbisect.resetstate(repo) hbisect.resetstate(repo)
return return
state = hbisect.load_state(repo) state = hbisect.load_state(repo)
action = b'inactive' # meaning deactivate action = b'inactive' # meaning deactivate
else: else:
action = b'list' action = b'list'
cmdutil.check_incompatible_arguments( cmdutil.check_incompatible_arguments(
opts, b'inactive', [b'delete', b'list'] opts, b'inactive', [b'delete', b'list']
) )
if not names and action in {b'add', b'delete'}: if not names and action in {b'add', b'delete'}:
raise error.Abort(_(b"bookmark name required")) raise error.InputError(_(b"bookmark name required"))
if action in {b'add', b'delete', b'rename', b'inactive'}: if action in {b'add', b'delete', b'rename', b'inactive'}:
with repo.wlock(), repo.lock(), repo.transaction(b'bookmark') as tr: with repo.wlock(), repo.lock(), repo.transaction(b'bookmark') as tr:
if action == b'delete': if action == b'delete':
names = pycompat.maplist(repo._bookmarks.expandname, names) names = pycompat.maplist(repo._bookmarks.expandname, names)
bookmarks.delete(repo, tr, names) bookmarks.delete(repo, tr, names)
elif action == b'rename': elif action == b'rename':
if not names: if not names:
raise error.Abort(_(b"new bookmark name required")) raise error.InputError(_(b"new bookmark name required"))
elif len(names) > 1: elif len(names) > 1:
raise error.Abort(_(b"only one new bookmark name allowed")) raise error.InputError(
_(b"only one new bookmark name allowed")
)
oldname = repo._bookmarks.expandname(opts[b'rename']) oldname = repo._bookmarks.expandname(opts[b'rename'])
bookmarks.rename(repo, tr, oldname, names[0], force, inactive) bookmarks.rename(repo, tr, oldname, names[0], force, inactive)
elif action == b'add': elif action == b'add':
bookmarks.addbookmarks(repo, tr, names, rev, force, inactive) bookmarks.addbookmarks(repo, tr, names, rev, force, inactive)
elif action == b'inactive': elif action == b'inactive':
if len(repo._bookmarks) == 0: if len(repo._bookmarks) == 0:
ui.status(_(b"no bookmarks set\n")) ui.status(_(b"no bookmarks set\n"))
elif not repo._activebookmark: elif not repo._activebookmark:
""" """
opts = pycompat.byteskwargs(opts) opts = pycompat.byteskwargs(opts)
revs = opts.get(b'rev') revs = opts.get(b'rev')
if label: if label:
label = label.strip() label = label.strip()
if not opts.get(b'clean') and not label: if not opts.get(b'clean') and not label:
if revs: if revs:
raise error.Abort(_(b"no branch name specified for the revisions")) raise error.InputError(
_(b"no branch name specified for the revisions")
)
ui.write(b"%s\n" % repo.dirstate.branch()) ui.write(b"%s\n" % repo.dirstate.branch())
return return
with repo.wlock(): with repo.wlock():
if opts.get(b'clean'): if opts.get(b'clean'):
label = repo[b'.'].branch() label = repo[b'.'].branch()
repo.dirstate.setbranch(label) repo.dirstate.setbranch(label)
ui.status(_(b'reset working directory to branch %s\n') % label) ui.status(_(b'reset working directory to branch %s\n') % label)
elif label: elif label:
scmutil.checknewlabel(repo, label, b'branch') scmutil.checknewlabel(repo, label, b'branch')
if revs: if revs:
return cmdutil.changebranch(ui, repo, revs, label, opts) return cmdutil.changebranch(ui, repo, revs, label, opts)
if not opts.get(b'force') and label in repo.branchmap(): if not opts.get(b'force') and label in repo.branchmap():
if label not in [p.branch() for p in repo[None].parents()]: if label not in [p.branch() for p in repo[None].parents()]:
raise error.Abort( raise error.InputError(
_(b'a branch of the same name already exists'), _(b'a branch of the same name already exists'),
# i18n: "it" refers to an existing branch # i18n: "it" refers to an existing branch
hint=_(b"use 'hg update' to switch to it"), hint=_(b"use 'hg update' to switch to it"),
) )
repo.dirstate.setbranch(label) repo.dirstate.setbranch(label)
ui.status(_(b'marked working directory as branch %s\n') % label) ui.status(_(b'marked working directory as branch %s\n') % label)
Returns 0 on success, 1 if no changes found. Returns 0 on success, 1 if no changes found.
""" """
opts = pycompat.byteskwargs(opts) opts = pycompat.byteskwargs(opts)
revs = None revs = None
if b'rev' in opts: if b'rev' in opts:
revstrings = opts[b'rev'] revstrings = opts[b'rev']
revs = scmutil.revrange(repo, revstrings) revs = scmutil.revrange(repo, revstrings)
if revstrings and not revs: if revstrings and not revs:
raise error.Abort(_(b'no commits to bundle')) raise error.InputError(_(b'no commits to bundle'))
bundletype = opts.get(b'type', b'bzip2').lower() bundletype = opts.get(b'type', b'bzip2').lower()
try: try:
bundlespec = bundlecaches.parsebundlespec( bundlespec = bundlecaches.parsebundlespec(
repo, bundletype, strict=False repo, bundletype, strict=False
) )
except error.UnsupportedBundleSpecification as e: except error.UnsupportedBundleSpecification as e:
raise error.Abort( raise error.InputError(
pycompat.bytestr(e), pycompat.bytestr(e),
hint=_(b"see 'hg help bundlespec' for supported values for --type"), hint=_(b"see 'hg help bundlespec' for supported values for --type"),
) )
cgversion = bundlespec.contentopts[b"cg.version"] cgversion = bundlespec.contentopts[b"cg.version"]
# Packed bundles are a pseudo bundle format for now. # Packed bundles are a pseudo bundle format for now.
if cgversion == b's1': if cgversion == b's1':
raise error.Abort( raise error.InputError(
_(b'packed bundles cannot be produced by "hg bundle"'), _(b'packed bundles cannot be produced by "hg bundle"'),
hint=_(b"use 'hg debugcreatestreamclonebundle'"), hint=_(b"use 'hg debugcreatestreamclonebundle'"),
) )
if opts.get(b'all'): if opts.get(b'all'):
if dest: if dest:
raise error.Abort( raise error.InputError(
_(b"--all is incompatible with specifying a destination") _(b"--all is incompatible with specifying a destination")
) )
if opts.get(b'base'): if opts.get(b'base'):
ui.warn(_(b"ignoring --base because --all was specified\n")) ui.warn(_(b"ignoring --base because --all was specified\n"))
base = [nullrev] base = [nullrev]
else: else:
base = scmutil.revrange(repo, opts.get(b'base')) base = scmutil.revrange(repo, opts.get(b'base'))
if cgversion not in changegroup.supportedoutgoingversions(repo): if cgversion not in changegroup.supportedoutgoingversions(repo):
raise error.Abort( raise error.Abort(
_(b"repository does not support bundle version %s") % cgversion _(b"repository does not support bundle version %s") % cgversion
) )
if base: if base:
if dest: if dest:
raise error.Abort( raise error.InputError(
_(b"--base is incompatible with specifying a destination") _(b"--base is incompatible with specifying a destination")
) )
common = [repo[rev].node() for rev in base] common = [repo[rev].node() for rev in base]
heads = [repo[r].node() for r in revs] if revs else None heads = [repo[r].node() for r in revs] if revs else None
outgoing = discovery.outgoing(repo, common, heads) outgoing = discovery.outgoing(repo, common, heads)
else: else:
dest = ui.expandpath(dest or b'default-push', dest or b'default') dest = ui.expandpath(dest or b'default-push', dest or b'default')
dest, branches = hg.parseurl(dest, opts.get(b'branch')) dest, branches = hg.parseurl(dest, opts.get(b'branch'))
bheads = repo.branchheads(branch) bheads = repo.branchheads(branch)
tip = repo.changelog.tip() tip = repo.changelog.tip()
extra = {} extra = {}
if opts.get(b'close_branch') or opts.get(b'force_close_branch'): if opts.get(b'close_branch') or opts.get(b'force_close_branch'):
extra[b'close'] = b'1' extra[b'close'] = b'1'
if repo[b'.'].closesbranch(): if repo[b'.'].closesbranch():
raise error.Abort( raise error.InputError(
_(b'current revision is already a branch closing head') _(b'current revision is already a branch closing head')
) )
elif not bheads: elif not bheads:
raise error.Abort(_(b'branch "%s" has no heads to close') % branch) raise error.InputError(
_(b'branch "%s" has no heads to close') % branch
)
elif ( elif (
branch == repo[b'.'].branch() branch == repo[b'.'].branch()
and repo[b'.'].node() not in bheads and repo[b'.'].node() not in bheads
and not opts.get(b'force_close_branch') and not opts.get(b'force_close_branch')
): ):
hint = _( hint = _(
b'use --force-close-branch to close branch from a non-head' b'use --force-close-branch to close branch from a non-head'
b' changeset' b' changeset'
) )
raise error.Abort(_(b'can only close branch heads'), hint=hint) raise error.InputError(_(b'can only close branch heads'), hint=hint)
elif opts.get(b'amend'): elif opts.get(b'amend'):
if ( if (
repo[b'.'].p1().branch() != branch repo[b'.'].p1().branch() != branch
and repo[b'.'].p2().branch() != branch and repo[b'.'].p2().branch() != branch
): ):
raise error.Abort(_(b'can only close branch heads')) raise error.InputError(_(b'can only close branch heads'))
if opts.get(b'amend'): if opts.get(b'amend'):
if ui.configbool(b'ui', b'commitsubrepos'): if ui.configbool(b'ui', b'commitsubrepos'):
raise error.Abort(_(b'cannot amend with ui.commitsubrepos enabled')) raise error.InputError(
_(b'cannot amend with ui.commitsubrepos enabled')
)
old = repo[b'.'] old = repo[b'.']
rewriteutil.precheck(repo, [old.rev()], b'amend') rewriteutil.precheck(repo, [old.rev()], b'amend')
# Currently histedit gets confused if an amend happens while histedit # Currently histedit gets confused if an amend happens while histedit
# is in progress. Since we have a checkunfinished command, we are # is in progress. Since we have a checkunfinished command, we are
# temporarily honoring it. # temporarily honoring it.
# #
""" """
opts = pycompat.byteskwargs(opts) opts = pycompat.byteskwargs(opts)
editopts = (b'edit', b'local', b'global', b'shared', b'non_shared') editopts = (b'edit', b'local', b'global', b'shared', b'non_shared')
if any(opts.get(o) for o in editopts): if any(opts.get(o) for o in editopts):
cmdutil.check_at_most_one_arg(opts, *editopts[1:]) cmdutil.check_at_most_one_arg(opts, *editopts[1:])
if opts.get(b'local'): if opts.get(b'local'):
if not repo: if not repo:
raise error.Abort(_(b"can't use --local outside a repository")) raise error.InputError(
_(b"can't use --local outside a repository")
)
paths = [repo.vfs.join(b'hgrc')] paths = [repo.vfs.join(b'hgrc')]
elif opts.get(b'global'): elif opts.get(b'global'):
paths = rcutil.systemrcpath() paths = rcutil.systemrcpath()
elif opts.get(b'shared'): elif opts.get(b'shared'):
if not repo.shared(): if not repo.shared():
raise error.Abort( raise error.InputError(
_(b"repository is not shared; can't use --shared") _(b"repository is not shared; can't use --shared")
) )
if requirements.SHARESAFE_REQUIREMENT not in repo.requirements: if requirements.SHARESAFE_REQUIREMENT not in repo.requirements:
raise error.Abort( raise error.InputError(
_( _(
b"share safe feature not unabled; " b"share safe feature not unabled; "
b"unable to edit shared source repository config" b"unable to edit shared source repository config"
) )
) )
paths = [vfsmod.vfs(repo.sharedpath).join(b'hgrc')] paths = [vfsmod.vfs(repo.sharedpath).join(b'hgrc')]
elif opts.get(b'non_shared'): elif opts.get(b'non_shared'):
paths = [repo.vfs.join(b'hgrc-not-shared')] paths = [repo.vfs.join(b'hgrc-not-shared')]
f = paths[0] f = paths[0]
fp = open(f, b"wb") fp = open(f, b"wb")
fp.write(util.tonativeeol(samplehgrc)) fp.write(util.tonativeeol(samplehgrc))
fp.close() fp.close()
editor = ui.geteditor() editor = ui.geteditor()
ui.system( ui.system(
b"%s \"%s\"" % (editor, f), b"%s \"%s\"" % (editor, f),
onerr=error.Abort, onerr=error.InputError,
errprefix=_(b"edit failed"), errprefix=_(b"edit failed"),
blockedtag=b'config_edit', blockedtag=b'config_edit',
) )
return return
ui.pager(b'config') ui.pager(b'config')
fm = ui.formatter(b'config', opts) fm = ui.formatter(b'config', opts)
for t, f in rcutil.rccomponents(): for t, f in rcutil.rccomponents():
if t == b'path': if t == b'path':
opts = pycompat.byteskwargs(opts) opts = pycompat.byteskwargs(opts)
bookmark = opts.get(b'bookmark') bookmark = opts.get(b'bookmark')
changesets += tuple(opts.get(b'rev', [])) changesets += tuple(opts.get(b'rev', []))
cmdutil.check_at_most_one_arg(opts, b'rev', b'bookmark') cmdutil.check_at_most_one_arg(opts, b'rev', b'bookmark')
if bookmark: if bookmark:
if bookmark not in repo._bookmarks: if bookmark not in repo._bookmarks:
raise error.Abort(_(b"bookmark '%s' not found") % bookmark) raise error.InputError(_(b"bookmark '%s' not found") % bookmark)
revs = scmutil.bookmarkrevs(repo, bookmark) revs = scmutil.bookmarkrevs(repo, bookmark)
else: else:
if not changesets: if not changesets:
changesets = [b'.'] changesets = [b'.']
repo = scmutil.unhidehashlikerevs(repo, changesets, b'nowarn') repo = scmutil.unhidehashlikerevs(repo, changesets, b'nowarn')
revs = scmutil.revrange(repo, changesets) revs = scmutil.revrange(repo, changesets)
if not revs: if not revs:
raise error.Abort(_(b"export requires at least one changeset")) raise error.InputError(_(b"export requires at least one changeset"))
if len(revs) > 1: if len(revs) > 1:
ui.note(_(b'exporting patches:\n')) ui.note(_(b'exporting patches:\n'))
else: else:
ui.note(_(b'exporting patch:\n')) ui.note(_(b'exporting patch:\n'))
fntemplate = opts.get(b'output') fntemplate = opts.get(b'output')
if cmdutil.isstdiofilename(fntemplate): if cmdutil.isstdiofilename(fntemplate):
fntemplate = b'' fntemplate = b''
hg forget "set:hgignore()" hg forget "set:hgignore()"
Returns 0 on success. Returns 0 on success.
""" """
opts = pycompat.byteskwargs(opts) opts = pycompat.byteskwargs(opts)
if not pats: if not pats:
raise error.Abort(_(b'no files specified')) raise error.InputError(_(b'no files specified'))
m = scmutil.match(repo[None], pats, opts) m = scmutil.match(repo[None], pats, opts)
dryrun, interactive = opts.get(b'dry_run'), opts.get(b'interactive') dryrun, interactive = opts.get(b'dry_run'), opts.get(b'interactive')
uipathfn = scmutil.getuipathfn(repo, legacyrelativevalue=True) uipathfn = scmutil.getuipathfn(repo, legacyrelativevalue=True)
rejected = cmdutil.forget( rejected = cmdutil.forget(
ui, ui,
repo, repo,
m, m,
b'currentuser', b'currentuser',
b'rev', b'rev',
], ],
) )
return cmdutil.abortgraft(ui, repo, graftstate) return cmdutil.abortgraft(ui, repo, graftstate)
elif opts.get(b'continue'): elif opts.get(b'continue'):
cont = True cont = True
if revs: if revs:
raise error.Abort(_(b"can't specify --continue and revisions")) raise error.InputError(_(b"can't specify --continue and revisions"))
# read in unfinished revisions # read in unfinished revisions
if graftstate.exists(): if graftstate.exists():
statedata = cmdutil.readgraftstate(repo, graftstate) statedata = cmdutil.readgraftstate(repo, graftstate)
if statedata.get(b'date'): if statedata.get(b'date'):
opts[b'date'] = statedata[b'date'] opts[b'date'] = statedata[b'date']
if statedata.get(b'user'): if statedata.get(b'user'):
opts[b'user'] = statedata[b'user'] opts[b'user'] = statedata[b'user']
if statedata.get(b'log'): if statedata.get(b'log'):
opts[b'log'] = True opts[b'log'] = True
if statedata.get(b'no_commit'): if statedata.get(b'no_commit'):
opts[b'no_commit'] = statedata.get(b'no_commit') opts[b'no_commit'] = statedata.get(b'no_commit')
if statedata.get(b'base'): if statedata.get(b'base'):
opts[b'base'] = statedata.get(b'base') opts[b'base'] = statedata.get(b'base')
nodes = statedata[b'nodes'] nodes = statedata[b'nodes']
revs = [repo[node].rev() for node in nodes] revs = [repo[node].rev() for node in nodes]
else: else:
cmdutil.wrongtooltocontinue(repo, _(b'graft')) cmdutil.wrongtooltocontinue(repo, _(b'graft'))
else: else:
if not revs: if not revs:
raise error.Abort(_(b'no revisions specified')) raise error.InputError(_(b'no revisions specified'))
cmdutil.checkunfinished(repo) cmdutil.checkunfinished(repo)
cmdutil.bailifchanged(repo) cmdutil.bailifchanged(repo)
revs = scmutil.revrange(repo, revs) revs = scmutil.revrange(repo, revs)
skipped = set() skipped = set()
basectx = None basectx = None
if opts.get(b'base'): if opts.get(b'base'):
basectx = scmutil.revsingle(repo, opts[b'base'], None) basectx = scmutil.revsingle(repo, opts[b'base'], None)
if basectx is None: if basectx is None:
# check for merges # check for merges
for rev in repo.revs(b'%ld and merge()', revs): for rev in repo.revs(b'%ld and merge()', revs):
ui.warn(_(b'skipping ungraftable merge revision %d\n') % rev) ui.warn(_(b'skipping ungraftable merge revision %d\n') % rev)
skipped.add(rev) skipped.add(rev)
revs = [r for r in revs if r not in skipped] revs = [r for r in revs if r not in skipped]
if not revs: if not revs:
return -1 return -1
if basectx is not None and len(revs) != 1: if basectx is not None and len(revs) != 1:
raise error.Abort(_(b'only one revision allowed with --base ')) raise error.InputError(_(b'only one revision allowed with --base '))
# Don't check in the --continue case, in effect retaining --force across # Don't check in the --continue case, in effect retaining --force across
# --continues. That's because without --force, any revisions we decided to # --continues. That's because without --force, any revisions we decided to
# skip would have been filtered out here, so they wouldn't have made their # skip would have been filtered out here, so they wouldn't have made their
# way to the graftstate. With --force, any revisions we would have otherwise # way to the graftstate. With --force, any revisions we would have otherwise
# skipped would not have been filtered out, and if they hadn't been applied # skipped would not have been filtered out, and if they hadn't been applied
# already, they'd have been in the graftstate. # already, they'd have been in the graftstate.
if not (cont or opts.get(b'force')) and basectx is None: if not (cont or opts.get(b'force')) and basectx is None:
See :hg:`log` for generating more information about specific revisions, See :hg:`log` for generating more information about specific revisions,
including full hash identifiers. including full hash identifiers.
Returns 0 if successful. Returns 0 if successful.
""" """
opts = pycompat.byteskwargs(opts) opts = pycompat.byteskwargs(opts)
if not repo and not source: if not repo and not source:
raise error.Abort( raise error.InputError(
_(b"there is no Mercurial repository here (.hg not found)") _(b"there is no Mercurial repository here (.hg not found)")
) )
default = not (num or id or branch or tags or bookmarks) default = not (num or id or branch or tags or bookmarks)
output = [] output = []
revs = [] revs = []
if source: if source:
source, branches = hg.parseurl(ui.expandpath(source)) source, branches = hg.parseurl(ui.expandpath(source))
peer = hg.peer(repo or ui, opts, source) # only pass ui when no repo peer = hg.peer(repo or ui, opts, source) # only pass ui when no repo
repo = peer.local() repo = peer.local()
revs, checkout = hg.addbranchrevs(repo, peer, branches, None) revs, checkout = hg.addbranchrevs(repo, peer, branches, None)
fm = ui.formatter(b'identify', opts) fm = ui.formatter(b'identify', opts)
fm.startitem() fm.startitem()
if not repo: if not repo:
if num or branch or tags: if num or branch or tags:
raise error.Abort( raise error.InputError(
_(b"can't query remote revision number, branch, or tags") _(b"can't query remote revision number, branch, or tags")
) )
if not rev and revs: if not rev and revs:
rev = revs[0] rev = revs[0]
if not rev: if not rev:
rev = b"tip" rev = b"tip"
remoterev = peer.lookup(rev) remoterev = peer.lookup(rev)
""" """
cmdutil.check_incompatible_arguments( cmdutil.check_incompatible_arguments(
opts, 'no_commit', ['bypass', 'secret'] opts, 'no_commit', ['bypass', 'secret']
) )
cmdutil.check_incompatible_arguments(opts, 'exact', ['edit', 'prefix']) cmdutil.check_incompatible_arguments(opts, 'exact', ['edit', 'prefix'])
opts = pycompat.byteskwargs(opts) opts = pycompat.byteskwargs(opts)
if not patch1: if not patch1:
raise error.Abort(_(b'need at least one patch to import')) raise error.InputError(_(b'need at least one patch to import'))
patches = (patch1,) + patches patches = (patch1,) + patches
date = opts.get(b'date') date = opts.get(b'date')
if date: if date:
opts[b'date'] = dateutil.parsedate(date) opts[b'date'] = dateutil.parsedate(date)
exact = opts.get(b'exact') exact = opts.get(b'exact')
update = not opts.get(b'bypass') update = not opts.get(b'bypass')
try: try:
sim = float(opts.get(b'similarity') or 0) sim = float(opts.get(b'similarity') or 0)
except ValueError: except ValueError:
raise error.Abort(_(b'similarity must be a number')) raise error.InputError(_(b'similarity must be a number'))
if sim < 0 or sim > 100: if sim < 0 or sim > 100:
raise error.Abort(_(b'similarity must be between 0 and 100')) raise error.InputError(_(b'similarity must be between 0 and 100'))
if sim and not update: if sim and not update:
raise error.Abort(_(b'cannot use --similarity with --bypass')) raise error.InputError(_(b'cannot use --similarity with --bypass'))
base = opts[b"base"] base = opts[b"base"]
msgs = [] msgs = []
ret = 0 ret = 0
with repo.wlock(): with repo.wlock():
if update: if update:
cmdutil.checkunfinished(repo) cmdutil.checkunfinished(repo)
b"(fix the .rej files and run " b"(fix the .rej files and run "
b"`hg commit --amend`)\n" b"`hg commit --amend`)\n"
) )
) )
ret = 1 ret = 1
break break
if not haspatch: if not haspatch:
raise error.Abort(_(b'%s: no diffs found') % patchurl) raise error.InputError(_(b'%s: no diffs found') % patchurl)
if msgs: if msgs:
repo.savecommitmessage(b'\n* * *\n'.join(msgs)) repo.savecommitmessage(b'\n* * *\n'.join(msgs))
return ret return ret
@command( @command(
b'incoming|in', b'incoming|in',
Returns 0 on success. Returns 0 on success.
""" """
opts = pycompat.byteskwargs(opts) opts = pycompat.byteskwargs(opts)
linerange = opts.get(b'line_range') linerange = opts.get(b'line_range')
if linerange and not opts.get(b'follow'): if linerange and not opts.get(b'follow'):
raise error.Abort(_(b'--line-range requires --follow')) raise error.InputError(_(b'--line-range requires --follow'))
if linerange and pats: if linerange and pats:
# TODO: take pats as patterns with no line-range filter # TODO: take pats as patterns with no line-range filter
raise error.Abort( raise error.InputError(
_(b'FILE arguments are not compatible with --line-range option') _(b'FILE arguments are not compatible with --line-range option')
) )
repo = scmutil.unhidehashlikerevs(repo, opts.get(b'rev'), b'nowarn') repo = scmutil.unhidehashlikerevs(repo, opts.get(b'rev'), b'nowarn')
revs, differ = logcmdutil.getrevs( revs, differ = logcmdutil.getrevs(
repo, logcmdutil.parseopts(ui, pats, opts) repo, logcmdutil.parseopts(ui, pats, opts)
) )
if linerange: if linerange:
Returns 0 on success. Returns 0 on success.
""" """
opts = pycompat.byteskwargs(opts) opts = pycompat.byteskwargs(opts)
fm = ui.formatter(b'manifest', opts) fm = ui.formatter(b'manifest', opts)
if opts.get(b'all'): if opts.get(b'all'):
if rev or node: if rev or node:
raise error.Abort(_(b"can't specify a revision with --all")) raise error.InputError(_(b"can't specify a revision with --all"))
res = set() res = set()
for rev in repo: for rev in repo:
ctx = repo[rev] ctx = repo[rev]
res |= set(ctx.files()) res |= set(ctx.files())
ui.pager(b'manifest') ui.pager(b'manifest')
for f in sorted(res): for f in sorted(res):
fm.startitem() fm.startitem()
fm.write(b"path", b'%s\n', f) fm.write(b"path", b'%s\n', f)
fm.end() fm.end()
return return
if rev and node: if rev and node:
raise error.Abort(_(b"please specify just one revision")) raise error.InputError(_(b"please specify just one revision"))
if not node: if not node:
node = rev node = rev
char = {b'l': b'@', b'x': b'*', b'': b'', b't': b'd'} char = {b'l': b'@', b'x': b'*', b'': b'', b't': b'd'}
mode = {b'l': b'644', b'x': b'755', b'': b'644', b't': b'755'} mode = {b'l': b'644', b'x': b'755', b'': b'644', b't': b'755'}
if node: if node:
repo = scmutil.unhidehashlikerevs(repo, [node], b'nowarn') repo = scmutil.unhidehashlikerevs(repo, [node], b'nowarn')
if abort: if abort:
state = cmdutil.getunfinishedstate(repo) state = cmdutil.getunfinishedstate(repo)
if state and state._opname != b'merge': if state and state._opname != b'merge':
raise error.Abort( raise error.Abort(
_(b'cannot abort merge with %s in progress') % (state._opname), _(b'cannot abort merge with %s in progress') % (state._opname),
hint=state.hint(), hint=state.hint(),
) )
if node: if node:
raise error.Abort(_(b"cannot specify a node with --abort")) raise error.InputError(_(b"cannot specify a node with --abort"))
return hg.abortmerge(repo.ui, repo) return hg.abortmerge(repo.ui, repo)
if opts.get(b'rev') and node: if opts.get(b'rev') and node:
raise error.Abort(_(b"please specify just one revision")) raise error.InputError(_(b"please specify just one revision"))
if not node: if not node:
node = opts.get(b'rev') node = opts.get(b'rev')
if node: if node:
ctx = scmutil.revsingle(repo, node) ctx = scmutil.revsingle(repo, node)
else: else:
if ui.configbool(b'commands', b'merge.require-rev'): if ui.configbool(b'commands', b'merge.require-rev'):
raise error.Abort( raise error.InputError(
_( _(
b'configuration requires specifying revision to merge ' b'configuration requires specifying revision to merge '
b'with' b'with'
) )
) )
ctx = repo[destutil.destmerge(repo)] ctx = repo[destutil.destmerge(repo)]
if ctx.node() is None: if ctx.node() is None:
raise error.Abort(_(b'merging with the working copy has no effect')) raise error.InputError(
_(b'merging with the working copy has no effect')
)
if opts.get(b'preview'): if opts.get(b'preview'):
# find nodes that are ancestors of p2 but not of p1 # find nodes that are ancestors of p2 but not of p1
p1 = repo[b'.'].node() p1 = repo[b'.'].node()
p2 = ctx.node() p2 = ctx.node()
nodes = repo.changelog.findmissing(common=[p1], heads=[p2]) nodes = repo.changelog.findmissing(common=[p1], heads=[p2])
displayer = logcmdutil.changesetdisplayer(ui, repo, opts) displayer = logcmdutil.changesetdisplayer(ui, repo, opts)
rev = opts.get(b'rev') rev = opts.get(b'rev')
if rev: if rev:
repo = scmutil.unhidehashlikerevs(repo, [rev], b'nowarn') repo = scmutil.unhidehashlikerevs(repo, [rev], b'nowarn')
ctx = scmutil.revsingle(repo, rev, None) ctx = scmutil.revsingle(repo, rev, None)
if file_: if file_:
m = scmutil.match(ctx, (file_,), opts) m = scmutil.match(ctx, (file_,), opts)
if m.anypats() or len(m.files()) != 1: if m.anypats() or len(m.files()) != 1:
raise error.Abort(_(b'can only specify an explicit filename')) raise error.InputError(_(b'can only specify an explicit filename'))
file_ = m.files()[0] file_ = m.files()[0]
filenodes = [] filenodes = []
for cp in ctx.parents(): for cp in ctx.parents():
if not cp: if not cp:
continue continue
try: try:
filenodes.append(cp.filenode(file_)) filenodes.append(cp.filenode(file_))
except error.LookupError: except error.LookupError:
pass pass
if not filenodes: if not filenodes:
raise error.Abort(_(b"'%s' not found in manifest!") % file_) raise error.InputError(_(b"'%s' not found in manifest!") % file_)
p = [] p = []
for fn in filenodes: for fn in filenodes:
fctx = repo.filectx(file_, fileid=fn) fctx = repo.filectx(file_, fileid=fn)
p.append(fctx.node()) p.append(fctx.node())
else: else:
p = [cp.node() for cp in ctx.parents()] p = [cp.node() for cp in ctx.parents()]
displayer = logcmdutil.changesetdisplayer(ui, repo, opts) displayer = logcmdutil.changesetdisplayer(ui, repo, opts)
(For more information about the phases concept, see :hg:`help phases`.) (For more information about the phases concept, see :hg:`help phases`.)
""" """
opts = pycompat.byteskwargs(opts) opts = pycompat.byteskwargs(opts)
# search for a unique phase argument # search for a unique phase argument
targetphase = None targetphase = None
for idx, name in enumerate(phases.cmdphasenames): for idx, name in enumerate(phases.cmdphasenames):
if opts[name]: if opts[name]:
if targetphase is not None: if targetphase is not None:
raise error.Abort(_(b'only one phase can be specified')) raise error.InputError(_(b'only one phase can be specified'))
targetphase = idx targetphase = idx
# look for specified revision # look for specified revision
revs = list(revs) revs = list(revs)
revs.extend(opts[b'rev']) revs.extend(opts[b'rev'])
if not revs: if not revs:
# display both parents as the second parent phase can influence # display both parents as the second parent phase can influence
# the phase of a merge commit # the phase of a merge commit
revs = [c.rev() for c in repo[None].parents()] revs = [c.rev() for c in repo[None].parents()]
revs = scmutil.revrange(repo, revs) revs = scmutil.revrange(repo, revs)
ret = 0 ret = 0
if targetphase is None: if targetphase is None:
# display # display
for r in revs: for r in revs:
ctx = repo[r] ctx = repo[r]
ui.write(b'%i: %s\n' % (ctx.rev(), ctx.phasestr())) ui.write(b'%i: %s\n' % (ctx.rev(), ctx.phasestr()))
else: else:
with repo.lock(), repo.transaction(b"phase") as tr: with repo.lock(), repo.transaction(b"phase") as tr:
# set phase # set phase
if not revs: if not revs:
raise error.Abort(_(b'empty revision set')) raise error.InputError(_(b'empty revision set'))
nodes = [repo[r].node() for r in revs] nodes = [repo[r].node() for r in revs]
# moving revision from public to draft may hide them # moving revision from public to draft may hide them
# We have to check result on an unfiltered repository # We have to check result on an unfiltered repository
unfi = repo.unfiltered() unfi = repo.unfiltered()
getphase = unfi._phasecache.phase getphase = unfi._phasecache.phase
olddata = [getphase(unfi, r) for r in unfi] olddata = [getphase(unfi, r) for r in unfi]
phases.advanceboundary(repo, tr, targetphase, nodes) phases.advanceboundary(repo, tr, targetphase, nodes)
if opts[b'force']: if opts[b'force']:
""" """
opts = pycompat.byteskwargs(opts) opts = pycompat.byteskwargs(opts)
if ui.configbool(b'commands', b'update.requiredest') and opts.get( if ui.configbool(b'commands', b'update.requiredest') and opts.get(
b'update' b'update'
): ):
msg = _(b'update destination required by configuration') msg = _(b'update destination required by configuration')
hint = _(b'use hg pull followed by hg update DEST') hint = _(b'use hg pull followed by hg update DEST')
raise error.Abort(msg, hint=hint) raise error.InputError(msg, hint=hint)
source, branches = hg.parseurl(ui.expandpath(source), opts.get(b'branch')) source, branches = hg.parseurl(ui.expandpath(source), opts.get(b'branch'))
ui.status(_(b'pulling from %s\n') % util.hidepassword(source)) ui.status(_(b'pulling from %s\n') % util.hidepassword(source))
other = hg.peer(repo, opts, source) other = hg.peer(repo, opts, source)
try: try:
revs, checkout = hg.addbranchrevs( revs, checkout = hg.addbranchrevs(
repo, other, branches, opts.get(b'rev') repo, other, branches, opts.get(b'rev')
) )
for r in revs: for r in revs:
fnodes.append(e.callcommand(b'lookup', {b'key': r})) fnodes.append(e.callcommand(b'lookup', {b'key': r}))
remotebookmarks = fremotebookmarks.result() remotebookmarks = fremotebookmarks.result()
remotebookmarks = bookmarks.unhexlifybookmarks(remotebookmarks) remotebookmarks = bookmarks.unhexlifybookmarks(remotebookmarks)
pullopargs[b'remotebookmarks'] = remotebookmarks pullopargs[b'remotebookmarks'] = remotebookmarks
for b in opts.get(b'bookmark', []): for b in opts.get(b'bookmark', []):
b = repo._bookmarks.expandname(b) b = repo._bookmarks.expandname(b)
if b not in remotebookmarks: if b not in remotebookmarks:
raise error.Abort(_(b'remote bookmark %s not found!') % b) raise error.InputError(
_(b'remote bookmark %s not found!') % b
)
nodes.append(remotebookmarks[b]) nodes.append(remotebookmarks[b])
for i, rev in enumerate(revs): for i, rev in enumerate(revs):
node = fnodes[i].result() node = fnodes[i].result()
nodes.append(node) nodes.append(node)
if rev == checkout: if rev == checkout:
checkout = node checkout = node
wlock = util.nullcontextmanager() wlock = util.nullcontextmanager()
branches = (path.branch, opts.get(b'branch') or []) branches = (path.branch, opts.get(b'branch') or [])
ui.status(_(b'pushing to %s\n') % util.hidepassword(dest)) ui.status(_(b'pushing to %s\n') % util.hidepassword(dest))
revs, checkout = hg.addbranchrevs(repo, repo, branches, opts.get(b'rev')) revs, checkout = hg.addbranchrevs(repo, repo, branches, opts.get(b'rev'))
other = hg.peer(repo, opts, dest) other = hg.peer(repo, opts, dest)
if revs: if revs:
revs = [repo[r].node() for r in scmutil.revrange(repo, revs)] revs = [repo[r].node() for r in scmutil.revrange(repo, revs)]
if not revs: if not revs:
raise error.Abort( raise error.InputError(
_(b"specified revisions evaluate to an empty set"), _(b"specified revisions evaluate to an empty set"),
hint=_(b"use different revision arguments"), hint=_(b"use different revision arguments"),
) )
elif path.pushrev: elif path.pushrev:
# It doesn't make any sense to specify ancestor revisions. So limit # It doesn't make any sense to specify ancestor revisions. So limit
# to DAG heads to make discovery simpler. # to DAG heads to make discovery simpler.
expr = revsetlang.formatspec(b'heads(%r)', path.pushrev) expr = revsetlang.formatspec(b'heads(%r)', path.pushrev)
revs = scmutil.revrange(repo, [expr]) revs = scmutil.revrange(repo, [expr])
revs = [repo[rev].node() for rev in revs] revs = [repo[rev].node() for rev in revs]
if not revs: if not revs:
raise error.Abort( raise error.InputError(
_(b'default push revset for path evaluates to an empty set') _(b'default push revset for path evaluates to an empty set')
) )
elif ui.configbool(b'commands', b'push.require-revs'): elif ui.configbool(b'commands', b'push.require-revs'):
raise error.Abort( raise error.InputError(
_(b'no revisions specified to push'), _(b'no revisions specified to push'),
hint=_(b'did you mean "hg push -r ."?'), hint=_(b'did you mean "hg push -r ."?'),
) )
repo._subtoppath = dest repo._subtoppath = dest
try: try:
# push subrepos depth-first for coherent ordering # push subrepos depth-first for coherent ordering
c = repo[b'.'] c = repo[b'.']
Returns 0 on success, 1 if any warnings encountered. Returns 0 on success, 1 if any warnings encountered.
""" """
opts = pycompat.byteskwargs(opts) opts = pycompat.byteskwargs(opts)
after, force = opts.get(b'after'), opts.get(b'force') after, force = opts.get(b'after'), opts.get(b'force')
dryrun = opts.get(b'dry_run') dryrun = opts.get(b'dry_run')
if not pats and not after: if not pats and not after:
raise error.Abort(_(b'no files specified')) raise error.InputError(_(b'no files specified'))
m = scmutil.match(repo[None], pats, opts) m = scmutil.match(repo[None], pats, opts)
subrepos = opts.get(b'subrepos') subrepos = opts.get(b'subrepos')
uipathfn = scmutil.getuipathfn(repo, legacyrelativevalue=True) uipathfn = scmutil.getuipathfn(repo, legacyrelativevalue=True)
return cmdutil.remove( return cmdutil.remove(
ui, repo, m, b"", uipathfn, after, force, subrepos, dryrun=dryrun ui, repo, m, b"", uipathfn, after, force, subrepos, dryrun=dryrun
) )
opts = pycompat.byteskwargs(opts) opts = pycompat.byteskwargs(opts)
confirm = ui.configbool(b'commands', b'resolve.confirm') confirm = ui.configbool(b'commands', b'resolve.confirm')
flaglist = b'all mark unmark list no_status re_merge'.split() flaglist = b'all mark unmark list no_status re_merge'.split()
all, mark, unmark, show, nostatus, remerge = [opts.get(o) for o in flaglist] all, mark, unmark, show, nostatus, remerge = [opts.get(o) for o in flaglist]
actioncount = len(list(filter(None, [show, mark, unmark, remerge]))) actioncount = len(list(filter(None, [show, mark, unmark, remerge])))
if actioncount > 1: if actioncount > 1:
raise error.Abort(_(b"too many actions specified")) raise error.InputError(_(b"too many actions specified"))
elif actioncount == 0 and ui.configbool( elif actioncount == 0 and ui.configbool(
b'commands', b'resolve.explicit-re-merge' b'commands', b'resolve.explicit-re-merge'
): ):
hint = _(b'use --mark, --unmark, --list or --re-merge') hint = _(b'use --mark, --unmark, --list or --re-merge')
raise error.Abort(_(b'no action specified'), hint=hint) raise error.InputError(_(b'no action specified'), hint=hint)
if pats and all: if pats and all:
raise error.Abort(_(b"can't specify --all and patterns")) raise error.InputError(_(b"can't specify --all and patterns"))
if not (all or pats or show or mark or unmark): if not (all or pats or show or mark or unmark):
raise error.Abort( raise error.InputError(
_(b'no files or directories specified'), _(b'no files or directories specified'),
hint=b'use --all to re-merge all unresolved files', hint=b'use --all to re-merge all unresolved files',
) )
if confirm: if confirm:
if all: if all:
if ui.promptchoice( if ui.promptchoice(
_(b're-merge all unresolved files (yn)?$$ &Yes $$ &No') _(b're-merge all unresolved files (yn)?$$ &Yes $$ &No')
opts = pycompat.byteskwargs(opts) opts = pycompat.byteskwargs(opts)
if opts.get(b"date"): if opts.get(b"date"):
cmdutil.check_incompatible_arguments(opts, b'date', [b'rev']) cmdutil.check_incompatible_arguments(opts, b'date', [b'rev'])
opts[b"rev"] = cmdutil.finddate(ui, repo, opts[b"date"]) opts[b"rev"] = cmdutil.finddate(ui, repo, opts[b"date"])
parent, p2 = repo.dirstate.parents() parent, p2 = repo.dirstate.parents()
if not opts.get(b'rev') and p2 != nullid: if not opts.get(b'rev') and p2 != nullid:
# revert after merge is a trap for new users (issue2915) # revert after merge is a trap for new users (issue2915)
raise error.Abort( raise error.InputError(
_(b'uncommitted merge with no revision specified'), _(b'uncommitted merge with no revision specified'),
hint=_(b"use 'hg update' or see 'hg help revert'"), hint=_(b"use 'hg update' or see 'hg help revert'"),
) )
rev = opts.get(b'rev') rev = opts.get(b'rev')
if rev: if rev:
repo = scmutil.unhidehashlikerevs(repo, [rev], b'nowarn') repo = scmutil.unhidehashlikerevs(repo, [rev], b'nowarn')
ctx = scmutil.revsingle(repo, rev) ctx = scmutil.revsingle(repo, rev)
if not ( if not (
pats pats
or opts.get(b'include') or opts.get(b'include')
or opts.get(b'exclude') or opts.get(b'exclude')
or opts.get(b'all') or opts.get(b'all')
or opts.get(b'interactive') or opts.get(b'interactive')
): ):
msg = _(b"no files or directories specified") msg = _(b"no files or directories specified")
if p2 != nullid: if p2 != nullid:
hint = _( hint = _(
b"uncommitted merge, use --all to discard all changes," b"uncommitted merge, use --all to discard all changes,"
b" or 'hg update -C .' to abort the merge" b" or 'hg update -C .' to abort the merge"
) )
raise error.Abort(msg, hint=hint) raise error.InputError(msg, hint=hint)
dirty = any(repo.status()) dirty = any(repo.status())
node = ctx.node() node = ctx.node()
if node != parent: if node != parent:
if dirty: if dirty:
hint = ( hint = (
_( _(
b"uncommitted changes, use --all to discard all" b"uncommitted changes, use --all to discard all"
b" changes, or 'hg update %d' to update" b" changes, or 'hg update %d' to update"
) )
% ctx.rev() % ctx.rev()
) )
else: else:
hint = ( hint = (
_( _(
b"use --all to revert all files," b"use --all to revert all files,"
b" or 'hg update %d' to update" b" or 'hg update %d' to update"
) )
% ctx.rev() % ctx.rev()
) )
elif dirty: elif dirty:
hint = _(b"uncommitted changes, use --all to discard all changes") hint = _(b"uncommitted changes, use --all to discard all changes")
else: else:
hint = _(b"use --all to revert all files") hint = _(b"use --all to revert all files")
raise error.Abort(msg, hint=hint) raise error.InputError(msg, hint=hint)
return cmdutil.revert(ui, repo, ctx, *pats, **pycompat.strkwargs(opts)) return cmdutil.revert(ui, repo, ctx, *pats, **pycompat.strkwargs(opts))
@command( @command(
b'rollback', b'rollback',
dryrunopts + [(b'f', b'force', False, _(b'ignore safety measures'))], dryrunopts + [(b'f', b'force', False, _(b'ignore safety measures'))],
helpcategory=command.CATEGORY_MAINTENANCE, helpcategory=command.CATEGORY_MAINTENANCE,
number it uses. number it uses.
Returns 0 on success. Returns 0 on success.
""" """
cmdutil.check_incompatible_arguments(opts, 'stdio', ['cmdserver']) cmdutil.check_incompatible_arguments(opts, 'stdio', ['cmdserver'])
opts = pycompat.byteskwargs(opts) opts = pycompat.byteskwargs(opts)
if opts[b"print_url"] and ui.verbose: if opts[b"print_url"] and ui.verbose:
raise error.Abort(_(b"cannot use --print-url with --verbose")) raise error.InputError(_(b"cannot use --print-url with --verbose"))
if opts[b"stdio"]: if opts[b"stdio"]:
if repo is None: if repo is None:
raise error.RepoError( raise error.RepoError(
_(b"there is no Mercurial repository here (.hg not found)") _(b"there is no Mercurial repository here (.hg not found)")
) )
s = wireprotoserver.sshserver(ui, repo) s = wireprotoserver.sshserver(ui, repo)
s.serve_forever() s.serve_forever()
(b'patch', {b'patch', b'list'}), (b'patch', {b'patch', b'list'}),
(b'stat', {b'stat', b'list'}), (b'stat', {b'stat', b'list'}),
] ]
def checkopt(opt): def checkopt(opt):
if opts.get(opt): if opts.get(opt):
for i, allowable in allowables: for i, allowable in allowables:
if opts[i] and opt not in allowable: if opts[i] and opt not in allowable:
raise error.Abort( raise error.InputError(
_( _(
b"options '--%s' and '--%s' may not be " b"options '--%s' and '--%s' may not be "
b"used together" b"used together"
) )
% (opt, i) % (opt, i)
) )
return True return True
if checkopt(b'cleanup'): if checkopt(b'cleanup'):
if pats: if pats:
raise error.Abort(_(b"cannot specify names when using '--cleanup'")) raise error.InputError(
_(b"cannot specify names when using '--cleanup'")
)
return shelvemod.cleanupcmd(ui, repo) return shelvemod.cleanupcmd(ui, repo)
elif checkopt(b'delete'): elif checkopt(b'delete'):
return shelvemod.deletecmd(ui, repo, pats) return shelvemod.deletecmd(ui, repo, pats)
elif checkopt(b'list'): elif checkopt(b'list'):
return shelvemod.listcmd(ui, repo, pats, opts) return shelvemod.listcmd(ui, repo, pats, opts)
elif checkopt(b'patch') or checkopt(b'stat'): elif checkopt(b'patch') or checkopt(b'stat'):
return shelvemod.patchcmds(ui, repo, pats, opts) return shelvemod.patchcmds(ui, repo, pats, opts)
else: else:
if terse is _NOTTERSE: if terse is _NOTTERSE:
if revs: if revs:
terse = b'' terse = b''
else: else:
terse = ui.config(b'commands', b'status.terse') terse = ui.config(b'commands', b'status.terse')
if revs and terse: if revs and terse:
msg = _(b'cannot use --terse with --rev') msg = _(b'cannot use --terse with --rev')
raise error.Abort(msg) raise error.InputError(msg)
elif change: elif change:
repo = scmutil.unhidehashlikerevs(repo, [change], b'nowarn') repo = scmutil.unhidehashlikerevs(repo, [change], b'nowarn')
ctx2 = scmutil.revsingle(repo, change, None) ctx2 = scmutil.revsingle(repo, change, None)
ctx1 = ctx2.p1() ctx1 = ctx2.p1()
else: else:
repo = scmutil.unhidehashlikerevs(repo, revs, b'nowarn') repo = scmutil.unhidehashlikerevs(repo, revs, b'nowarn')
ctx1, ctx2 = scmutil.revpair(repo, revs) ctx1, ctx2 = scmutil.revpair(repo, revs)
Returns 0 on success. Returns 0 on success.
""" """
cmdutil.check_incompatible_arguments(opts, 'remove', ['rev']) cmdutil.check_incompatible_arguments(opts, 'remove', ['rev'])
opts = pycompat.byteskwargs(opts) opts = pycompat.byteskwargs(opts)
with repo.wlock(), repo.lock(): with repo.wlock(), repo.lock():
rev_ = b"." rev_ = b"."
names = [t.strip() for t in (name1,) + names] names = [t.strip() for t in (name1,) + names]
if len(names) != len(set(names)): if len(names) != len(set(names)):
raise error.Abort(_(b'tag names must be unique')) raise error.InputError(_(b'tag names must be unique'))
for n in names: for n in names:
scmutil.checknewlabel(repo, n, b'tag') scmutil.checknewlabel(repo, n, b'tag')
if not n: if not n:
raise error.Abort( raise error.InputError(
_(b'tag names cannot consist entirely of whitespace') _(b'tag names cannot consist entirely of whitespace')
) )
if opts.get(b'rev'): if opts.get(b'rev'):
rev_ = opts[b'rev'] rev_ = opts[b'rev']
message = opts.get(b'message') message = opts.get(b'message')
if opts.get(b'remove'): if opts.get(b'remove'):
if opts.get(b'local'): if opts.get(b'local'):
expectedtype = b'local' expectedtype = b'local'
else: else:
expectedtype = b'global' expectedtype = b'global'
for n in names: for n in names:
if repo.tagtype(n) == b'global': if repo.tagtype(n) == b'global':
alltags = tagsmod.findglobaltags(ui, repo) alltags = tagsmod.findglobaltags(ui, repo)
if alltags[n][0] == nullid: if alltags[n][0] == nullid:
raise error.Abort(_(b"tag '%s' is already removed") % n) raise error.InputError(
_(b"tag '%s' is already removed") % n
)
if not repo.tagtype(n): if not repo.tagtype(n):
raise error.Abort(_(b"tag '%s' does not exist") % n) raise error.InputError(_(b"tag '%s' does not exist") % n)
if repo.tagtype(n) != expectedtype: if repo.tagtype(n) != expectedtype:
if expectedtype == b'global': if expectedtype == b'global':
raise error.Abort( raise error.InputError(
_(b"tag '%s' is not a global tag") % n _(b"tag '%s' is not a global tag") % n
) )
else: else:
raise error.Abort(_(b"tag '%s' is not a local tag") % n) raise error.InputError(
_(b"tag '%s' is not a local tag") % n
)
rev_ = b'null' rev_ = b'null'
if not message: if not message:
# we don't translate commit messages # we don't translate commit messages
message = b'Removed tag %s' % b', '.join(names) message = b'Removed tag %s' % b', '.join(names)
elif not opts.get(b'force'): elif not opts.get(b'force'):
for n in names: for n in names:
if n in repo.tags(): if n in repo.tags():
raise error.Abort( raise error.InputError(
_(b"tag '%s' already exists (use -f to force)") % n _(b"tag '%s' already exists (use -f to force)") % n
) )
if not opts.get(b'local'): if not opts.get(b'local'):
p1, p2 = repo.dirstate.parents() p1, p2 = repo.dirstate.parents()
if p2 != nullid: if p2 != nullid:
raise error.Abort(_(b'uncommitted merge')) raise error.Abort(_(b'uncommitted merge'))
bheads = repo.branchheads() bheads = repo.branchheads()
if not opts.get(b'force') and bheads and p1 not in bheads: if not opts.get(b'force') and bheads and p1 not in bheads:
raise error.Abort( raise error.InputError(
_( _(
b'working directory is not at a branch head ' b'working directory is not at a branch head '
b'(use -f to force)' b'(use -f to force)'
) )
) )
node = scmutil.revsingle(repo, rev_).node() node = scmutil.revsingle(repo, rev_).node()
if not message: if not message:
editform=editform, **pycompat.strkwargs(opts) editform=editform, **pycompat.strkwargs(opts)
) )
# don't allow tagging the null rev # don't allow tagging the null rev
if ( if (
not opts.get(b'remove') not opts.get(b'remove')
and scmutil.revsingle(repo, rev_).rev() == nullrev and scmutil.revsingle(repo, rev_).rev() == nullrev
): ):
raise error.Abort(_(b"cannot tag null revision")) raise error.InputError(_(b"cannot tag null revision"))
tagsmod.tag( tagsmod.tag(
repo, repo,
names, names,
node, node,
message, message,
opts.get(b'local'), opts.get(b'local'),
opts.get(b'user'), opts.get(b'user'),
""" """
fnames = (fname1,) + fnames fnames = (fname1,) + fnames
with repo.lock(): with repo.lock():
for fname in fnames: for fname in fnames:
f = hg.openpath(ui, fname) f = hg.openpath(ui, fname)
gen = exchange.readbundle(ui, f, fname) gen = exchange.readbundle(ui, f, fname)
if isinstance(gen, streamclone.streamcloneapplier): if isinstance(gen, streamclone.streamcloneapplier):
raise error.Abort( raise error.InputError(
_( _(
b'packed bundles cannot be applied with ' b'packed bundles cannot be applied with '
b'"hg unbundle"' b'"hg unbundle"'
), ),
hint=_(b'use "hg debugapplystreamclonebundle"'), hint=_(b'use "hg debugapplystreamclonebundle"'),
) )
url = b'bundle:' + fname url = b'bundle:' + fname
try: try:
""" """
cmdutil.check_at_most_one_arg(opts, 'clean', 'check', 'merge') cmdutil.check_at_most_one_arg(opts, 'clean', 'check', 'merge')
rev = opts.get('rev') rev = opts.get('rev')
date = opts.get('date') date = opts.get('date')
clean = opts.get('clean') clean = opts.get('clean')
check = opts.get('check') check = opts.get('check')
merge = opts.get('merge') merge = opts.get('merge')
if rev and node: if rev and node:
raise error.Abort(_(b"please specify just one revision")) raise error.InputError(_(b"please specify just one revision"))
if ui.configbool(b'commands', b'update.requiredest'): if ui.configbool(b'commands', b'update.requiredest'):
if not node and not rev and not date: if not node and not rev and not date:
raise error.Abort( raise error.InputError(
_(b'you must specify a destination'), _(b'you must specify a destination'),
hint=_(b'for example: hg update ".::"'), hint=_(b'for example: hg update ".::"'),
) )
if rev is None or rev == b'': if rev is None or rev == b'':
rev = node rev = node
if date and rev is not None: if date and rev is not None:
raise error.Abort(_(b"you can't specify a revision and a date")) raise error.InputError(_(b"you can't specify a revision and a date"))
updatecheck = None updatecheck = None
if check: if check:
updatecheck = b'abort' updatecheck = b'abort'
elif merge: elif merge:
updatecheck = b'none' updatecheck = b'none'
with repo.wlock(): with repo.wlock():

mercurial/error.py

def __str__(self): def __str__(self):
# the output would be unreadable if the message was translated, # the output would be unreadable if the message was translated,
# but do not replace it with encoding.strfromlocal(), which # but do not replace it with encoding.strfromlocal(), which
# may raise another exception. # may raise another exception.
return pycompat.sysstr(self.__bytes__()) return pycompat.sysstr(self.__bytes__())
class InputError(Abort):
"""Indicates that the user made an error in their input.
Examples: Invalid command, invalid flags, invalid revision.
"""
class HookLoadError(Abort): class HookLoadError(Abort):
"""raised when loading a hook fails, aborting an operation """raised when loading a hook fails, aborting an operation
Exists to allow more specialized catching.""" Exists to allow more specialized catching."""
class HookAbort(Abort): class HookAbort(Abort):
"""raised when a validation hook fails, aborting an operation """raised when a validation hook fails, aborting an operation

mercurial/scmutil.py

ui.error(b"%s\n" % inst) ui.error(b"%s\n" % inst)
if inst.hint: if inst.hint:
ui.error(_(b"(%s)\n") % inst.hint) ui.error(_(b"(%s)\n") % inst.hint)
detailed_exit_code = 240 detailed_exit_code = 240
coarse_exit_code = 1 coarse_exit_code = 1
except error.WdirUnsupported: except error.WdirUnsupported:
ui.error(_(b"abort: working directory revision cannot be specified\n")) ui.error(_(b"abort: working directory revision cannot be specified\n"))
except error.Abort as inst: except error.Abort as inst:
if isinstance(inst, error.InputError):
detailed_exit_code = 10
ui.error(_(b"abort: %s\n") % inst.message) ui.error(_(b"abort: %s\n") % inst.message)
if inst.hint: if inst.hint:
ui.error(_(b"(%s)\n") % inst.hint) ui.error(_(b"(%s)\n") % inst.hint)
except error.WorkerError as inst: except error.WorkerError as inst:
# Don't print a message -- the worker already should have # Don't print a message -- the worker already should have
return inst.status_code return inst.status_code
except ImportError as inst: except ImportError as inst:
ui.error(_(b"abort: %s!\n") % stringutil.forcebytestr(inst)) ui.error(_(b"abort: %s!\n") % stringutil.forcebytestr(inst))

tests/test-add.t

$ hg init interactiveforget $ hg init interactiveforget
$ cd interactiveforget $ cd interactiveforget
$ echo foo > foo $ echo foo > foo
$ hg commit -qAm "foo" $ hg commit -qAm "foo"
$ echo bar > bar $ echo bar > bar
$ hg commit -qAm "bar" $ hg commit -qAm "bar"
$ hg forget foo --dry-run -i $ hg forget foo --dry-run -i
abort: cannot specify both --dry-run and --interactive abort: cannot specify both --dry-run and --interactive
[255] [10]
$ hg forget foo --config ui.interactive=True -i << EOF $ hg forget foo --config ui.interactive=True -i << EOF
> ? > ?
> n > n
> EOF > EOF
forget foo [Ynsa?] ? forget foo [Ynsa?] ?
y - yes, forget this file y - yes, forget this file
n - no, skip this file n - no, skip this file

tests/test-amend.t

$ HGEDITOR="sh $TESTTMP/prefix.sh" hg amend -e -m MSG $ HGEDITOR="sh $TESTTMP/prefix.sh" hg amend -e -m MSG
saved backup bundle to $TESTTMP/repo1/.hg/strip-backup/298f085230c3-d81a6ad3-amend.hg (obsstore-off !) saved backup bundle to $TESTTMP/repo1/.hg/strip-backup/298f085230c3-d81a6ad3-amend.hg (obsstore-off !)
$ hg log -r . -T '{node|short} {desc}\n' $ hg log -r . -T '{node|short} {desc}\n'
974f07f28537 EDITED: MSG 974f07f28537 EDITED: MSG
$ echo FOO > $TESTTMP/msg $ echo FOO > $TESTTMP/msg
$ hg amend -l $TESTTMP/msg -m BAR $ hg amend -l $TESTTMP/msg -m BAR
abort: cannot specify both --message and --logfile abort: cannot specify both --message and --logfile
[255] [10]
$ hg amend -l $TESTTMP/msg $ hg amend -l $TESTTMP/msg
saved backup bundle to $TESTTMP/repo1/.hg/strip-backup/974f07f28537-edb6470a-amend.hg (obsstore-off !) saved backup bundle to $TESTTMP/repo1/.hg/strip-backup/974f07f28537-edb6470a-amend.hg (obsstore-off !)
$ hg log -r . -T '{node|short} {desc}\n' $ hg log -r . -T '{node|short} {desc}\n'
507be9bdac71 FOO 507be9bdac71 FOO
Interactive mode Interactive mode
$ touch F G $ touch F G
o 0 426bada5c675 A o 0 426bada5c675 A
Checking the note stored in the obsmarker Checking the note stored in the obsmarker
$ echo foo > bar $ echo foo > bar
$ hg add bar $ hg add bar
$ hg amend --note 'yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy' $ hg amend --note 'yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy'
abort: cannot store a note of more than 255 bytes abort: cannot store a note of more than 255 bytes
[255] [10]
$ hg amend --note "adding bar" $ hg amend --note "adding bar"
$ hg debugobsolete -r . $ hg debugobsolete -r .
112478962961147124edd43549aedd1a335e44bf be169c7e8dbe21cd10b3d79691cbe7f241e3c21c 0 (Thu Jan 01 00:00:00 1970 +0000) {'ef1': '8', 'operation': 'amend', 'user': 'test'} 112478962961147124edd43549aedd1a335e44bf be169c7e8dbe21cd10b3d79691cbe7f241e3c21c 0 (Thu Jan 01 00:00:00 1970 +0000) {'ef1': '8', 'operation': 'amend', 'user': 'test'}
be169c7e8dbe21cd10b3d79691cbe7f241e3c21c 16084da537dd8f84cfdb3055c633772269d62e1b 0 (Thu Jan 01 00:00:00 1970 +0000) {'ef1': '8', 'note': 'adding bar', 'operation': 'amend', 'user': 'test'} be169c7e8dbe21cd10b3d79691cbe7f241e3c21c 16084da537dd8f84cfdb3055c633772269d62e1b 0 (Thu Jan 01 00:00:00 1970 +0000) {'ef1': '8', 'note': 'adding bar', 'operation': 'amend', 'user': 'test'}
#endif #endif
Cannot amend public changeset Cannot amend public changeset
user: baz user: baz
date: Thu Jan 01 00:00:05 1970 +0000 date: Thu Jan 01 00:00:05 1970 +0000
summary: commit 1 summary: commit 1
Bad combination of date options: Bad combination of date options:
$ hg amend -D --date '0 0' $ hg amend -D --date '0 0'
abort: cannot specify both --date and --currentdate abort: cannot specify both --date and --currentdate
[255] [10]
Close branch Close branch
$ hg amend --secret --close-branch $ hg amend --secret --close-branch
$ hg log --limit 1 -T 'close={get(extras, "close")}\nphase={phase}\n' $ hg log --limit 1 -T 'close={get(extras, "close")}\nphase={phase}\n'
close=1 close=1
phase=secret phase=secret

tests/test-archive.t

$ cat errors.log $ cat errors.log
empty repo empty repo
$ hg init ../empty $ hg init ../empty
$ cd ../empty $ cd ../empty
$ hg archive ../test-empty $ hg archive ../test-empty
abort: no working directory: please specify a revision abort: no working directory: please specify a revision
[255] [10]
old file -- date clamped to 1980 old file -- date clamped to 1980
$ touch -t 197501010000 old $ touch -t 197501010000 old
$ hg add old $ hg add old
$ hg commit -m old $ hg commit -m old
$ hg archive ../old.zip $ hg archive ../old.zip
$ unzip -l ../old.zip | grep -v -- ----- | egrep -v files$ $ unzip -l ../old.zip | grep -v -- ----- | egrep -v files$

tests/test-backout.t

$ hg init basic $ hg init basic
$ cd basic $ cd basic
should complain should complain
$ hg backout $ hg backout
abort: please specify a revision to backout abort: please specify a revision to backout
[255] [10]
$ hg backout -r 0 0 $ hg backout -r 0 0
abort: please specify just one revision abort: please specify just one revision
[255] [10]
basic operation basic operation
(this also tests that editor is invoked if the commit message is not (this also tests that editor is invoked if the commit message is not
specified explicitly) specified explicitly)
$ echo a > a $ echo a > a
$ hg commit -d '0 0' -A -m a $ hg commit -d '0 0' -A -m a
adding a adding a
commit: (clean) commit: (clean)
update: 1 new changesets (update) update: 1 new changesets (update)
phases: 2 draft phases: 2 draft
should fail should fail
$ hg backout 1 $ hg backout 1
abort: cannot backout change that is not an ancestor abort: cannot backout change that is not an ancestor
[255] [10]
$ echo c > c $ echo c > c
$ hg ci -Am2 $ hg ci -Am2
adding c adding c
created new head created new head
$ hg summary $ hg summary
parent: 2:db815d6d32e6 tip parent: 2:db815d6d32e6 tip
2 2
branch: default branch: default
commit: (clean) commit: (clean)
update: 1 new changesets, 2 branch heads (merge) update: 1 new changesets, 2 branch heads (merge)
phases: 3 draft phases: 3 draft
should fail should fail
$ hg backout 1 $ hg backout 1
abort: cannot backout change that is not an ancestor abort: cannot backout change that is not an ancestor
[255] [10]
$ hg summary $ hg summary
parent: 2:db815d6d32e6 tip parent: 2:db815d6d32e6 tip
2 2
branch: default branch: default
commit: (clean) commit: (clean)
update: 1 new changesets, 2 branch heads (merge) update: 1 new changesets, 2 branch heads (merge)
phases: 3 draft phases: 3 draft
commit: (clean) commit: (clean)
update: (current) update: (current)
phases: 5 draft phases: 5 draft
backout of merge should fail backout of merge should fail
$ hg backout 4 $ hg backout 4
abort: cannot backout a merge changeset abort: cannot backout a merge changeset
[255] [10]
backout of merge with bad parent should fail backout of merge with bad parent should fail
$ hg backout --parent 0 4 $ hg backout --parent 0 4
abort: cb9a9f314b8b is not a parent of b2f3bb92043e abort: cb9a9f314b8b is not a parent of b2f3bb92043e
[255] [10]
backout of non-merge with parent should fail backout of non-merge with parent should fail
$ hg backout --parent 0 3 $ hg backout --parent 0 3
abort: cannot use --parent on non-merge changeset abort: cannot use --parent on non-merge changeset
[255] [10]
backout with valid parent should be ok backout with valid parent should be ok
$ hg backout -d '5 0' --parent 2 4 --tool=true $ hg backout -d '5 0' --parent 2 4 --tool=true
removing d removing d
changeset 5:10e5328c8435 backs out changeset 4:b2f3bb92043e changeset 5:10e5328c8435 backs out changeset 4:b2f3bb92043e
$ hg summary $ hg summary
parent: 5:10e5328c8435 tip parent: 5:10e5328c8435 tip
removing 3 removing 3
changeset cccc23d9d68f backed out, don't forget to commit. changeset cccc23d9d68f backed out, don't forget to commit.
$ hg revert -aq $ hg revert -aq
--no-commit can't be used with --merge --no-commit can't be used with --merge
$ hg backout --merge --no-commit 2 $ hg backout --merge --no-commit 2
abort: cannot specify both --no-commit and --merge abort: cannot specify both --no-commit and --merge
[255] [10]
Ensure that backout out the same changeset twice performs correctly: Ensure that backout out the same changeset twice performs correctly:
$ hg backout 2 $ hg backout 2
removing 3 removing 3
changeset 3:8f188de730d9 backs out changeset 2:cccc23d9d68f changeset 3:8f188de730d9 backs out changeset 2:cccc23d9d68f
$ echo 4 > 4 $ echo 4 > 4
$ hg ci -A -m 4 $ hg ci -A -m 4
adding 4 adding 4
$ hg up 2 $ hg up 2
1 files updated, 0 files merged, 1 files removed, 0 files unresolved 1 files updated, 0 files merged, 1 files removed, 0 files unresolved
$ hg backout 2 $ hg backout 2
removing 3 removing 3
warning: commit already existed in the repository! warning: commit already existed in the repository!
changeset 3:8f188de730d9 backs out changeset 2:cccc23d9d68f changeset 3:8f188de730d9 backs out changeset 2:cccc23d9d68f

tests/test-bisect.t

date: Thu Jan 01 00:00:26 1970 +0000 date: Thu Jan 01 00:00:26 1970 +0000
summary: msg 26 summary: msg 26
Test the validation message when exclusive options are used: Test the validation message when exclusive options are used:
$ hg bisect -r $ hg bisect -r
$ hg bisect -b -c false $ hg bisect -b -c false
abort: --bad and --command are incompatible abort: --bad and --command are incompatible
[255] [10]
$ hg bisect -b -e $ hg bisect -b -e
abort: --bad and --extend are incompatible abort: --bad and --extend are incompatible
[255] [10]
$ hg bisect -b -g $ hg bisect -b -g
abort: --bad and --good are incompatible abort: --bad and --good are incompatible
[255] [10]
$ hg bisect -b -r $ hg bisect -b -r
abort: --bad and --reset are incompatible abort: --bad and --reset are incompatible
[255] [10]
$ hg bisect -b -s $ hg bisect -b -s
abort: --bad and --skip are incompatible abort: --bad and --skip are incompatible
[255] [10]
$ hg bisect -c false -e $ hg bisect -c false -e
abort: --command and --extend are incompatible abort: --command and --extend are incompatible
[255] [10]
$ hg bisect -c false -g $ hg bisect -c false -g
abort: --command and --good are incompatible abort: --command and --good are incompatible
[255] [10]
$ hg bisect -c false -r $ hg bisect -c false -r
abort: --command and --reset are incompatible abort: --command and --reset are incompatible
[255] [10]
$ hg bisect -c false -s $ hg bisect -c false -s
abort: --command and --skip are incompatible abort: --command and --skip are incompatible
[255] [10]
$ hg bisect -e -g $ hg bisect -e -g
abort: --extend and --good are incompatible abort: --extend and --good are incompatible
[255] [10]
$ hg bisect -e -r $ hg bisect -e -r
abort: --extend and --reset are incompatible abort: --extend and --reset are incompatible
[255] [10]
$ hg bisect -e -s $ hg bisect -e -s
abort: --extend and --skip are incompatible abort: --extend and --skip are incompatible
[255] [10]
$ hg bisect -g -r $ hg bisect -g -r
abort: --good and --reset are incompatible abort: --good and --reset are incompatible
[255] [10]
$ hg bisect -g -s $ hg bisect -g -s
abort: --good and --skip are incompatible abort: --good and --skip are incompatible
[255] [10]
$ hg bisect -r -s $ hg bisect -r -s
abort: --reset and --skip are incompatible abort: --reset and --skip are incompatible
[255] [10]

tests/test-bookmarks-pushpull.t

pushing to ../a pushing to ../a
searching for changes searching for changes
bookmark badname does not exist on the local or remote repository! bookmark badname does not exist on the local or remote repository!
no changes found no changes found
[2] [2]
$ hg pull -B anotherbadname ../a $ hg pull -B anotherbadname ../a
pulling from ../a pulling from ../a
abort: remote bookmark anotherbadname not found! abort: remote bookmark anotherbadname not found!
[255] [10]
divergent bookmarks divergent bookmarks
$ cd ../a $ cd ../a
$ echo c1 > f1 $ echo c1 > f1
$ hg ci -Am1 $ hg ci -Am1
adding f1 adding f1
$ hg book -f @ $ hg book -f @
$ hg book -r 1 A; hg book -r 2 B; hg book -r 3 C $ hg book -r 1 A; hg book -r 2 B; hg book -r 3 C
$ hg push ../ab2 $ hg push ../ab2
pushing to ../ab2 pushing to ../ab2
searching for changes searching for changes
no changes found no changes found
[1] [1]
$ hg push --all-bookmarks -r 1 ../ab2 $ hg push --all-bookmarks -r 1 ../ab2
abort: cannot specify both --all-bookmarks and --rev abort: cannot specify both --all-bookmarks and --rev
[255] [10]
$ hg push --all-bookmarks -B A ../ab2 $ hg push --all-bookmarks -B A ../ab2
abort: cannot specify both --all-bookmarks and --bookmark abort: cannot specify both --all-bookmarks and --bookmark
[255] [10]
$ hg push --all-bookmarks ../ab2 $ hg push --all-bookmarks ../ab2
pushing to ../ab2 pushing to ../ab2
searching for changes searching for changes
no changes found no changes found
exporting bookmark A exporting bookmark A
exporting bookmark B exporting bookmark B
exporting bookmark C exporting bookmark C
[1] [1]

tests/test-bookmarks.t

Y -1:000000000000 Y -1:000000000000
$ hg bookmarks -l . $ hg bookmarks -l .
* X2 0:f7b1eb17ad24 * X2 0:f7b1eb17ad24
$ hg bookmarks -l X A Y $ hg bookmarks -l X A Y
abort: bookmark 'A' does not exist abort: bookmark 'A' does not exist
[255] [255]
$ hg bookmarks -l -r0 $ hg bookmarks -l -r0
abort: cannot specify both --list and --rev abort: cannot specify both --list and --rev
[255] [10]
$ hg bookmarks -l --inactive $ hg bookmarks -l --inactive
abort: cannot specify both --inactive and --list abort: cannot specify both --inactive and --list
[255] [10]
$ hg log -T '{bookmarks % "{rev} {bookmark}\n"}' $ hg log -T '{bookmarks % "{rev} {bookmark}\n"}'
0 X 0 X
0 X2 0 X2
$ echo b > b $ echo b > b
$ hg add b $ hg add b
$ hg commit -m 1 --config "$TESTHOOK" $ hg commit -m 1 --config "$TESTHOOK"
$ hg bookmark -d REVSET $ hg bookmark -d REVSET
$ hg bookmark -d TIP $ hg bookmark -d TIP
rename without new name or multiple names rename without new name or multiple names
$ hg bookmark -m Y $ hg bookmark -m Y
abort: new bookmark name required abort: new bookmark name required
[255] [10]
$ hg bookmark -m Y Y2 Y3 $ hg bookmark -m Y Y2 Y3
abort: only one new bookmark name allowed abort: only one new bookmark name allowed
[255] [10]
delete without name delete without name
$ hg bookmark -d $ hg bookmark -d
abort: bookmark name required abort: bookmark name required
[255] [10]
delete nonexistent bookmark delete nonexistent bookmark
$ hg bookmark -d A $ hg bookmark -d A
abort: bookmark 'A' does not exist abort: bookmark 'A' does not exist
[255] [255]
delete with --inactive delete with --inactive
$ hg bookmark -d --inactive Y $ hg bookmark -d --inactive Y
abort: cannot specify both --inactive and --delete abort: cannot specify both --inactive and --delete
[255] [10]
bookmark name with spaces should be stripped bookmark name with spaces should be stripped
$ hg bookmark ' x y ' $ hg bookmark ' x y '
list bookmarks list bookmarks
$ hg bookmarks $ hg bookmarks
$ cd .. $ cd ..
incompatible options incompatible options
$ cd repo $ cd repo
$ hg bookmark -m Y -d Z $ hg bookmark -m Y -d Z
abort: cannot specify both --delete and --rename abort: cannot specify both --delete and --rename
[255] [10]
$ hg bookmark -r 1 -d Z $ hg bookmark -r 1 -d Z
abort: cannot specify both --delete and --rev abort: cannot specify both --delete and --rev
[255] [10]
$ hg bookmark -r 1 -m Z Y $ hg bookmark -r 1 -m Z Y
abort: cannot specify both --rename and --rev abort: cannot specify both --rename and --rev
[255] [10]
force bookmark with existing name force bookmark with existing name
$ hg bookmark -f X2 --config "$TESTHOOK" $ hg bookmark -f X2 --config "$TESTHOOK"
test-hook-bookmark: X2: 925d80f479bb026b0fb3deb27503780b13f74123 -> db815d6d32e69058eadefc8cffbad37675707975 test-hook-bookmark: X2: 925d80f479bb026b0fb3deb27503780b13f74123 -> db815d6d32e69058eadefc8cffbad37675707975
force bookmark back to where it was, should deactivate it force bookmark back to where it was, should deactivate it
2 Z 2 Z
2 x y 2 x y
1 X2 1 X2
revision but no bookmark name revision but no bookmark name
$ hg bookmark -r . $ hg bookmark -r .
abort: bookmark name required abort: bookmark name required
[255] [10]
bookmark name with whitespace only bookmark name with whitespace only
$ hg bookmark ' ' $ hg bookmark ' '
abort: bookmark names cannot consist entirely of whitespace abort: bookmark names cannot consist entirely of whitespace
[255] [255]
$ hg bookmark -m Y ' ' $ hg bookmark -m Y ' '
added 2 changesets with 2 changes to 2 files (+1 heads) added 2 changesets with 2 changes to 2 files (+1 heads)
new changesets 125c9a1d6df6:9ba5f110a0b3 new changesets 125c9a1d6df6:9ba5f110a0b3
(run 'hg heads' to see heads, 'hg merge' to merge) (run 'hg heads' to see heads, 'hg merge' to merge)
(# tests strange but with --date crashing when bookmark have to move) (# tests strange but with --date crashing when bookmark have to move)
$ hg -R ../cloned-bookmarks-manual-update update -d 1986 $ hg -R ../cloned-bookmarks-manual-update update -d 1986
abort: revision matching date not found abort: revision matching date not found
[255] [10]
$ hg -R ../cloned-bookmarks-manual-update update $ hg -R ../cloned-bookmarks-manual-update update
updating to active bookmark Y updating to active bookmark Y
1 files updated, 0 files merged, 0 files removed, 0 files unresolved 1 files updated, 0 files merged, 0 files removed, 0 files unresolved
(all in one version) (all in one version)
$ hg -R ../cloned-bookmarks-update update Y $ hg -R ../cloned-bookmarks-update update Y
0 files updated, 0 files merged, 0 files removed, 0 files unresolved 0 files updated, 0 files merged, 0 files removed, 0 files unresolved

tests/test-branch-change.t

$ hg branches $ hg branches
default 4:aa98ab95a928 default 4:aa98ab95a928
Try without passing a new branch name Try without passing a new branch name
$ hg branch -r . $ hg branch -r .
abort: no branch name specified for the revisions abort: no branch name specified for the revisions
[255] [10]
Setting an invalid branch name Setting an invalid branch name
$ hg branch -r . a:b $ hg branch -r . a:b
abort: ':' cannot be used in a name abort: ':' cannot be used in a name
[255] [255]
$ hg branch -r . tip $ hg branch -r . tip
abort: the name 'tip' is reserved abort: the name 'tip' is reserved
[255] [255]
$ hg branch -r . 1234 $ hg branch -r . 1234
abort: cannot use an integer as a name abort: cannot use an integer as a name
[255] [255]
Change on non-linear set of commits Change on non-linear set of commits
$ hg branch -r 2 -r 4 foo $ hg branch -r 2 -r 4 foo
abort: cannot change branch of non-linear revisions abort: cannot change branch of non-linear revisions
[255] [10]
Change in middle of the stack (linear commits) Change in middle of the stack (linear commits)
$ hg branch -r 1::3 foo $ hg branch -r 1::3 foo
abort: cannot change branch of changeset with children abort: cannot change branch of changeset with children
[255] [255]
Change with dirty working directory Change with dirty working directory
$ echo bar > a $ echo bar > a
$ hg branch -r . foo $ hg branch -r . foo
abort: uncommitted changes abort: uncommitted changes
[255] [255]
$ hg revert --all $ hg revert --all
reverting a reverting a
Change on empty revision set Change on empty revision set
$ hg branch -r 'draft() - all()' foo $ hg branch -r 'draft() - all()' foo
abort: empty revision set abort: empty revision set
[255] [10]
Changing branch on linear set of commits from head Changing branch on linear set of commits from head
Without obsmarkers Without obsmarkers
$ hg branch -r 3:4 foo --config experimental.evolution=! $ hg branch -r 3:4 foo --config experimental.evolution=!
changed branch on 2 changesets changed branch on 2 changesets
saved backup bundle to $TESTTMP/repo/.hg/strip-backup/62615734edd5-e86bd13a-branch-change.hg saved backup bundle to $TESTTMP/repo/.hg/strip-backup/62615734edd5-e86bd13a-branch-change.hg
$ hg branches $ hg branches
bar 6:7c1991464886 bar 6:7c1991464886
default 2:28ad74487de9 (inactive) default 2:28ad74487de9 (inactive)
Change branch name to an existing branch Change branch name to an existing branch
$ hg branch -r . default $ hg branch -r . default
abort: a branch of the same name already exists abort: a branch of the same name already exists
[255] [10]
Changing on a branch head which is not topological head Changing on a branch head which is not topological head
$ hg branch -r 2 stable $ hg branch -r 2 stable
abort: cannot change branch of changeset with children abort: cannot change branch of changeset with children
[255] [255]
Enabling the allowunstable config and trying to change branch on a branch head Enabling the allowunstable config and trying to change branch on a branch head
$ hg branch -r 4 foobar $ hg branch -r 4 foobar
abort: hidden revision '4' was rewritten as: 7c1991464886! abort: hidden revision '4' was rewritten as: 7c1991464886!
(use --hidden to access hidden revisions) (use --hidden to access hidden revisions)
[255] [255]
$ hg branch -r 4 --hidden foobar $ hg branch -r 4 --hidden foobar
abort: cannot change branch of a obsolete changeset abort: cannot change branch of a obsolete changeset
[255] [10]
Make sure bookmark movement is correct Make sure bookmark movement is correct
$ hg bookmark b1 $ hg bookmark b1
$ hg glog -r '.^::' $ hg glog -r '.^::'
@ 6:7c1991464886 Added e @ 6:7c1991464886 Added e
| bar (b1) | bar (b1)
* 5:1ea05e93925f Added d * 5:1ea05e93925f Added d
0 files updated, 0 files merged, 4 files removed, 0 files unresolved 0 files updated, 0 files merged, 4 files removed, 0 files unresolved
changed branch on 1 changesets changed branch on 1 changesets
$ hg branch -r . jkl $ hg branch -r . jkl
changed branch on 1 changesets changed branch on 1 changesets
$ hg branch -r . default $ hg branch -r . default
changed branch on 1 changesets changed branch on 1 changesets
$ hg branch -r . stable $ hg branch -r . stable
abort: a branch of the same name already exists abort: a branch of the same name already exists
[255] [10]
$ hg branch -r . stable --force $ hg branch -r . stable --force
changed branch on 1 changesets changed branch on 1 changesets
$ hg branches $ hg branches
stable 34:d1c2addda4a2 stable 34:d1c2addda4a2
jkl 29:6bc1c6c2c9da (inactive) jkl 29:6bc1c6c2c9da (inactive)
ghi 28:2f1019bd29d2 (inactive) ghi 28:2f1019bd29d2 (inactive)

tests/test-branches.t

abort: '\n' cannot be used in a name abort: '\n' cannot be used in a name
[255] [255]
trailing or leading spaces should be stripped before testing duplicates trailing or leading spaces should be stripped before testing duplicates
$ hg branch 'b ' $ hg branch 'b '
abort: a branch of the same name already exists abort: a branch of the same name already exists
(use 'hg update' to switch to it) (use 'hg update' to switch to it)
[255] [10]
$ hg branch ' b' $ hg branch ' b'
abort: a branch of the same name already exists abort: a branch of the same name already exists
(use 'hg update' to switch to it) (use 'hg update' to switch to it)
[255] [10]
verify update will accept invalid legacy branch names verify update will accept invalid legacy branch names
$ hg init test-invalid-branch-name $ hg init test-invalid-branch-name
$ cd test-invalid-branch-name $ cd test-invalid-branch-name
$ hg unbundle -u "$TESTDIR"/bundles/test-invalid-branch-name.hg $ hg unbundle -u "$TESTDIR"/bundles/test-invalid-branch-name.hg
adding changesets adding changesets
adding manifests adding manifests
$ hg branches -a $ hg branches -a
b 8:eebb944467c9 b 8:eebb944467c9
a branch name much longer than the default justification used by branches 7:10ff5895aa57 a branch name much longer than the default justification used by branches 7:10ff5895aa57
$ hg up -C b $ hg up -C b
1 files updated, 0 files merged, 0 files removed, 0 files unresolved 1 files updated, 0 files merged, 0 files removed, 0 files unresolved
$ hg commit -d '9 0' --close-branch -m 'close this part branch too' $ hg commit -d '9 0' --close-branch -m 'close this part branch too'
$ hg commit -d '9 0' --close-branch -m 're-closing this branch' $ hg commit -d '9 0' --close-branch -m 're-closing this branch'
abort: current revision is already a branch closing head abort: current revision is already a branch closing head
[255] [10]
$ hg log -r tip --debug $ hg log -r tip --debug
changeset: 12:e3d49c0575d8fc2cb1cd6859c747c14f5f6d499f changeset: 12:e3d49c0575d8fc2cb1cd6859c747c14f5f6d499f
branch: b branch: b
tag: tip tag: tip
phase: draft phase: draft
parent: 8:eebb944467c9fb9651ed232aeaf31b3c0a7fc6c1 parent: 8:eebb944467c9fb9651ed232aeaf31b3c0a7fc6c1
parent: -1:0000000000000000000000000000000000000000 parent: -1:0000000000000000000000000000000000000000
$ hg up -r "desc('added b')" $ hg up -r "desc('added b')"
0 files updated, 0 files merged, 1 files removed, 0 files unresolved 0 files updated, 0 files merged, 1 files removed, 0 files unresolved
trying to close branch from a cset which is not a branch head trying to close branch from a cset which is not a branch head
it should abort: it should abort:
$ hg ci -m "closing branch" --close-branch $ hg ci -m "closing branch" --close-branch
abort: can only close branch heads abort: can only close branch heads
(use --force-close-branch to close branch from a non-head changeset) (use --force-close-branch to close branch from a non-head changeset)
[255] [10]
$ hg up 0 $ hg up 0
0 files updated, 0 files merged, 1 files removed, 0 files unresolved 0 files updated, 0 files merged, 1 files removed, 0 files unresolved
$ hg log -GT "{rev}: {node|short} {desc|firstline}\n\t{branch}\n\n" $ hg log -GT "{rev}: {node|short} {desc|firstline}\n\t{branch}\n\n"
o 2: 155349b645be added c o 2: 155349b645be added c
| default | default
| |
o 1: 5f6d8a4bf34a added b o 1: 5f6d8a4bf34a added b
| default | default
| |
@ 0: 9092f1db7931 added a @ 0: 9092f1db7931 added a
default default
Test --force-close-branch to close a branch from a non-head changeset: Test --force-close-branch to close a branch from a non-head changeset:
--------------------------------------------------------------------- ---------------------------------------------------------------------
$ hg show stack --config extensions.show= $ hg show stack --config extensions.show=
o 1553 added c o 1553 added c
o 5f6d added b o 5f6d added b
@ 9092 added a @ 9092 added a
$ hg ci -m "branch closed" --close-branch $ hg ci -m "branch closed" --close-branch
abort: can only close branch heads abort: can only close branch heads
(use --force-close-branch to close branch from a non-head changeset) (use --force-close-branch to close branch from a non-head changeset)
[255] [10]
$ hg ci -m "branch closed" --force-close-branch $ hg ci -m "branch closed" --force-close-branch
created new head created new head

tests/test-bundle-r.t

$ hg rollback $ hg rollback
repository tip rolled back to revision 4 (undo pull) repository tip rolled back to revision 4 (undo pull)
$ cd .. $ cd ..
should fail should fail
$ hg -R test bundle --base 2 -r tip test-bundle-branch1.hg test-3 $ hg -R test bundle --base 2 -r tip test-bundle-branch1.hg test-3
abort: --base is incompatible with specifying a destination abort: --base is incompatible with specifying a destination
[255] [10]
$ hg -R test bundle -a -r tip test-bundle-branch1.hg test-3 $ hg -R test bundle -a -r tip test-bundle-branch1.hg test-3
abort: --all is incompatible with specifying a destination abort: --all is incompatible with specifying a destination
[255] [10]
$ hg -R test bundle -r tip test-bundle-branch1.hg $ hg -R test bundle -r tip test-bundle-branch1.hg
abort: repository default-push not found! abort: repository default-push not found!
[255] [255]
$ hg -R test bundle --base 2 -r tip test-bundle-branch1.hg $ hg -R test bundle --base 2 -r tip test-bundle-branch1.hg
2 changesets found 2 changesets found
$ hg -R test bundle --base 2 -r 7 test-bundle-branch2.hg $ hg -R test bundle --base 2 -r 7 test-bundle-branch2.hg
4 changesets found 4 changesets found

tests/test-bundle-type.t

Unknown compression type is rejected Unknown compression type is rejected
$ hg init t3 $ hg init t3
$ cd t3 $ cd t3
$ hg -q unbundle ../b1 $ hg -q unbundle ../b1
$ hg bundle -a -t unknown out.hg $ hg bundle -a -t unknown out.hg
abort: unknown is not a recognized bundle specification abort: unknown is not a recognized bundle specification
(see 'hg help bundlespec' for supported values for --type) (see 'hg help bundlespec' for supported values for --type)
[255] [10]
$ hg bundle -a -t unknown-v2 out.hg $ hg bundle -a -t unknown-v2 out.hg
abort: unknown compression is not supported abort: unknown compression is not supported
(see 'hg help bundlespec' for supported values for --type) (see 'hg help bundlespec' for supported values for --type)
[255] [10]
$ cd .. $ cd ..
test bundle types test bundle types
$ testbundle() { $ testbundle() {
> echo % test bundle type $1 > echo % test bundle type $1
> hg init t$1 > hg init t$1
$ hg -R nogd bundle -a -t zstd nogd-zstd $ hg -R nogd bundle -a -t zstd nogd-zstd
1 changesets found 1 changesets found
zstd-v1 always fails zstd-v1 always fails
$ hg -R tzstd bundle -a -t zstd-v1 zstd-v1 $ hg -R tzstd bundle -a -t zstd-v1 zstd-v1
abort: compression engine zstd is not supported on v1 bundles abort: compression engine zstd is not supported on v1 bundles
(see 'hg help bundlespec' for supported values for --type) (see 'hg help bundlespec' for supported values for --type)
[255] [10]
#else #else
zstd is a valid engine but isn't available zstd is a valid engine but isn't available
$ hg -R t1 bundle -a -t zstd irrelevant.hg $ hg -R t1 bundle -a -t zstd irrelevant.hg
abort: compression engine zstd could not be loaded abort: compression engine zstd could not be loaded
[255] [255]
$ cd .. $ cd ..
test invalid bundle type test invalid bundle type
$ cd t1 $ cd t1
$ hg bundle -a -t garbage ../bgarbage $ hg bundle -a -t garbage ../bgarbage
abort: garbage is not a recognized bundle specification abort: garbage is not a recognized bundle specification
(see 'hg help bundlespec' for supported values for --type) (see 'hg help bundlespec' for supported values for --type)
[255] [10]
$ cd .. $ cd ..

tests/test-bundle.t

#endif #endif
Cannot produce streaming clone bundles with "hg bundle" Cannot produce streaming clone bundles with "hg bundle"
$ hg -R test bundle -t packed1 packed.hg $ hg -R test bundle -t packed1 packed.hg
abort: packed bundles cannot be produced by "hg bundle" abort: packed bundles cannot be produced by "hg bundle"
(use 'hg debugcreatestreamclonebundle') (use 'hg debugcreatestreamclonebundle')
[255] [10]
packed1 is produced properly packed1 is produced properly
#if reporevlogstore #if reporevlogstore
$ hg -R test debugcreatestreamclonebundle packed.hg $ hg -R test debugcreatestreamclonebundle packed.hg
writing 2664 bytes for 6 files writing 2664 bytes for 6 files
bundle requirements: generaldelta, revlogv1, sparserevlog bundle requirements: generaldelta, revlogv1, sparserevlog
bundle requirements: generaldelta, revlogv1, sparserevlog bundle requirements: generaldelta, revlogv1, sparserevlog
Unpacking packed1 bundles with "hg unbundle" isn't allowed Unpacking packed1 bundles with "hg unbundle" isn't allowed
$ hg init packed $ hg init packed
$ hg -R packed unbundle packed.hg $ hg -R packed unbundle packed.hg
abort: packed bundles cannot be applied with "hg unbundle" abort: packed bundles cannot be applied with "hg unbundle"
(use "hg debugapplystreamclonebundle") (use "hg debugapplystreamclonebundle")
[255] [10]
packed1 can be consumed from debug command packed1 can be consumed from debug command
(this also confirms that streamclone-ed changes are visible via (this also confirms that streamclone-ed changes are visible via
@filecache properties to in-process procedures before closing @filecache properties to in-process procedures before closing
transaction) transaction)
$ cat > $TESTTMP/showtip.py <<EOF $ cat > $TESTTMP/showtip.py <<EOF
checking files checking files
checked 3 changesets with 5 changes to 4 files checked 3 changesets with 5 changes to 4 files
#endif #endif
== Test bundling no commits == Test bundling no commits
$ hg bundle -r 'public()' no-output.hg $ hg bundle -r 'public()' no-output.hg
abort: no commits to bundle abort: no commits to bundle
[255] [10]
$ cd .. $ cd ..
When user merges to the revision existing only in the bundle, When user merges to the revision existing only in the bundle,
it should show warning that second parent of the working it should show warning that second parent of the working
directory does not exist directory does not exist
$ hg init update2bundled $ hg init update2bundled

tests/test-clone-update-order.t

$ echo good > bye $ echo good > bye
$ hg commit -Am other $ hg commit -Am other
adding bye adding bye
$ hg up -r mine $ hg up -r mine
1 files updated, 0 files merged, 1 files removed, 0 files unresolved 1 files updated, 0 files merged, 1 files removed, 0 files unresolved
$ hg clone -U -u . .#other ../b -r 0 -r 1 -r 2 -b other $ hg clone -U -u . .#other ../b -r 0 -r 1 -r 2 -b other
abort: cannot specify both --noupdate and --updaterev abort: cannot specify both --noupdate and --updaterev
[255] [10]
$ hg clone -U .#other ../b -r 0 -r 1 -r 2 -b other $ hg clone -U .#other ../b -r 0 -r 1 -r 2 -b other
adding changesets adding changesets
adding manifests adding manifests
adding file changes adding file changes
added 3 changesets with 3 changes to 3 files (+2 heads) added 3 changesets with 3 changes to 3 files (+2 heads)
new changesets 8c68ee086fd0:fcc393352796 new changesets 8c68ee086fd0:fcc393352796
$ rm -rf ../b $ rm -rf ../b

tests/test-clone.t

$ cd .. $ cd ..
Testing --noupdate with --updaterev (must abort): Testing --noupdate with --updaterev (must abort):
$ hg clone --noupdate --updaterev 1 a ua $ hg clone --noupdate --updaterev 1 a ua
abort: cannot specify both --noupdate and --updaterev abort: cannot specify both --noupdate and --updaterev
[255] [10]
Testing clone -u: Testing clone -u:
$ hg clone -u . a ua $ hg clone -u . a ua
updating to branch stable updating to branch stable
2 files updated, 0 files merged, 0 files removed, 0 files unresolved 2 files updated, 0 files merged, 0 files removed, 0 files unresolved

tests/test-commandserver.t

... ch, data = readchannel(server) ... ch, data = readchannel(server)
... bprint(b'%c, %r' % (ch, data)) ... bprint(b'%c, %r' % (ch, data))
... # run an arbitrary command to make sure the next thing the server ... # run an arbitrary command to make sure the next thing the server
... # sends isn't part of the hello message ... # sends isn't part of the hello message
... runcommand(server, [b'id']) ... runcommand(server, [b'id'])
o, 'capabilities: getencoding runcommand\nencoding: *\npid: *' (glob) o, 'capabilities: getencoding runcommand\nencoding: *\npid: *' (glob)
*** runcommand id *** runcommand id
abort: there is no Mercurial repository here (.hg not found) abort: there is no Mercurial repository here (.hg not found)
[255] [10]
>>> from hgclient import check, readchannel, runcommand >>> from hgclient import check, readchannel, runcommand
>>> @check >>> @check
... def startwithoutrepo(server): ... def startwithoutrepo(server):
... readchannel(server) ... readchannel(server)
... runcommand(server, [b'init', b'repo2']) ... runcommand(server, [b'init', b'repo2'])
... runcommand(server, [b'id', b'-R', b'repo2']) ... runcommand(server, [b'id', b'-R', b'repo2'])
*** runcommand init repo2 *** runcommand init repo2

tests/test-commit-amend.t

parent: 1:43f1ba15f28a tip parent: 1:43f1ba15f28a tip
amend base1 amend base1
branch: default branch: default
commit: 1 modified, 1 added, 1 unknown commit: 1 modified, 1 added, 1 unknown
update: (current) update: (current)
phases: 2 draft phases: 2 draft
$ HGEDITOR="\"sh\" \"`pwd`/editor.sh\"" hg commit --amend $ HGEDITOR="\"sh\" \"`pwd`/editor.sh\"" hg commit --amend
abort: empty commit message abort: empty commit message
[255] [10]
$ hg summary $ hg summary
parent: 1:43f1ba15f28a tip parent: 1:43f1ba15f28a tip
amend base1 amend base1
branch: default branch: default
commit: 1 modified, 1 added, 1 unknown commit: 1 modified, 1 added, 1 unknown
update: (current) update: (current)
phases: 2 draft phases: 2 draft
$ cat > editor.sh << '__EOF__' $ cat > editor.sh << '__EOF__'
> #!/bin/sh > #!/bin/sh
> echo "" > "$1" > echo "" > "$1"
> __EOF__ > __EOF__
$ echo a >> a $ echo a >> a
$ HGEDITOR="\"sh\" \"`pwd`/editor.sh\"" hg commit --amend $ HGEDITOR="\"sh\" \"`pwd`/editor.sh\"" hg commit --amend
abort: empty commit message abort: empty commit message
[255] [10]
$ hg book $ hg book
book1 1:a3b65065808c book1 1:a3b65065808c
* book2 1:a3b65065808c * book2 1:a3b65065808c
$ hg revert -Caq $ hg revert -Caq
$ rm editor.sh $ rm editor.sh
$ echo '[defaults]' >> $HGRCPATH $ echo '[defaults]' >> $HGRCPATH
$ echo "commit=-d '0 0'" >> $HGRCPATH $ echo "commit=-d '0 0'" >> $HGRCPATH
$ hg up -q default $ hg up -q default
$ hg branch closewithamend $ hg branch closewithamend
marked working directory as branch closewithamend marked working directory as branch closewithamend
$ echo foo > foo $ echo foo > foo
$ hg add foo $ hg add foo
$ hg ci -m.. $ hg ci -m..
$ hg ci --amend --close-branch -m 'closing' $ hg ci --amend --close-branch -m 'closing'
abort: can only close branch heads abort: can only close branch heads
[255] [10]
This silliness fails: This silliness fails:
$ hg branch silliness $ hg branch silliness
marked working directory as branch silliness marked working directory as branch silliness
$ echo b >> b $ echo b >> b
$ hg ci --close-branch -m'open and close' $ hg ci --close-branch -m'open and close'
abort: branch "silliness" has no heads to close abort: branch "silliness" has no heads to close
[255] [10]
Test that amend with --secret creates new secret changeset forcibly Test that amend with --secret creates new secret changeset forcibly
--------------------------------------------------------------------- ---------------------------------------------------------------------
$ hg phase '.^::.' $ hg phase '.^::.'
29: draft 29: draft
30: draft 30: draft
$ hg commit --amend --secret -m 'amend as secret' -q $ hg commit --amend --secret -m 'amend as secret' -q

tests/test-commit-interactive.t

$ touch empty-rw $ touch empty-rw
$ hg add empty-rw $ hg add empty-rw
$ hg record --config ui.interactive=false $ hg record --config ui.interactive=false
abort: running non-interactively, use commit instead abort: running non-interactively, use commit instead
[255] [255]
$ hg commit -i --config ui.interactive=false $ hg commit -i --config ui.interactive=false
abort: running non-interactively abort: running non-interactively
[255] [10]
$ hg commit -i empty-rw<<EOF $ hg commit -i empty-rw<<EOF
> n > n
> EOF > EOF
diff --git a/empty-rw b/empty-rw diff --git a/empty-rw b/empty-rw
new file mode 100644 new file mode 100644
abort: empty commit message abort: empty commit message
[255] [10]
$ hg tip -p $ hg tip -p
changeset: -1:000000000000 changeset: -1:000000000000
tag: tip tag: tip
user: user:
date: Thu Jan 01 00:00:00 1970 +0000 date: Thu Jan 01 00:00:00 1970 +0000
Select files but no hunks Select files but no hunks
$ hg commit -i empty-rw<<EOF $ hg commit -i empty-rw<<EOF
> y > y
> n > n
> EOF > EOF
diff --git a/empty-rw b/empty-rw diff --git a/empty-rw b/empty-rw
new file mode 100644 new file mode 100644
abort: empty commit message abort: empty commit message
[255] [10]
$ hg tip -p $ hg tip -p
changeset: -1:000000000000 changeset: -1:000000000000
tag: tip tag: tip
user: user:
date: Thu Jan 01 00:00:00 1970 +0000 date: Thu Jan 01 00:00:00 1970 +0000
7 files updated, 0 files merged, 2 files removed, 0 files unresolved 7 files updated, 0 files merged, 2 files removed, 0 files unresolved
$ hg merge thatbranch $ hg merge thatbranch
1 files updated, 0 files merged, 0 files removed, 0 files unresolved 1 files updated, 0 files merged, 0 files removed, 0 files unresolved
(branch merge, don't forget to commit) (branch merge, don't forget to commit)
$ hg commit -i -m'will abort' $ hg commit -i -m'will abort'
abort: cannot partially commit a merge (use "hg commit" instead) abort: cannot partially commit a merge (use "hg commit" instead)
[255] [10]
$ hg up -C $ hg up -C
0 files updated, 0 files merged, 1 files removed, 0 files unresolved 0 files updated, 0 files merged, 1 files removed, 0 files unresolved
Editing patch (and ignoring trailing text) Editing patch (and ignoring trailing text)
$ cat > editor.sh << '__EOF__' $ cat > editor.sh << '__EOF__'
> sed -e 7d -e '5s/^-/ /' -e '/^# ---/i\ > sed -e 7d -e '5s/^-/ /' -e '/^# ---/i\
+This line has been added +This line has been added
record this change to 'editedfile'? record this change to 'editedfile'?
(enter ? for help) [Ynesfdaq?] e (enter ? for help) [Ynesfdaq?] e
patching file editedfile patching file editedfile
Hunk #1 FAILED at 0 Hunk #1 FAILED at 0
1 out of 1 hunks FAILED -- saving rejects to file editedfile.rej 1 out of 1 hunks FAILED -- saving rejects to file editedfile.rej
abort: patch failed to apply abort: patch failed to apply
[255] [10]
$ cat editedfile $ cat editedfile
This change will not be committed This change will not be committed
This is the second line This is the second line
This line has been added This line has been added
$ hg cat -r tip editedfile $ hg cat -r tip editedfile
This is the first line This is the first line
This change will be committed This change will be committed
This is the third line This is the third line
-This is the third line -This is the third line
+This change will not be committed +This change will not be committed
+This is the second line +This is the second line
+This line has been added +This line has been added
record this change to 'editedfile'? record this change to 'editedfile'?
(enter ? for help) [Ynesfdaq?] e (enter ? for help) [Ynesfdaq?] e
abort: error parsing patch: unhandled transition: range -> range abort: error parsing patch: unhandled transition: range -> range
[255] [10]
Exiting editor with status 1, ignores the edit but does not stop the recording Exiting editor with status 1, ignores the edit but does not stop the recording
session session
$ HGEDITOR=false hg commit -i <<EOF $ HGEDITOR=false hg commit -i <<EOF
> y > y
> e > e
> n > n
-This is the third line -This is the third line
+This change will not be committed +This change will not be committed
+This is the second line +This is the second line
+This line has been added +This line has been added
record this change to 'editedfile'? record this change to 'editedfile'?
(enter ? for help) [Ynesfdaq?] e (enter ? for help) [Ynesfdaq?] e
abort: error parsing patch: unhandled transition: file -> other abort: error parsing patch: unhandled transition: file -> other
[255] [10]
$ hg up -C $ hg up -C
1 files updated, 0 files merged, 0 files removed, 0 files unresolved 1 files updated, 0 files merged, 0 files removed, 0 files unresolved
With win32text With win32text
$ echo '[extensions]' >> .hg/hgrc $ echo '[extensions]' >> .hg/hgrc
$ echo 'win32text = ' >> .hg/hgrc $ echo 'win32text = ' >> .hg/hgrc

tests/test-commit-unresolved.t

merging A merging A
warning: conflicts while merging A! (edit, then use 'hg resolve --mark') warning: conflicts while merging A! (edit, then use 'hg resolve --mark')
1 files updated, 0 files merged, 0 files removed, 1 files unresolved 1 files updated, 0 files merged, 0 files removed, 1 files unresolved
use 'hg resolve' to retry unresolved file merges or 'hg merge --abort' to abandon use 'hg resolve' to retry unresolved file merges or 'hg merge --abort' to abandon
[1] [1]
$ hg merge --abort e4501 $ hg merge --abort e4501
abort: cannot specify a node with --abort abort: cannot specify a node with --abort
[255] [10]
$ hg merge --abort --rev e4501 $ hg merge --abort --rev e4501
abort: cannot specify both --abort and --rev abort: cannot specify both --abort and --rev
[255] [10]
#if abortcommand #if abortcommand
when in dry-run mode when in dry-run mode
$ hg abort --dry-run $ hg abort --dry-run
merge in progress, will be aborted merge in progress, will be aborted
#endif #endif
$ hg abort $ hg abort
68352a18a7c4 tip 68352a18a7c4 tip
$ hg merge -r 4 $ hg merge -r 4
2 files updated, 0 files merged, 0 files removed, 0 files unresolved 2 files updated, 0 files merged, 0 files removed, 0 files unresolved
(branch merge, don't forget to commit) (branch merge, don't forget to commit)
$ hg merge --preview --abort $ hg merge --preview --abort
abort: cannot specify both --abort and --preview abort: cannot specify both --abort and --preview
[255] [10]
$ hg abort $ hg abort
aborting the merge, updating back to 68352a18a7c4 aborting the merge, updating back to 68352a18a7c4
1 files updated, 0 files merged, 1 files removed, 0 files unresolved 1 files updated, 0 files merged, 1 files removed, 0 files unresolved
$ hg id $ hg id
68352a18a7c4 tip 68352a18a7c4 tip
$ cd .. $ cd ..

tests/test-commit.t

commit date test commit date test
$ hg init test $ hg init test
$ cd test $ cd test
$ echo foo > foo $ echo foo > foo
$ hg add foo $ hg add foo
$ cat > $TESTTMP/checkeditform.sh <<EOF $ cat > $TESTTMP/checkeditform.sh <<EOF
> env | grep HGEDITFORM > env | grep HGEDITFORM
> true > true
> EOF > EOF
$ HGEDITOR="sh $TESTTMP/checkeditform.sh" hg commit -m "" $ HGEDITOR="sh $TESTTMP/checkeditform.sh" hg commit -m ""
HGEDITFORM=commit.normal.normal HGEDITFORM=commit.normal.normal
abort: empty commit message abort: empty commit message
[255] [10]
$ hg commit -d '0 0' -m commit-1 $ hg commit -d '0 0' -m commit-1
$ echo foo >> foo $ echo foo >> foo
$ hg commit -d '1 4444444' -m commit-3 $ hg commit -d '1 4444444' -m commit-3
hg: parse error: impossible time zone offset: 4444444 hg: parse error: impossible time zone offset: 4444444
[255] [255]
$ hg commit -d '1 15.1' -m commit-4 $ hg commit -d '1 15.1' -m commit-4
hg: parse error: invalid date: '1\t15.1' hg: parse error: invalid date: '1\t15.1'
[255] [255]
HG: -- HG: --
HG: user: test HG: user: test
HG: branch 'default' HG: branch 'default'
HG: bookmark 'activebookmark' HG: bookmark 'activebookmark'
HG: added added HG: added added
HG: changed changed HG: changed changed
HG: removed removed HG: removed removed
abort: empty commit message abort: empty commit message
[255] [10]
test saving last-message.txt test saving last-message.txt
$ hg init sub $ hg init sub
$ echo a > sub/a $ echo a > sub/a
$ hg -R sub add sub/a $ hg -R sub add sub/a
$ cat > sub/.hg/hgrc <<EOF $ cat > sub/.hg/hgrc <<EOF
> [hooks] > [hooks]
$ HGEDITOR=cat hg commit -S -q $ HGEDITOR=cat hg commit -S -q
HG: this is "commit.normal" template HG: this is "commit.normal" template
HG: Leave message empty to abort commit. HG: Leave message empty to abort commit.
HG: bookmark 'activebookmark' is activated HG: bookmark 'activebookmark' is activated
HG: subrepo 'sub' is changed HG: subrepo 'sub' is changed
HG: subrepo 'sub2' is changed HG: subrepo 'sub2' is changed
abort: empty commit message abort: empty commit message
[255] [10]
$ cat >> .hg/hgrc <<EOF $ cat >> .hg/hgrc <<EOF
> [committemplate] > [committemplate]
> changeset.commit.normal = > changeset.commit.normal =
> # now, "changeset.commit" should be chosen for "hg commit" > # now, "changeset.commit" should be chosen for "hg commit"
> EOF > EOF
$ hg bookmark --inactive activebookmark $ hg bookmark --inactive activebookmark
$ hg forget .hgsub $ hg forget .hgsub
$ HGEDITOR=cat hg commit -q $ HGEDITOR=cat hg commit -q
HG: this is "commit" template HG: this is "commit" template
HG: Leave message empty to abort commit. HG: Leave message empty to abort commit.
HG: no bookmark is activated HG: no bookmark is activated
abort: empty commit message abort: empty commit message
[255] [10]
$ cat >> .hg/hgrc <<EOF $ cat >> .hg/hgrc <<EOF
> [committemplate] > [committemplate]
> changeset.commit = > changeset.commit =
> # now, "changeset" should be chosen for "hg commit" > # now, "changeset" should be chosen for "hg commit"
> EOF > EOF
$ HGEDITOR=cat hg commit -q $ HGEDITOR=cat hg commit -q
HG: this is customized commit template HG: this is customized commit template
HG: Leave message empty to abort commit. HG: Leave message empty to abort commit.
HG: no bookmark is activated HG: no bookmark is activated
abort: empty commit message abort: empty commit message
[255] [10]
$ cat >> .hg/hgrc <<EOF $ cat >> .hg/hgrc <<EOF
> [committemplate] > [committemplate]
> changeset = {desc} > changeset = {desc}
> HG: mods={file_mods} > HG: mods={file_mods}
> HG: adds={file_adds} > HG: adds={file_adds}
> HG: dels={file_dels} > HG: dels={file_dels}
> HG: files={files} > HG: files={files}
> EOF > EOF
$ cat > $TESTTMP/notouching.sh <<EOF $ cat > $TESTTMP/notouching.sh <<EOF
> true > true
> EOF > EOF
$ echo foo2 > foo2 $ echo foo2 > foo2
$ hg add foo2 $ hg add foo2
$ HGEDITOR="sh $TESTTMP/notouching.sh" hg commit $ HGEDITOR="sh $TESTTMP/notouching.sh" hg commit
abort: commit message unchanged abort: commit message unchanged
[255] [10]
$ cd .. $ cd ..
test that text below the --- >8 --- special string is ignored test that text below the --- >8 --- special string is ignored
$ cat <<'EOF' > $TESTTMP/lowercaseline.sh $ cat <<'EOF' > $TESTTMP/lowercaseline.sh
> cat $1 | sed s/LINE/line/ | tee $1.new > cat $1 | sed s/LINE/line/ | tee $1.new
> mv $1.new $1 > mv $1.new $1
> HG: {extramsg} > HG: {extramsg}
> HG: ------------------------ >8 ------------------------ > HG: ------------------------ >8 ------------------------
> {diff()} > {diff()}
> EOF > EOF
$ echo foo2 > foo2 $ echo foo2 > foo2
$ hg add foo2 $ hg add foo2
$ HGEDITOR="sh $TESTTMP/notouching.sh" hg ci $ HGEDITOR="sh $TESTTMP/notouching.sh" hg ci
abort: commit message unchanged abort: commit message unchanged
[255] [10]
$ HGEDITOR="sh $TESTTMP/lowercaseline.sh" hg ci $ HGEDITOR="sh $TESTTMP/lowercaseline.sh" hg ci
first line first line
HG: this is customized commit template HG: this is customized commit template
HG: Leave message empty to abort commit. HG: Leave message empty to abort commit.
HG: ------------------------ >8 ------------------------ HG: ------------------------ >8 ------------------------
diff -r e63c23eaa88a foo2 diff -r e63c23eaa88a foo2
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/foo2 Thu Jan 01 00:00:00 1970 +0000 +++ b/foo2 Thu Jan 01 00:00:00 1970 +0000

tests/test-config.t

$ hg showconfig paths $ hg showconfig paths
paths.foo:suboption=~/foo paths.foo:suboption=~/foo
paths.foo=$TESTTMP/foo paths.foo=$TESTTMP/foo
edit failure edit failure
$ HGEDITOR=false hg config --edit $ HGEDITOR=false hg config --edit
abort: edit failed: false exited with status 1 abort: edit failed: false exited with status 1
[255] [10]
config affected by environment variables config affected by environment variables
$ EDITOR=e1 VISUAL=e2 hg config --debug | grep 'ui\.editor' $ EDITOR=e1 VISUAL=e2 hg config --debug | grep 'ui\.editor'
$VISUAL: ui.editor=e2 $VISUAL: ui.editor=e2
$ VISUAL=e2 hg config --debug --config ui.editor=e3 | grep 'ui\.editor' $ VISUAL=e2 hg config --debug --config ui.editor=e3 | grep 'ui\.editor'
--config: ui.editor=e3 --config: ui.editor=e3

tests/test-confused-revert.t

A b A b
R a R a
Revert should fail: Revert should fail:
$ hg revert $ hg revert
abort: uncommitted merge with no revision specified abort: uncommitted merge with no revision specified
(use 'hg update' or see 'hg help revert') (use 'hg update' or see 'hg help revert')
[255] [10]
Revert should be ok now: Revert should be ok now:
$ hg revert -r2 --all $ hg revert -r2 --all
forgetting b forgetting b
undeleting a undeleting a
Should show b unknown and a marked modified (merged): Should show b unknown and a marked modified (merged):

tests/test-copy.t

$ cd part2 $ cd part2
$ hg init $ hg init
$ echo foo > foo $ echo foo > foo
should fail - foo is not managed should fail - foo is not managed
$ hg mv foo bar $ hg mv foo bar
foo: not copying - file is not managed foo: not copying - file is not managed
abort: no files to copy abort: no files to copy
[255] [10]
$ hg st -A $ hg st -A
? foo ? foo
respects ui.relative-paths respects ui.relative-paths
$ mkdir dir $ mkdir dir
$ cd dir $ cd dir
$ hg mv ../foo ../bar $ hg mv ../foo ../bar
../foo: not copying - file is not managed ../foo: not copying - file is not managed
abort: no files to copy abort: no files to copy
[255] [10]
$ hg mv ../foo ../bar --config ui.relative-paths=yes $ hg mv ../foo ../bar --config ui.relative-paths=yes
../foo: not copying - file is not managed ../foo: not copying - file is not managed
abort: no files to copy abort: no files to copy
[255] [10]
$ hg mv ../foo ../bar --config ui.relative-paths=no $ hg mv ../foo ../bar --config ui.relative-paths=no
foo: not copying - file is not managed foo: not copying - file is not managed
abort: no files to copy abort: no files to copy
[255] [10]
$ cd .. $ cd ..
$ rmdir dir $ rmdir dir
$ hg add foo $ hg add foo
dry-run; print a warning that this is not a real copy; foo is added dry-run; print a warning that this is not a real copy; foo is added
$ hg mv --dry-run foo bar $ hg mv --dry-run foo bar
foo has not been committed yet, so no copy data will be stored for bar. foo has not been committed yet, so no copy data will be stored for bar.
$ hg st -A $ hg st -A
A foo A foo

tests/test-dirstate-backup.t

Set up Set up
$ hg init repo $ hg init repo
$ cd repo $ cd repo
Try to import an empty patch Try to import an empty patch
$ hg import --no-commit - <<EOF $ hg import --no-commit - <<EOF
> EOF > EOF
applying patch from stdin applying patch from stdin
abort: stdin: no diffs found abort: stdin: no diffs found
[255] [10]
No dirstate backups are left behind No dirstate backups are left behind
$ ls .hg/dirstate* | sort $ ls .hg/dirstate* | sort
.hg/dirstate .hg/dirstate

tests/test-export.t

$ hg export "" $ hg export ""
hg: parse error: empty query hg: parse error: empty query
[255] [255]
$ hg export 999 $ hg export 999
abort: unknown revision '999'! abort: unknown revision '999'!
[255] [255]
$ hg export "not all()" $ hg export "not all()"
abort: export requires at least one changeset abort: export requires at least one changeset
[255] [10]
Check for color output Check for color output
$ cat <<EOF >> $HGRCPATH $ cat <<EOF >> $HGRCPATH
> [color] > [color]
> mode = ansi > mode = ansi
> [extensions] > [extensions]
> color = > color =
> EOF > EOF

tests/test-fix-topology.t

immutable. We can fix orphans because their successors are still just orphans immutable. We can fix orphans because their successors are still just orphans
of the original obsolete parent. When obsolesence is off, we're just fixing and of the original obsolete parent. When obsolesence is off, we're just fixing and
replacing anything that isn't public. replacing anything that isn't public.
$ hg init fixall $ hg init fixall
$ cd fixall $ cd fixall
$ hg fix --all --working-dir $ hg fix --all --working-dir
abort: cannot specify both --working-dir and --all abort: cannot specify both --working-dir and --all
[255] [10]
#if obsstore-on #if obsstore-on
$ printf "one\n" > foo.whole $ printf "one\n" > foo.whole
$ hg commit -Aqm "first" $ hg commit -Aqm "first"
$ hg phase --public $ hg phase --public
$ hg tag --local root $ hg tag --local root
$ printf "two\n" > foo.whole $ printf "two\n" > foo.whole
$ hg commit -m "second" $ hg commit -m "second"

tests/test-graft-interrupted.t

merging d merging d
warning: conflicts while merging d! (edit, then use 'hg resolve --mark') warning: conflicts while merging d! (edit, then use 'hg resolve --mark')
abort: unresolved conflicts, can't continue abort: unresolved conflicts, can't continue
(use 'hg resolve' and 'hg graft --continue') (use 'hg resolve' and 'hg graft --continue')
[1] [1]
$ hg graft --stop --continue $ hg graft --stop --continue
abort: cannot specify both --stop and --continue abort: cannot specify both --stop and --continue
[255] [10]
$ hg graft --stop -U $ hg graft --stop -U
abort: cannot specify both --stop and --user abort: cannot specify both --stop and --user
[255] [10]
$ hg graft --stop --rev 4 $ hg graft --stop --rev 4
abort: cannot specify both --stop and --rev abort: cannot specify both --stop and --rev
[255] [10]
$ hg graft --stop --log $ hg graft --stop --log
abort: cannot specify both --stop and --log abort: cannot specify both --stop and --log
[255] [10]
$ hg graft --stop $ hg graft --stop
stopped the interrupted graft stopped the interrupted graft
working directory is now at a0deacecd59d working directory is now at a0deacecd59d
$ hg diff $ hg diff
$ hg log -Gr '.' $ hg log -Gr '.'
merging c merging c
warning: conflicts while merging c! (edit, then use 'hg resolve --mark') warning: conflicts while merging c! (edit, then use 'hg resolve --mark')
abort: unresolved conflicts, can't continue abort: unresolved conflicts, can't continue
(use 'hg resolve' and 'hg graft --continue') (use 'hg resolve' and 'hg graft --continue')
[1] [1]
$ hg graft --continue --abort $ hg graft --continue --abort
abort: cannot specify both --abort and --continue abort: cannot specify both --abort and --continue
[255] [10]
$ hg graft --abort --stop $ hg graft --abort --stop
abort: cannot specify both --abort and --stop abort: cannot specify both --abort and --stop
[255] [10]
$ hg graft --abort --currentuser $ hg graft --abort --currentuser
abort: cannot specify both --abort and --user abort: cannot specify both --abort and --user
[255] [10]
$ hg graft --abort --edit $ hg graft --abort --edit
abort: cannot specify both --abort and --edit abort: cannot specify both --abort and --edit
[255] [10]
#if abortcommand #if abortcommand
when in dry-run mode when in dry-run mode
$ hg abort --dry-run $ hg abort --dry-run
graft in progress, will be aborted graft in progress, will be aborted
#endif #endif
$ hg abort $ hg abort
|/ |/
o 0:cb9a9f314b8b a o 0:cb9a9f314b8b a
Check reporting when --no-commit used with non-applicable options: Check reporting when --no-commit used with non-applicable options:
$ hg graft 1 --no-commit -e $ hg graft 1 --no-commit -e
abort: cannot specify both --no-commit and --edit abort: cannot specify both --no-commit and --edit
[255] [10]
$ hg graft 1 --no-commit --log $ hg graft 1 --no-commit --log
abort: cannot specify both --no-commit and --log abort: cannot specify both --no-commit and --log
[255] [10]
$ hg graft 1 --no-commit -D $ hg graft 1 --no-commit -D
abort: cannot specify both --no-commit and --currentdate abort: cannot specify both --no-commit and --currentdate
[255] [10]
Test --no-commit is working: Test --no-commit is working:
$ hg graft 1 --no-commit $ hg graft 1 --no-commit
grafting 1:d2ae7f538514 "b" grafting 1:d2ae7f538514 "b"
$ hg log -GT "{rev}:{node|short} {desc}\n" $ hg log -GT "{rev}:{node|short} {desc}\n"
@ 2:d36c0562f908 c @ 2:d36c0562f908 c
| |

tests/test-graft.t

abort: no graft in progress abort: no graft in progress
[255] [255]
$ hg revert -r . -q e $ hg revert -r . -q e
Need to specify a rev: Need to specify a rev:
$ hg graft $ hg graft
abort: no revisions specified abort: no revisions specified
[255] [10]
Can't graft ancestor: Can't graft ancestor:
$ hg graft 1 2 $ hg graft 1 2
skipping ancestor revision 1:5d205f8b35b6 skipping ancestor revision 1:5d205f8b35b6
skipping ancestor revision 2:5c095ad7e90f skipping ancestor revision 2:5c095ad7e90f
[255] [255]
skipping ancestor revision 1:5d205f8b35b6 skipping ancestor revision 1:5d205f8b35b6
[255] [255]
Conflicting date/user options: Conflicting date/user options:
$ hg up -q 0 $ hg up -q 0
$ hg graft -U --user foo 2 $ hg graft -U --user foo 2
abort: cannot specify both --user and --currentuser abort: cannot specify both --user and --currentuser
[255] [10]
$ hg graft -D --date '0 0' 2 $ hg graft -D --date '0 0' 2
abort: cannot specify both --date and --currentdate abort: cannot specify both --date and --currentdate
[255] [10]
Can't graft with dirty wd: Can't graft with dirty wd:
$ hg up -q 0 $ hg up -q 0
$ echo foo > a $ echo foo > a
$ hg graft 1 $ hg graft 1
abort: uncommitted changes abort: uncommitted changes
[255] [255]
$ hg resolve -m e $ hg resolve -m e
(no more unresolved files) (no more unresolved files)
continue: hg graft --continue continue: hg graft --continue
Continue with a revision should fail: Continue with a revision should fail:
$ hg graft -c 6 $ hg graft -c 6
abort: can't specify --continue and revisions abort: can't specify --continue and revisions
[255] [10]
$ hg graft -c -r 6 $ hg graft -c -r 6
abort: can't specify --continue and revisions abort: can't specify --continue and revisions
[255] [10]
Continue for real, clobber usernames Continue for real, clobber usernames
$ hg graft -c -U $ hg graft -c -U
grafting 4:9c233e8e184d "4" grafting 4:9c233e8e184d "4"
grafting 3:4c60f11aa304 "3" grafting 3:4c60f11aa304 "3"
Compare with original: Compare with original:

tests/test-identify.t

#require serve #require serve
#if no-outer-repo #if no-outer-repo
no repo no repo
$ hg id $ hg id
abort: there is no Mercurial repository here (.hg not found) abort: there is no Mercurial repository here (.hg not found)
[255] [10]
#endif #endif
create repo create repo
$ hg init test $ hg init test
$ cd test $ cd test
$ echo a > a $ echo a > a
$ cat hg.pid >> $DAEMON_PIDS $ cat hg.pid >> $DAEMON_PIDS
$ hg id http://localhost:$HGPORT1/ $ hg id http://localhost:$HGPORT1/
cb9a9f314b8b cb9a9f314b8b
remote with rev number? remote with rev number?
$ hg id -n http://localhost:$HGPORT1/ $ hg id -n http://localhost:$HGPORT1/
abort: can't query remote revision number, branch, or tags abort: can't query remote revision number, branch, or tags
[255] [10]
remote with tags? remote with tags?
$ hg id -t http://localhost:$HGPORT1/ $ hg id -t http://localhost:$HGPORT1/
abort: can't query remote revision number, branch, or tags abort: can't query remote revision number, branch, or tags
[255] [10]
remote with branch? remote with branch?
$ hg id -b http://localhost:$HGPORT1/ $ hg id -b http://localhost:$HGPORT1/
abort: can't query remote revision number, branch, or tags abort: can't query remote revision number, branch, or tags
[255] [10]
test bookmark support test bookmark support
$ hg bookmark Y $ hg bookmark Y
$ hg bookmark Z $ hg bookmark Z
$ hg bookmarks $ hg bookmarks
Y 0:cb9a9f314b8b Y 0:cb9a9f314b8b
* Z 0:cb9a9f314b8b * Z 0:cb9a9f314b8b

tests/test-import-bypass.t

0 files updated, 0 files merged, 1 files removed, 0 files unresolved 0 files updated, 0 files merged, 1 files removed, 0 files unresolved
Test importing an existing revision Test importing an existing revision
(this also tests that "hg import" disallows combination of '--exact' (this also tests that "hg import" disallows combination of '--exact'
and '--edit') and '--edit')
$ hg import --bypass --exact --edit ../test.diff $ hg import --bypass --exact --edit ../test.diff
abort: cannot specify both --exact and --edit abort: cannot specify both --exact and --edit
[255] [10]
$ hg import --bypass --exact ../test.diff $ hg import --bypass --exact ../test.diff
applying ../test.diff applying ../test.diff
$ shortlog $ shortlog
o 1:4e322f7ce8e3 test 0 0 - foo - changea o 1:4e322f7ce8e3 test 0 0 - foo - changea
| |
o 0:07f494440405 test 0 0 - default - adda o 0:07f494440405 test 0 0 - default - adda
cc cc
+cc +cc
$ hg -q --config extensions.strip= strip . $ hg -q --config extensions.strip= strip .
Test unsupported combinations Test unsupported combinations
$ hg import --bypass --no-commit ../test.diff $ hg import --bypass --no-commit ../test.diff
abort: cannot specify both --no-commit and --bypass abort: cannot specify both --no-commit and --bypass
[255] [10]
$ hg import --bypass --similarity 50 ../test.diff $ hg import --bypass --similarity 50 ../test.diff
abort: cannot use --similarity with --bypass abort: cannot use --similarity with --bypass
[255] [10]
$ hg import --exact --prefix dir/ ../test.diff $ hg import --exact --prefix dir/ ../test.diff
abort: cannot specify both --exact and --prefix abort: cannot specify both --exact and --prefix
[255] [10]
Test commit editor Test commit editor
(this also tests that editor is invoked, if the patch doesn't contain (this also tests that editor is invoked, if the patch doesn't contain
the commit message, regardless of '--edit') the commit message, regardless of '--edit')
$ cat > ../test.diff <<EOF $ cat > ../test.diff <<EOF
> diff -r 07f494440405 -r 4e322f7ce8e3 a > diff -r 07f494440405 -r 4e322f7ce8e3 a
> --- a/a Thu Jan 01 00:00:00 1970 +0000 > --- a/a Thu Jan 01 00:00:00 1970 +0000
HG: Enter commit message. Lines beginning with 'HG:' are removed. HG: Enter commit message. Lines beginning with 'HG:' are removed.
HG: Leave message empty to abort commit. HG: Leave message empty to abort commit.
HG: -- HG: --
HG: user: test HG: user: test
HG: branch 'default' HG: branch 'default'
HG: changed a HG: changed a
abort: empty commit message abort: empty commit message
[255] [10]
Test patch.eol is handled Test patch.eol is handled
(this also tests that editor is not invoked for '--bypass', if the (this also tests that editor is not invoked for '--bypass', if the
commit message is explicitly specified, regardless of '--edit') commit message is explicitly specified, regardless of '--edit')
$ "$PYTHON" -c 'open("a", "wb").write(b"a\r\n")' $ "$PYTHON" -c 'open("a", "wb").write(b"a\r\n")'
$ hg ci -m makeacrlf $ hg ci -m makeacrlf
$ HGEDITOR=cat hg import -m 'should fail because of eol' --edit --bypass ../test.diff $ HGEDITOR=cat hg import -m 'should fail because of eol' --edit --bypass ../test.diff

tests/test-import.t

$ hg init a $ hg init a
$ mkdir a/d1 $ mkdir a/d1
$ mkdir a/d1/d2 $ mkdir a/d1/d2
$ echo line 1 > a/a $ echo line 1 > a/a
$ echo line 1 > a/d1/d2/a $ echo line 1 > a/d1/d2/a
$ hg --cwd a ci -Ama $ hg --cwd a ci -Ama
adding a adding a
adding d1/d2/a adding d1/d2/a
$ echo line 2 >> a/a $ echo line 2 >> a/a
$ hg --cwd a ci -u someone -d '1 0' -m'second change' $ hg --cwd a ci -u someone -d '1 0' -m'second change'
import with no args: import with no args:
$ hg --cwd a import $ hg --cwd a import
abort: need at least one patch to import abort: need at least one patch to import
[255] [10]
generate patches for the test generate patches for the test
$ hg --cwd a export tip > exported-tip.patch $ hg --cwd a export tip > exported-tip.patch
$ hg --cwd a diff -r0:1 > diffed-tip.patch $ hg --cwd a diff -r0:1 > diffed-tip.patch
import exported patch import exported patch
HG: Enter commit message. Lines beginning with 'HG:' are removed. HG: Enter commit message. Lines beginning with 'HG:' are removed.
HG: Leave message empty to abort commit. HG: Leave message empty to abort commit.
HG: -- HG: --
HG: user: test HG: user: test
HG: branch 'default' HG: branch 'default'
HG: changed a HG: changed a
abort: empty commit message abort: empty commit message
[255] [10]
Test avoiding editor invocation at applying the patch with --exact, Test avoiding editor invocation at applying the patch with --exact,
even if commit message is empty even if commit message is empty
$ echo a >> b/a $ echo a >> b/a
$ hg --cwd b commit -m ' ' $ hg --cwd b commit -m ' '
$ hg --cwd b tip -T "{node}\n" $ hg --cwd b tip -T "{node}\n"
d8804f3f5396d800812f579c8452796a5993bdb2 d8804f3f5396d800812f579c8452796a5993bdb2
adding file changes adding file changes
added 1 changesets with 2 changes to 2 files added 1 changesets with 2 changes to 2 files
new changesets 80971e65b431 new changesets 80971e65b431
updating to branch default updating to branch default
2 files updated, 0 files merged, 0 files removed, 0 files unresolved 2 files updated, 0 files merged, 0 files removed, 0 files unresolved
$ egrep -v '^(Subject|email)' msg.patch | hg --cwd b import - $ egrep -v '^(Subject|email)' msg.patch | hg --cwd b import -
applying patch from stdin applying patch from stdin
abort: empty commit message abort: empty commit message
[255] [10]
$ rm -r b $ rm -r b
hg export in email, should use patch header hg export in email, should use patch header
$ hg clone -r0 a b $ hg clone -r0 a b
adding changesets adding changesets
adding manifests adding manifests
$ rm -r b $ rm -r b
hg import --secret hg import --secret
$ hg clone -r0 a b -q $ hg clone -r0 a b -q
$ hg --cwd b import --no-commit --secret ../exported-tip.patch $ hg --cwd b import --no-commit --secret ../exported-tip.patch
abort: cannot specify both --no-commit and --secret abort: cannot specify both --no-commit and --secret
[255] [10]
$ hg --cwd b import --secret ../exported-tip.patch $ hg --cwd b import --secret ../exported-tip.patch
applying ../exported-tip.patch applying ../exported-tip.patch
$ hg --cwd b diff -c . --nodates $ hg --cwd b diff -c . --nodates
diff -r 80971e65b431 -r 1d4bd90af0e4 a diff -r 80971e65b431 -r 1d4bd90af0e4 a
--- a/a --- a/a
+++ b/a +++ b/a
@@ -1,1 +1,2 @@ @@ -1,1 +1,2 @@
line 1 line 1
$ rm b $ rm b
$ touch empty.patch $ touch empty.patch
$ hg import a.patch empty.patch $ hg import a.patch empty.patch
applying a.patch applying a.patch
applying empty.patch applying empty.patch
transaction abort! transaction abort!
rollback completed rollback completed
abort: empty.patch: no diffs found abort: empty.patch: no diffs found
[255] [10]
$ hg tip --template '{rev} {desc|firstline}\n' $ hg tip --template '{rev} {desc|firstline}\n'
0 commit 0 commit
$ hg -q status $ hg -q status
M a M a
$ cd .. $ cd ..
create file when source is not /dev/null create file when source is not /dev/null

tests/test-keyword.t

A b A b
Default keyword expansion including commit hook Default keyword expansion including commit hook
Interrupted commit should not change state or run commit hook Interrupted commit should not change state or run commit hook
$ hg --debug commit $ hg --debug commit
abort: empty commit message abort: empty commit message
[255] [10]
$ hg status $ hg status
A a A a
A b A b
Commit with several checks Commit with several checks
$ hg --debug commit -mabsym -u 'User Name <user@example.com>' $ hg --debug commit -mabsym -u 'User Name <user@example.com>'
committing files: committing files:
> firstline > firstline
> secondline > secondline
> EOF > EOF
Interrupted commit should not change state Interrupted commit should not change state
$ hg commit $ hg commit
abort: empty commit message abort: empty commit message
[255] [10]
$ hg status $ hg status
M a M a
? c ? c
? log ? log
Commit with multi-line message and custom expansion Commit with multi-line message and custom expansion
$ hg --debug commit -l log -d '2 0' -u 'User Name <user@example.com>' $ hg --debug commit -l log -d '2 0' -u 'User Name <user@example.com>'

tests/test-largefiles.t

$ hg clone file:// $ hg clone file://
abort: repository / not found! abort: repository / not found!
[255] [255]
Ensure base clone command argument validation Ensure base clone command argument validation
$ hg clone -U -u 0 a a-clone-failure $ hg clone -U -u 0 a a-clone-failure
abort: cannot specify both --noupdate and --updaterev abort: cannot specify both --noupdate and --updaterev
[255] [10]
$ hg clone --all-largefiles a ssh://localhost/a $ hg clone --all-largefiles a ssh://localhost/a
abort: --all-largefiles is incompatible with non-local destination ssh://localhost/a abort: --all-largefiles is incompatible with non-local destination ssh://localhost/a
[255] [255]
Test pulling with --all-largefiles flag. Also test that the largefiles are Test pulling with --all-largefiles flag. Also test that the largefiles are
downloaded from 'default' instead of 'default-push' when no source is specified downloaded from 'default' instead of 'default-push' when no source is specified
(issue3584) (issue3584)

tests/test-log-linerange.t

+3 +3
+4 +4
Regular file patterns are not allowed. Regular file patterns are not allowed.
$ hg log -f -L foo,5:7 -p bar $ hg log -f -L foo,5:7 -p bar
abort: FILE arguments are not compatible with --line-range option abort: FILE arguments are not compatible with --line-range option
[255] [10]
Option --rev acts as a restriction. Option --rev acts as a restriction.
$ hg log -f -L foo,5:7 -p -r 'desc(2)' $ hg log -f -L foo,5:7 -p -r 'desc(2)'
changeset: 2:63a884426fd0 changeset: 2:63a884426fd0
user: test user: test
date: Thu Jan 01 00:00:00 1970 +0000 date: Thu Jan 01 00:00:00 1970 +0000
summary: 2 -> 2+; added bar summary: 2 -> 2+; added bar
diff -r 91a3d3b6c546 -r dc865b608edf dir/binary diff -r 91a3d3b6c546 -r dc865b608edf dir/binary
Binary file dir/binary has changed Binary file dir/binary has changed
Option --follow is required. Option --follow is required.
$ hg log -L foo,5:7 $ hg log -L foo,5:7
abort: --line-range requires --follow abort: --line-range requires --follow
[255] [10]
Non-exact pattern kinds are not allowed. Non-exact pattern kinds are not allowed.
$ cd .. $ cd ..
$ hg log -f -L glob:*a*,1:2 $ hg log -f -L glob:*a*,1:2
hg: parse error: line range pattern 'glob:*a*' must match exactly one file hg: parse error: line range pattern 'glob:*a*' must match exactly one file
[255] [255]
We get an error for removed files. We get an error for removed files.
$ hg rm dir/baz $ hg rm dir/baz
$ hg ci -m 'remove baz' --quiet $ hg ci -m 'remove baz' --quiet
$ hg log -f -L dir/baz,5:7 -p $ hg log -f -L dir/baz,5:7 -p
abort: cannot follow file not in parent revision: "dir/baz" abort: cannot follow file not in parent revision: "dir/baz"
[255] [255]

tests/test-manifest.t

The next two calls are expected to abort: The next two calls are expected to abort:
$ hg manifest -r 2 $ hg manifest -r 2
abort: unknown revision '2'! abort: unknown revision '2'!
[255] [255]
$ hg manifest -r tip tip $ hg manifest -r tip tip
abort: please specify just one revision abort: please specify just one revision
[255] [10]
Testing the manifest full text cache utility Testing the manifest full text cache utility
-------------------------------------------- --------------------------------------------
Reminder of the manifest log content Reminder of the manifest log content
$ hg log --debug | grep 'manifest:' $ hg log --debug | grep 'manifest:'
manifest: 1:1e01206b1d2f72bd55f2a33fa8ccad74144825b7 manifest: 1:1e01206b1d2f72bd55f2a33fa8ccad74144825b7

tests/test-merge-default.t

] ]
$ hg commit -mm1 $ hg commit -mm1
Should fail because we didn't specify a revision (even though it would have Should fail because we didn't specify a revision (even though it would have
succeeded without this): succeeded without this):
$ hg merge --config commands.merge.require-rev=True $ hg merge --config commands.merge.require-rev=True
abort: configuration requires specifying revision to merge with abort: configuration requires specifying revision to merge with
[255] [10]
Should succeed - 2 heads: Should succeed - 2 heads:
$ hg merge -P $ hg merge -P
changeset: 3:ea9ff125ff88 changeset: 3:ea9ff125ff88
parent: 1:1846eede8b68 parent: 1:1846eede8b68
user: test user: test
date: Thu Jan 01 00:00:00 1970 +0000 date: Thu Jan 01 00:00:00 1970 +0000
} }
] ]
Should fail because we didn't specify a revision (even though it would have Should fail because we didn't specify a revision (even though it would have
failed without this due to being on tip, but this check comes first): failed without this due to being on tip, but this check comes first):
$ hg merge --config commands.merge.require-rev=True $ hg merge --config commands.merge.require-rev=True
abort: configuration requires specifying revision to merge with abort: configuration requires specifying revision to merge with
[255] [10]
Should fail because at tip: Should fail because at tip:
$ hg merge $ hg merge
abort: nothing to merge abort: nothing to merge
[255] [255]
$ hg up 0 $ hg up 0

tests/test-merge2.t

0 files updated, 0 files merged, 0 files removed, 0 files unresolved 0 files updated, 0 files merged, 0 files removed, 0 files unresolved
$ echo This is file b2 > b $ echo This is file b2 > b
$ hg commit -A -m "commit #2" $ hg commit -A -m "commit #2"
adding b adding b
created new head created new head
$ hg merge 'wdir()' $ hg merge 'wdir()'
abort: merging with the working copy has no effect abort: merging with the working copy has no effect
[255] [10]
$ cd .. $ cd ..

tests/test-merge9.t

$ hg resolve -l $ hg resolve -l
U bar U bar
R baz R baz
resolve all warning resolve all warning
$ hg resolve $ hg resolve
abort: no files or directories specified abort: no files or directories specified
(use --all to re-merge all unresolved files) (use --all to re-merge all unresolved files)
[255] [10]
resolve all resolve all
$ hg resolve -a $ hg resolve -a
merging bar merging bar
warning: conflicts while merging bar! (edit, then use 'hg resolve --mark') warning: conflicts while merging bar! (edit, then use 'hg resolve --mark')
[1] [1]
after after
$ hg resolve -l $ hg resolve -l
U bar U bar
R baz R baz
$ cd .. $ cd ..

tests/test-missing-capability.t

pulling from ssh://user@dummy/repo1 pulling from ssh://user@dummy/repo1
abort: other repository doesn't support revision lookup, so a rev cannot be specified. abort: other repository doesn't support revision lookup, so a rev cannot be specified.
[255] [255]
$ disable_cap pushkey $ disable_cap pushkey
$ hg pull ssh://user@dummy/repo1 -r tip -B a $ hg pull ssh://user@dummy/repo1 -r tip -B a
pulling from ssh://user@dummy/repo1 pulling from ssh://user@dummy/repo1
abort: remote bookmark a not found! abort: remote bookmark a not found!
[255] [10]

tests/test-mq-qrefresh-interactive.t

> loves > loves
> me > me
> EOF > EOF
$ hg add 1.txt 2.txt dir/a.txt $ hg add 1.txt 2.txt dir/a.txt
$ hg commit -m aaa $ hg commit -m aaa
$ hg qrecord --config ui.interactive=false patch $ hg qrecord --config ui.interactive=false patch
abort: running non-interactively, use qnew instead abort: running non-interactively, use qnew instead
[255] [10]
$ hg qnew -i --config ui.interactive=false patch $ hg qnew -i --config ui.interactive=false patch
abort: running non-interactively abort: running non-interactively
[255] [10]
$ hg qnew -d '0 0' patch $ hg qnew -d '0 0' patch
Changing files Changing files
$ sed -e 's/2/2 2/;s/4/4 4/' 1.txt > 1.txt.new $ sed -e 's/2/2 2/;s/4/4 4/' 1.txt > 1.txt.new
$ sed -e 's/b/b b/' 2.txt > 2.txt.new $ sed -e 's/b/b b/' 2.txt > 2.txt.new
$ sed -e 's/hello world/hello world!/' dir/a.txt > dir/a.txt.new $ sed -e 's/hello world/hello world!/' dir/a.txt > dir/a.txt.new
someone someone
up up
partial qrefresh partial qrefresh
$ hg qrefresh -i --config ui.interactive=false $ hg qrefresh -i --config ui.interactive=false
abort: running non-interactively abort: running non-interactively
[255] [10]
$ hg qrefresh -i -d '0 0' <<EOF $ hg qrefresh -i -d '0 0' <<EOF
> y > y
> y > y
> n > n
> y > y
> y > y
> n > n
> EOF > EOF

tests/test-newbranch.t

marked working directory as branch bar marked working directory as branch bar
$ hg ci -m "change branch name" $ hg ci -m "change branch name"
Branch shadowing: Branch shadowing:
$ hg branch default $ hg branch default
abort: a branch of the same name already exists abort: a branch of the same name already exists
(use 'hg update' to switch to it) (use 'hg update' to switch to it)
[255] [10]
$ hg branch -f default $ hg branch -f default
marked working directory as branch default marked working directory as branch default
$ hg ci -m "clear branch name" $ hg ci -m "clear branch name"
created new head created new head
There should be only one default branch head There should be only one default branch head
$ hg branch $ hg branch
foo foo
set existing branch name fails unless force - setting existing parent branch works without force: set existing branch name fails unless force - setting existing parent branch works without force:
$ hg branch bar $ hg branch bar
abort: a branch of the same name already exists abort: a branch of the same name already exists
(use 'hg update' to switch to it) (use 'hg update' to switch to it)
[255] [10]
$ hg branch -f bar $ hg branch -f bar
marked working directory as branch bar marked working directory as branch bar
$ hg branch foo $ hg branch foo
marked working directory as branch foo marked working directory as branch foo
$ echo bleah > a $ echo bleah > a
$ hg ci -m "modify a branch" $ hg ci -m "modify a branch"
$ hg merge default $ hg merge default
0 files updated, 0 files merged, 0 files removed, 0 files unresolved 0 files updated, 0 files merged, 0 files removed, 0 files unresolved
(branch merge, don't forget to commit) (branch merge, don't forget to commit)
$ hg branch $ hg branch
foo foo
set existing branch name where branch head is ancestor: set existing branch name where branch head is ancestor:
$ hg branch bar $ hg branch bar
abort: a branch of the same name already exists abort: a branch of the same name already exists
(use 'hg update' to switch to it) (use 'hg update' to switch to it)
[255] [10]
set (other) parent branch as branch name set (other) parent branch as branch name
$ hg branch default $ hg branch default
marked working directory as branch default marked working directory as branch default
set (first) parent branch as branch name set (first) parent branch as branch name

tests/test-parents.t

changeset: 3:02d851b7e549 changeset: 3:02d851b7e549
user: test user: test
date: Thu Jan 01 00:00:03 1970 +0000 date: Thu Jan 01 00:00:03 1970 +0000
summary: c summary: c
$ hg parents -r 3 c $ hg parents -r 3 c
abort: 'c' not found in manifest! abort: 'c' not found in manifest!
[255] [10]
$ hg parents -r 2 $ hg parents -r 2
changeset: 1:d786049f033a changeset: 1:d786049f033a
user: test user: test
date: Thu Jan 01 00:00:01 1970 +0000 date: Thu Jan 01 00:00:01 1970 +0000
summary: a summary: a
user: test user: test
date: Thu Jan 01 00:00:01 1970 +0000 date: Thu Jan 01 00:00:01 1970 +0000
summary: a summary: a
$ cd .. $ cd ..
$ hg parents -r 2 glob:a $ hg parents -r 2 glob:a
abort: can only specify an explicit filename abort: can only specify an explicit filename
[255] [10]
merge working dir with 2 parents, hg parents c merge working dir with 2 parents, hg parents c
$ HGMERGE=true hg merge $ HGMERGE=true hg merge
merging c merging c
0 files updated, 1 files merged, 0 files removed, 0 files unresolved 0 files updated, 1 files merged, 0 files removed, 0 files unresolved
(branch merge, don't forget to commit) (branch merge, don't forget to commit)

tests/test-push-warn.t

$ hg commit -m "3" $ hg commit -m "3"
Specifying a revset that evaluates to null will abort Specifying a revset that evaluates to null will abort
$ hg push -r '0 & 1' ../a $ hg push -r '0 & 1' ../a
pushing to ../a pushing to ../a
abort: specified revisions evaluate to an empty set abort: specified revisions evaluate to an empty set
(use different revision arguments) (use different revision arguments)
[255] [10]
$ hg push ../a $ hg push ../a
pushing to ../a pushing to ../a
searching for changes searching for changes
remote has heads on branch 'default' that are not known locally: 1c9246a22a0a remote has heads on branch 'default' that are not known locally: 1c9246a22a0a
abort: push creates new remote head 1e108cc5548c! abort: push creates new remote head 1e108cc5548c!
(pull and merge or see 'hg help push' for details about pushing new heads) (pull and merge or see 'hg help push' for details about pushing new heads)
[255] [255]

tests/test-push.t

> default = ../test-require-revs-dest > default = ../test-require-revs-dest
> [commands] > [commands]
> push.require-revs=1 > push.require-revs=1
> EOF > EOF
$ hg push $ hg push
pushing to $TESTTMP/test-require-revs-dest pushing to $TESTTMP/test-require-revs-dest
abort: no revisions specified to push abort: no revisions specified to push
(did you mean "hg push -r ."?) (did you mean "hg push -r ."?)
[255] [10]
$ hg push -r 0 $ hg push -r 0
pushing to $TESTTMP/test-require-revs-dest pushing to $TESTTMP/test-require-revs-dest
searching for changes searching for changes
adding changesets adding changesets
adding manifests adding manifests
adding file changes adding file changes
added 1 changesets with 1 changes to 1 files added 1 changesets with 1 changes to 1 files
$ hg bookmark -r 0 push-this-bookmark $ hg bookmark -r 0 push-this-bookmark
(merge or see 'hg help push' for details about pushing new heads) (merge or see 'hg help push' for details about pushing new heads)
[255] [255]
(demonstrate that even though we don't have anything to exchange, we're still (demonstrate that even though we don't have anything to exchange, we're still
showing the error) showing the error)
$ hg push $ hg push
pushing to $TESTTMP/test-require-revs-dest pushing to $TESTTMP/test-require-revs-dest
abort: no revisions specified to push abort: no revisions specified to push
(did you mean "hg push -r ."?) (did you mean "hg push -r ."?)
[255] [10]
$ hg push --config paths.default:pushrev=0 $ hg push --config paths.default:pushrev=0
pushing to $TESTTMP/test-require-revs-dest pushing to $TESTTMP/test-require-revs-dest
searching for changes searching for changes
no changes found no changes found
[1] [1]

tests/test-rebase-inmemory.t

| b | b
| |
o 0:cb9a9f314b8b test o 0:cb9a9f314b8b test
a a
Make sure it throws error while passing --continue or --abort with --dry-run Make sure it throws error while passing --continue or --abort with --dry-run
$ hg rebase -s 2 -d 6 -n --continue $ hg rebase -s 2 -d 6 -n --continue
abort: cannot specify both --continue and --dry-run abort: cannot specify both --continue and --dry-run
[255] [10]
$ hg rebase -s 2 -d 6 -n --abort $ hg rebase -s 2 -d 6 -n --abort
abort: cannot specify both --abort and --dry-run abort: cannot specify both --abort and --dry-run
[255] [10]
Check dryrun gives correct results when there is no conflict in rebasing Check dryrun gives correct results when there is no conflict in rebasing
$ hg rebase -s 2 -d 6 -n $ hg rebase -s 2 -d 6 -n
starting dry-run rebase; repository will not be changed starting dry-run rebase; repository will not be changed
rebasing 2:177f92b77385 "c" rebasing 2:177f92b77385 "c"
rebasing 3:055a42cdd887 "d" rebasing 3:055a42cdd887 "d"
rebasing 4:e860deea161a "e" rebasing 4:e860deea161a "e"
dry-run rebase completed successfully; run without -n/--dry-run to perform this rebase dry-run rebase completed successfully; run without -n/--dry-run to perform this rebase
| b | b
| |
o 0:cb9a9f314b8b test o 0:cb9a9f314b8b test
a a
Check it gives error when both --dryrun and --confirm is used: Check it gives error when both --dryrun and --confirm is used:
$ hg rebase -s 2 -d . --confirm --dry-run $ hg rebase -s 2 -d . --confirm --dry-run
abort: cannot specify both --confirm and --dry-run abort: cannot specify both --confirm and --dry-run
[255] [10]
$ hg rebase -s 2 -d . --confirm --abort $ hg rebase -s 2 -d . --confirm --abort
abort: cannot specify both --abort and --confirm abort: cannot specify both --abort and --confirm
[255] [10]
$ hg rebase -s 2 -d . --confirm --continue $ hg rebase -s 2 -d . --confirm --continue
abort: cannot specify both --continue and --confirm abort: cannot specify both --continue and --confirm
[255] [10]
Test --confirm option when there are no conflicts: Test --confirm option when there are no conflicts:
$ hg rebase -s 2 -d . --keep --config ui.interactive=True --confirm << EOF $ hg rebase -s 2 -d . --keep --config ui.interactive=True --confirm << EOF
> n > n
> EOF > EOF
starting in-memory rebase starting in-memory rebase
rebasing 2:177f92b77385 "c" rebasing 2:177f92b77385 "c"
rebasing 3:055a42cdd887 "d" rebasing 3:055a42cdd887 "d"

tests/test-rebase-obsolete.t

|/ |/
o 0:cd010b8cd998 A o 0:cd010b8cd998 A
$ cd .. $ cd ..
$ cp -R hidden stabilize $ cp -R hidden stabilize
$ cd stabilize $ cd stabilize
$ hg rebase --auto-orphans '0::' -d 10 $ hg rebase --auto-orphans '0::' -d 10
abort: cannot specify both --auto-orphans and --dest abort: cannot specify both --auto-orphans and --dest
[255] [10]
$ hg rebase --auto-orphans '0::' $ hg rebase --auto-orphans '0::'
rebasing 9:cf44d2f5a9f4 "D" rebasing 9:cf44d2f5a9f4 "D"
$ hg log -G $ hg log -G
o 12:7e3935feaa68 D o 12:7e3935feaa68 D
| |
o 11:0d8f238b634c C o 11:0d8f238b634c C
| |
o 10:7c6027df6a99 B o 10:7c6027df6a99 B
$ hg rebase -s 3 -d 5 $ hg rebase -s 3 -d 5
rebasing 3:055a42cdd887 "d" rebasing 3:055a42cdd887 "d"
merging d merging d
warning: conflicts while merging d! (edit, then use 'hg resolve --mark') warning: conflicts while merging d! (edit, then use 'hg resolve --mark')
unresolved conflicts (see 'hg resolve', then 'hg rebase --continue') unresolved conflicts (see 'hg resolve', then 'hg rebase --continue')
[240] [240]
$ hg rebase --stop --dry-run $ hg rebase --stop --dry-run
abort: cannot specify both --stop and --dry-run abort: cannot specify both --stop and --dry-run
[255] [10]
$ hg rebase -s 3 -d 5 $ hg rebase -s 3 -d 5
abort: rebase in progress abort: rebase in progress
(use 'hg rebase --continue', 'hg rebase --abort', or 'hg rebase --stop') (use 'hg rebase --continue', 'hg rebase --abort', or 'hg rebase --stop')
[255] [255]
$ hg rebase --stop --continue $ hg rebase --stop --continue
abort: cannot specify both --stop and --continue abort: cannot specify both --stop and --continue
[255] [10]
Test --stop moves bookmarks of original revisions to new rebased nodes: Test --stop moves bookmarks of original revisions to new rebased nodes:
====================================================================== ======================================================================
$ cd .. $ cd ..
$ hg init repo $ hg init repo
$ cd repo $ cd repo
$ echo a > a $ echo a > a

tests/test-rebase-parameters.t

$ cd a0 $ cd a0
$ hg rebase -s 8 -d 7 $ hg rebase -s 8 -d 7
nothing to rebase nothing to rebase
[1] [1]
$ hg rebase --continue --abort $ hg rebase --continue --abort
abort: cannot specify both --abort and --continue abort: cannot specify both --abort and --continue
[255] [10]
$ hg rebase --continue --collapse $ hg rebase --continue --collapse
abort: cannot use collapse with continue or abort abort: cannot use collapse with continue or abort
[255] [255]
$ hg rebase --continue --dest 4 $ hg rebase --continue --dest 4
abort: cannot specify both --continue and --dest abort: cannot specify both --continue and --dest
[255] [10]
$ hg rebase --base 5 --source 4 $ hg rebase --base 5 --source 4
abort: cannot specify both --source and --base abort: cannot specify both --source and --base
[255] [10]
$ hg rebase --rev 5 --source 4 $ hg rebase --rev 5 --source 4
abort: cannot specify both --rev and --source abort: cannot specify both --rev and --source
[255] [10]
$ hg rebase --base 5 --rev 4 $ hg rebase --base 5 --rev 4
abort: cannot specify both --rev and --base abort: cannot specify both --rev and --base
[255] [10]
$ hg rebase --base 6 $ hg rebase --base 6
abort: branch 'default' has 3 heads - please rebase to an explicit rev abort: branch 'default' has 3 heads - please rebase to an explicit rev
(run 'hg heads .' to see heads, specify destination with -d) (run 'hg heads .' to see heads, specify destination with -d)
[255] [255]
$ hg rebase --rev '1 & !1' --dest 8 $ hg rebase --rev '1 & !1' --dest 8
empty "rev" revision set - nothing to rebase empty "rev" revision set - nothing to rebase

tests/test-record.t

$ hg add empty-rw $ hg add empty-rw
$ hg record empty-rw<<EOF $ hg record empty-rw<<EOF
> n > n
> EOF > EOF
diff --git a/empty-rw b/empty-rw diff --git a/empty-rw b/empty-rw
new file mode 100644 new file mode 100644
abort: empty commit message abort: empty commit message
[255] [10]
$ hg tip -p $ hg tip -p
changeset: -1:000000000000 changeset: -1:000000000000
tag: tip tag: tip
user: user:
date: Thu Jan 01 00:00:00 1970 +0000 date: Thu Jan 01 00:00:00 1970 +0000

tests/test-remotefilelog-prefetch.t

[1] [1]
$ hg mv x x2 $ hg mv x x2
x2: not overwriting - file exists x2: not overwriting - file exists
('hg rename --after' to record the rename) ('hg rename --after' to record the rename)
[1] [1]
$ hg mv z2 z3 $ hg mv z2 z3
z2: not copying - file is not managed z2: not copying - file is not managed
abort: no files to copy abort: no files to copy
[255] [10]
$ find $CACHEDIR -type f | sort $ find $CACHEDIR -type f | sort
.. The following output line about files fetches is globed because it is .. The following output line about files fetches is globed because it is
.. flaky, the core the test is checked when checking the cache dir, so .. flaky, the core the test is checked when checking the cache dir, so
.. hopefully this flakyness is not hiding any actual bug. .. hopefully this flakyness is not hiding any actual bug.
$ hg revert -a -r 1 || true $ hg revert -a -r 1 || true
? files fetched over 1 fetches - (? misses, 0.00% hit ratio) over * (glob) ? files fetched over 1 fetches - (? misses, 0.00% hit ratio) over * (glob)
abort: z2@109c3a557a73: not found in manifest! (?) abort: z2@109c3a557a73: not found in manifest! (?)
$ find $CACHEDIR -type f | sort $ find $CACHEDIR -type f | sort

tests/test-rename-after-merge.t

$ hg log -r tip -C -v | grep copies $ hg log -r tip -C -v | grep copies
copies: b2 (b1) copies: b2 (b1)
Test marking/unmarking copies in merge commit Test marking/unmarking copies in merge commit
$ hg copy --forget --at-rev . b2 $ hg copy --forget --at-rev . b2
abort: cannot mark/unmark copy in merge commit abort: cannot mark/unmark copy in merge commit
[255] [10]
$ hg copy --after --at-rev . b1 b2 $ hg copy --after --at-rev . b1 b2
abort: cannot mark/unmark copy in merge commit abort: cannot mark/unmark copy in merge commit
[255] [10]
$ cd .. $ cd ..

tests/test-rename-rev.t

$ hg ci -m 'copy d1/b to d1/c and d1/d' $ hg ci -m 'copy d1/b to d1/c and d1/d'
$ hg st -C --change . $ hg st -C --change .
A d1/c A d1/c
d1/b d1/b
A d1/d A d1/d
# Errors out without --after for now # Errors out without --after for now
$ hg cp --at-rev . d1/b d1/d $ hg cp --at-rev . d1/b d1/d
abort: --at-rev requires --after abort: --at-rev requires --after
[255] [10]
# Errors out with non-existent source # Errors out with non-existent source
$ hg cp -A --at-rev . d1/non-existent d1/d $ hg cp -A --at-rev . d1/non-existent d1/d
d1/non-existent: no such file in rev 55d1fd85ef0a d1/non-existent: no such file in rev 55d1fd85ef0a
abort: no files to copy abort: no files to copy
[255] [10]
# Errors out with non-existent destination # Errors out with non-existent destination
$ hg cp -A --at-rev . d1/b d1/non-existent $ hg cp -A --at-rev . d1/b d1/non-existent
abort: d1/non-existent: copy destination does not exist in 8a9d70fa20c9 abort: d1/non-existent: copy destination does not exist in 8a9d70fa20c9
[255] [10]
# Successful invocation # Successful invocation
$ hg cp -A --at-rev . d1/b d1/d $ hg cp -A --at-rev . d1/b d1/d
saved backup bundle to $TESTTMP/.hg/strip-backup/8a9d70fa20c9-973ae357-copy.hg saved backup bundle to $TESTTMP/.hg/strip-backup/8a9d70fa20c9-973ae357-copy.hg
# New copy is recorded, and previously recorded copy is also still there # New copy is recorded, and previously recorded copy is also still there
$ hg st -C --change . $ hg st -C --change .
A d1/c A d1/c
d1/b d1/b
A d1/d A d1/d
adding d3/a adding d3/a
adding d3/b adding d3/b
adding d3/ba adding d3/ba
adding d3/d11/a1 adding d3/d11/a1
$ hg ci -m 'copy d1/ to d3/' $ hg ci -m 'copy d1/ to d3/'
created new head created new head
$ hg cp -A --at-rev . d1 d3 $ hg cp -A --at-rev . d1 d3
abort: d3: --at-rev does not support a directory as destination abort: d3: --at-rev does not support a directory as destination
[255] [10]

tests/test-rename.t

$ hg update -C $ hg update -C
3 files updated, 0 files merged, 0 files removed, 0 files unresolved 3 files updated, 0 files merged, 0 files removed, 0 files unresolved
$ rm d2/a d2/ba d2/d11/a1 $ rm d2/a d2/ba d2/d11/a1
attempt to move one file into a non-existent directory attempt to move one file into a non-existent directory
$ hg rename d1/a dx/ $ hg rename d1/a dx/
abort: destination dx/ is not a directory abort: destination dx/ is not a directory
[255] [10]
$ hg status -C $ hg status -C
$ hg update -C $ hg update -C
0 files updated, 0 files merged, 0 files removed, 0 files unresolved 0 files updated, 0 files merged, 0 files removed, 0 files unresolved
attempt to move potentially more than one file into a non-existent directory attempt to move potentially more than one file into a non-existent directory
$ hg rename 'glob:d1/**' dx $ hg rename 'glob:d1/**' dx
abort: with multiple sources, destination must be an existing directory abort: with multiple sources, destination must be an existing directory
[255] [10]
move every file under d1 to d2/d21 move every file under d1 to d2/d21
$ mkdir d2/d21 $ mkdir d2/d21
$ hg rename 'glob:d1/**' d2/d21 $ hg rename 'glob:d1/**' d2/d21
moving d1/a to d2/d21/a moving d1/a to d2/d21/a
moving d1/b to d2/d21/b moving d1/b to d2/d21/b
moving d1/ba to d2/d21/ba moving d1/ba to d2/d21/ba

tests/test-resolve.t

0 files updated, 0 files merged, 0 files removed, 2 files unresolved 0 files updated, 0 files merged, 0 files removed, 2 files unresolved
use 'hg resolve' to retry unresolved file merges or 'hg merge --abort' to abandon use 'hg resolve' to retry unresolved file merges or 'hg merge --abort' to abandon
[1] [1]
resolve without arguments should suggest --all resolve without arguments should suggest --all
$ hg resolve $ hg resolve
abort: no files or directories specified abort: no files or directories specified
(use --all to re-merge all unresolved files) (use --all to re-merge all unresolved files)
[255] [10]
resolve --all should re-merge all unresolved files resolve --all should re-merge all unresolved files
$ hg resolve --all $ hg resolve --all
merging file1 merging file1
merging file2 merging file2
warning: conflicts while merging file1! (edit, then use 'hg resolve --mark') warning: conflicts while merging file1! (edit, then use 'hg resolve --mark')
warning: conflicts while merging file2! (edit, then use 'hg resolve --mark') warning: conflicts while merging file2! (edit, then use 'hg resolve --mark')
[1] [1]
R file2 R file2
Testing the --re-merge flag Testing the --re-merge flag
$ hg resolve --unmark file1 $ hg resolve --unmark file1
$ hg resolve -l $ hg resolve -l
U file1 U file1
R file2 R file2
$ hg resolve --mark --re-merge $ hg resolve --mark --re-merge
abort: too many actions specified abort: too many actions specified
[255] [10]
$ hg resolve --re-merge --all $ hg resolve --re-merge --all
merging file1 merging file1
warning: conflicts while merging file1! (edit, then use 'hg resolve --mark') warning: conflicts while merging file1! (edit, then use 'hg resolve --mark')
[1] [1]
Explicit re-merge Explicit re-merge
$ hg resolve --unmark file1 $ hg resolve --unmark file1
$ hg resolve --config commands.resolve.explicit-re-merge=1 --all $ hg resolve --config commands.resolve.explicit-re-merge=1 --all
abort: no action specified abort: no action specified
(use --mark, --unmark, --list or --re-merge) (use --mark, --unmark, --list or --re-merge)
[255] [10]
$ hg resolve --config commands.resolve.explicit-re-merge=1 --re-merge --all $ hg resolve --config commands.resolve.explicit-re-merge=1 --re-merge --all
merging file1 merging file1
warning: conflicts while merging file1! (edit, then use 'hg resolve --mark') warning: conflicts while merging file1! (edit, then use 'hg resolve --mark')
[1] [1]
$ cd .. $ cd ..
====================================================== ======================================================
> interactive = True > interactive = True
> [commands] > [commands]
> resolve.confirm = True > resolve.confirm = True
> EOF > EOF
$ hg resolve $ hg resolve
abort: no files or directories specified abort: no files or directories specified
(use --all to re-merge all unresolved files) (use --all to re-merge all unresolved files)
[255] [10]
$ hg resolve --all << EOF $ hg resolve --all << EOF
> n > n
> EOF > EOF
re-merge all unresolved files (yn)? n re-merge all unresolved files (yn)? n
abort: user quit abort: user quit
[255] [255]
$ hg resolve --all << EOF $ hg resolve --all << EOF

tests/test-revert.t

$ hg init repo $ hg init repo
$ cd repo $ cd repo
$ echo 123 > a $ echo 123 > a
$ echo 123 > c $ echo 123 > c
$ echo 123 > e $ echo 123 > e
$ hg add a c e $ hg add a c e
$ hg commit -m "first" a c e $ hg commit -m "first" a c e
nothing changed nothing changed
$ hg revert $ hg revert
abort: no files or directories specified abort: no files or directories specified
(use --all to revert all files) (use --all to revert all files)
[255] [10]
$ hg revert --all $ hg revert --all
Introduce some changes and revert them Introduce some changes and revert them
-------------------------------------- --------------------------------------
$ echo 123 > b $ echo 123 > b
$ hg status $ hg status
$ echo b > b/b $ echo b > b/b
call `hg revert` with no file specified call `hg revert` with no file specified
--------------------------------------- ---------------------------------------
$ hg revert -rtip $ hg revert -rtip
abort: no files or directories specified abort: no files or directories specified
(use --all to revert all files, or 'hg update 1' to update) (use --all to revert all files, or 'hg update 1' to update)
[255] [10]
call `hg revert` with -I call `hg revert` with -I
--------------------------- ---------------------------
$ echo a >> a $ echo a >> a
$ hg revert -I a $ hg revert -I a
reverting a reverting a

tests/test-share-safe.t

$ echo a > a $ echo a > a
$ hg ci -Aqm "added a" $ hg ci -Aqm "added a"
$ echo b > b $ echo b > b
$ hg ci -Aqm "added b" $ hg ci -Aqm "added b"
$ HGEDITOR=cat hg config --shared $ HGEDITOR=cat hg config --shared
abort: repository is not shared; can't use --shared abort: repository is not shared; can't use --shared
[255] [10]
$ cd .. $ cd ..
Create a shared repo and check the requirements are shared and read correctly Create a shared repo and check the requirements are shared and read correctly
$ hg share source shared1 $ hg share source shared1
updating working directory updating working directory
2 files updated, 0 files merged, 0 files removed, 0 files unresolved 2 files updated, 0 files merged, 0 files removed, 0 files unresolved
$ cd shared1 $ cd shared1
$ cat .hg/requires $ cat .hg/requires

tests/test-shelve.t

--- a/a/a --- a/a/a
+++ b/a/a +++ b/a/a
@@ -1,1 +1,2 @@ @@ -1,1 +1,2 @@
a a
+a +a
$ hg shelve --list --addremove $ hg shelve --list --addremove
abort: options '--list' and '--addremove' may not be used together abort: options '--list' and '--addremove' may not be used together
[255] [10]
delete our older shelved change delete our older shelved change
$ hg shelve -d default $ hg shelve -d default
$ hg qfinish -a -q $ hg qfinish -a -q
ensure shelve backups aren't overwritten ensure shelve backups aren't overwritten
unshelving change 'default' unshelving change 'default'
$ hg shelve --list $ hg shelve --list
default (*)* changes to: create conflict (glob) default (*)* changes to: create conflict (glob)
$ hg shelve --cleanup $ hg shelve --cleanup
$ hg shelve --list $ hg shelve --list
$ hg shelve --cleanup --delete $ hg shelve --cleanup --delete
abort: options '--cleanup' and '--delete' may not be used together abort: options '--cleanup' and '--delete' may not be used together
[255] [10]
$ hg shelve --cleanup --patch $ hg shelve --cleanup --patch
abort: options '--cleanup' and '--patch' may not be used together abort: options '--cleanup' and '--patch' may not be used together
[255] [10]
$ hg shelve --cleanup --message MESSAGE $ hg shelve --cleanup --message MESSAGE
abort: options '--cleanup' and '--message' may not be used together abort: options '--cleanup' and '--message' may not be used together
[255] [10]
test bookmarks test bookmarks
$ hg bookmark test $ hg bookmark test
$ hg bookmark $ hg bookmark
\* test (4|13):33f7f61e6c5e (re) \* test (4|13):33f7f61e6c5e (re)
$ hg shelve $ hg shelve
shelved as test shelved as test
branch: default branch: default
bookmarks: *test bookmarks: *test
commit: 2 unknown (clean) commit: 2 unknown (clean)
update: (current) update: (current)
phases: 5 draft phases: 5 draft
$ hg shelve --delete --stat $ hg shelve --delete --stat
abort: options '--delete' and '--stat' may not be used together abort: options '--delete' and '--stat' may not be used together
[255] [10]
$ hg shelve --delete --name NAME $ hg shelve --delete --name NAME
abort: options '--delete' and '--name' may not be used together abort: options '--delete' and '--name' may not be used together
[255] [10]
Test interactive shelve Test interactive shelve
$ cat <<EOF >> $HGRCPATH $ cat <<EOF >> $HGRCPATH
> [ui] > [ui]
> interactive = true > interactive = true
> EOF > EOF
$ echo 'a' >> a/b $ echo 'a' >> a/b
$ cat a/a >> a/b $ cat a/a >> a/b
c c
x x
x x
$ cat foo/foo $ cat foo/foo
foo foo
a a
$ hg shelve --interactive --config ui.interactive=false $ hg shelve --interactive --config ui.interactive=false
abort: running non-interactively abort: running non-interactively
[255] [10]
$ hg shelve --interactive << EOF $ hg shelve --interactive << EOF
> y > y
> y > y
> n > n
> EOF > EOF
diff --git a/a/a b/a/a diff --git a/a/a b/a/a
2 hunks, 2 lines changed 2 hunks, 2 lines changed
examine changes to 'a/a'? examine changes to 'a/a'?
330882a04d2ce8487636b1fb292e5beea77fa1e3 330882a04d2ce8487636b1fb292e5beea77fa1e3
Test shelve --keep Test shelve --keep
$ hg unshelve $ hg unshelve
unshelving change 'default' unshelving change 'default'
$ hg shelve --keep --list $ hg shelve --keep --list
abort: options '--list' and '--keep' may not be used together abort: options '--list' and '--keep' may not be used together
[255] [10]
$ hg shelve --keep --patch $ hg shelve --keep --patch
abort: options '--patch' and '--keep' may not be used together abort: options '--patch' and '--keep' may not be used together
[255] [10]
$ hg shelve --keep --delete $ hg shelve --keep --delete
abort: options '--delete' and '--keep' may not be used together abort: options '--delete' and '--keep' may not be used together
[255] [10]
$ hg shelve --keep $ hg shelve --keep
shelved as default shelved as default
$ hg diff $ hg diff
diff --git a/jungle b/jungle diff --git a/jungle b/jungle
new file mode 100644 new file mode 100644
--- /dev/null --- /dev/null
+++ b/jungle +++ b/jungle
@@ -0,0 +1,1 @@ @@ -0,0 +1,1 @@

tests/test-simple-update.t

$ hg manifest --debug $ hg manifest --debug
6f4310b00b9a147241b071a60c28a650827fb03d 644 foo 6f4310b00b9a147241b071a60c28a650827fb03d 644 foo
update to rev 0 with a date update to rev 0 with a date
$ hg upd -d foo 0 $ hg upd -d foo 0
abort: you can't specify a revision and a date abort: you can't specify a revision and a date
[255] [10]
update by date update by date
$ hg update -d '<1970-01-01 00:00:02 +0000' $ hg update -d '<1970-01-01 00:00:02 +0000'
found revision 1 from Thu Jan 01 00:00:01 1970 +0000 found revision 1 from Thu Jan 01 00:00:01 1970 +0000
0 files updated, 0 files merged, 0 files removed, 0 files unresolved 0 files updated, 0 files merged, 0 files removed, 0 files unresolved
$ hg update -d '<1970-01-01 00:00:01 +0000' $ hg update -d '<1970-01-01 00:00:01 +0000'
found revision 1 from Thu Jan 01 00:00:01 1970 +0000 found revision 1 from Thu Jan 01 00:00:01 1970 +0000
0 files updated, 0 files merged, 0 files removed, 0 files unresolved 0 files updated, 0 files merged, 0 files removed, 0 files unresolved
$ hg update -d '<1970-01-01 00:00:00 +0000' $ hg update -d '<1970-01-01 00:00:00 +0000'
found revision 0 from Thu Jan 01 00:00:00 1970 +0000 found revision 0 from Thu Jan 01 00:00:00 1970 +0000
1 files updated, 0 files merged, 0 files removed, 0 files unresolved 1 files updated, 0 files merged, 0 files removed, 0 files unresolved
$ hg update -d '>1970-01-01 00:00:02 +0000' $ hg update -d '>1970-01-01 00:00:02 +0000'
abort: revision matching date not found abort: revision matching date not found
[255] [10]
$ hg update -d '>1970-01-01 00:00:01 +0000' $ hg update -d '>1970-01-01 00:00:01 +0000'
found revision 1 from Thu Jan 01 00:00:01 1970 +0000 found revision 1 from Thu Jan 01 00:00:01 1970 +0000
1 files updated, 0 files merged, 0 files removed, 0 files unresolved 1 files updated, 0 files merged, 0 files removed, 0 files unresolved
$ hg update -d '>1970-01-01 00:00:00 +0000' $ hg update -d '>1970-01-01 00:00:00 +0000'
found revision 1 from Thu Jan 01 00:00:01 1970 +0000 found revision 1 from Thu Jan 01 00:00:01 1970 +0000
0 files updated, 0 files merged, 0 files removed, 0 files unresolved 0 files updated, 0 files merged, 0 files removed, 0 files unresolved
update to default destination (with empty revspec) update to default destination (with empty revspec)

tests/test-status-terse.t

? x/ ? x/
$ hg status --terse madric $ hg status --terse madric
? a ? a
? b ? b
? x/aa.o ? x/aa.o
? x/bb.o ? x/bb.o
$ hg status --terse f $ hg status --terse f
abort: 'f' not recognized abort: 'f' not recognized
[255] [10]
Add a .hgignore so that we can also have ignored files Add a .hgignore so that we can also have ignored files
$ echo ".*\.o" > .hgignore $ echo ".*\.o" > .hgignore
$ hg status $ hg status
? .hgignore ? .hgignore
? a ? a
? b ? b
? x/m/ ? x/m/
? x/n/ ? x/n/
? y/ ? y/
Trying with --rev Trying with --rev
$ hg status --terse marduic --rev 0 --rev 1 $ hg status --terse marduic --rev 0 --rev 1
abort: cannot use --terse with --rev abort: cannot use --terse with --rev
[255] [10]
Config item to set the default terseness Config item to set the default terseness
$ cat <<EOF >> $HGRCPATH $ cat <<EOF >> $HGRCPATH
> [commands] > [commands]
> status.terse = u > status.terse = u
> EOF > EOF
$ hg status -mu $ hg status -mu
M x/aa M x/aa

tests/test-subrepo-recursion.t

summary: 3-4-2 summary: 3-4-2
comparing with $TESTTMP/repo2/foo/bar comparing with $TESTTMP/repo2/foo/bar
searching for changes searching for changes
no changes found no changes found
$ hg incoming -S --bundle incoming.hg $ hg incoming -S --bundle incoming.hg
abort: cannot specify both --subrepos and --bundle abort: cannot specify both --subrepos and --bundle
[255] [10]
Test missing subrepo: Test missing subrepo:
$ rm -r foo $ rm -r foo
$ hg status -S $ hg status -S
warning: error "unknown revision '65903cebad86f1a84bd4f1134f62fa7dcb7a1c98'" in subrepository "foo" warning: error "unknown revision '65903cebad86f1a84bd4f1134f62fa7dcb7a1c98'" in subrepository "foo"
Issue2619: IndexError: list index out of range on hg add with subrepos Issue2619: IndexError: list index out of range on hg add with subrepos

tests/test-tag.t

tag: tip tag: tip
user: test user: test
date: Thu Jan 01 00:00:00 1970 +0000 date: Thu Jan 01 00:00:00 1970 +0000
summary: test summary: test
$ hg tag ' ' $ hg tag ' '
abort: tag names cannot consist entirely of whitespace abort: tag names cannot consist entirely of whitespace
[255] [10]
(this tests also that editor is not invoked, if '--edit' is not (this tests also that editor is not invoked, if '--edit' is not
specified) specified)
$ HGEDITOR=cat hg tag "bleah" $ HGEDITOR=cat hg tag "bleah"
hook: tag changes detected hook: tag changes detected
hook: +A acb14030fe0a21b60322c440ad2d20cf7685a376 bleah hook: +A acb14030fe0a21b60322c440ad2d20cf7685a376 bleah
$ hg history $ hg history
$ hg tag "bleah2" $ hg tag "bleah2"
abort: working copy of .hgtags is changed abort: working copy of .hgtags is changed
(please commit .hgtags manually) (please commit .hgtags manually)
[255] [255]
$ hg revert .hgtags $ hg revert .hgtags
$ hg tag -r 0 x y z y y z $ hg tag -r 0 x y z y y z
abort: tag names must be unique abort: tag names must be unique
[255] [10]
$ hg tag tap nada dot tip $ hg tag tap nada dot tip
abort: the name 'tip' is reserved abort: the name 'tip' is reserved
[255] [255]
$ hg tag . $ hg tag .
abort: the name '.' is reserved abort: the name '.' is reserved
[255] [255]
$ hg tag null $ hg tag null
abort: the name 'null' is reserved abort: the name 'null' is reserved
[255] [255]
$ hg tag "bleah" $ hg tag "bleah"
abort: tag 'bleah' already exists (use -f to force) abort: tag 'bleah' already exists (use -f to force)
[255] [10]
$ hg tag "blecch" "bleah" $ hg tag "blecch" "bleah"
abort: tag 'bleah' already exists (use -f to force) abort: tag 'bleah' already exists (use -f to force)
[255] [10]
$ hg tag --remove "blecch" $ hg tag --remove "blecch"
abort: tag 'blecch' does not exist abort: tag 'blecch' does not exist
[255] [10]
$ hg tag --remove "bleah" "blecch" "blough" $ hg tag --remove "bleah" "blecch" "blough"
abort: tag 'blecch' does not exist abort: tag 'blecch' does not exist
[255] [10]
$ hg tag -r 0 "bleah0" $ hg tag -r 0 "bleah0"
hook: tag changes detected hook: tag changes detected
hook: +A acb14030fe0a21b60322c440ad2d20cf7685a376 bleah0 hook: +A acb14030fe0a21b60322c440ad2d20cf7685a376 bleah0
$ hg tag -l -r 1 "bleah1" $ hg tag -l -r 1 "bleah1"
$ hg tag gack gawk gorp $ hg tag gack gawk gorp
hook: tag changes detected hook: tag changes detected
hook: +A 336fccc858a4eb69609a291105009e484a6b6b8d gack hook: +A 336fccc858a4eb69609a291105009e484a6b6b8d gack
hook: +A 336fccc858a4eb69609a291105009e484a6b6b8d gawk hook: +A 336fccc858a4eb69609a291105009e484a6b6b8d gawk
hook: +A 336fccc858a4eb69609a291105009e484a6b6b8d gorp hook: +A 336fccc858a4eb69609a291105009e484a6b6b8d gorp
$ hg tag -f gack $ hg tag -f gack
hook: tag changes detected hook: tag changes detected
hook: -M 336fccc858a4eb69609a291105009e484a6b6b8d gack hook: -M 336fccc858a4eb69609a291105009e484a6b6b8d gack
hook: +M 799667b6f2d9b957f73fa644a918c2df22bab58f gack hook: +M 799667b6f2d9b957f73fa644a918c2df22bab58f gack
$ hg tag --remove gack gorp $ hg tag --remove gack gorp
hook: tag changes detected hook: tag changes detected
hook: -R 799667b6f2d9b957f73fa644a918c2df22bab58f gack hook: -R 799667b6f2d9b957f73fa644a918c2df22bab58f gack
hook: -R 336fccc858a4eb69609a291105009e484a6b6b8d gorp hook: -R 336fccc858a4eb69609a291105009e484a6b6b8d gorp
$ hg tag "bleah " $ hg tag "bleah "
abort: tag 'bleah' already exists (use -f to force) abort: tag 'bleah' already exists (use -f to force)
[255] [10]
$ hg tag " bleah" $ hg tag " bleah"
abort: tag 'bleah' already exists (use -f to force) abort: tag 'bleah' already exists (use -f to force)
[255] [10]
$ hg tag " bleah" $ hg tag " bleah"
abort: tag 'bleah' already exists (use -f to force) abort: tag 'bleah' already exists (use -f to force)
[255] [10]
$ hg tag -r 0 " bleahbleah " $ hg tag -r 0 " bleahbleah "
hook: tag changes detected hook: tag changes detected
hook: +A acb14030fe0a21b60322c440ad2d20cf7685a376 bleahbleah hook: +A acb14030fe0a21b60322c440ad2d20cf7685a376 bleahbleah
$ hg tag -r 0 " bleah bleah " $ hg tag -r 0 " bleah bleah "
hook: tag changes detected hook: tag changes detected
hook: +A acb14030fe0a21b60322c440ad2d20cf7685a376 bleah bleah hook: +A acb14030fe0a21b60322c440ad2d20cf7685a376 bleah bleah
$ cat .hgtags $ cat .hgtags
tagging on a non-head revision tagging on a non-head revision
$ hg update 0 $ hg update 0
0 files updated, 0 files merged, 1 files removed, 0 files unresolved 0 files updated, 0 files merged, 1 files removed, 0 files unresolved
$ hg tag -l localblah $ hg tag -l localblah
$ hg tag "foobar" $ hg tag "foobar"
abort: working directory is not at a branch head (use -f to force) abort: working directory is not at a branch head (use -f to force)
[255] [10]
$ hg tag -f "foobar" $ hg tag -f "foobar"
hook: tag changes detected hook: tag changes detected
hook: +A acb14030fe0a21b60322c440ad2d20cf7685a376 foobar hook: +A acb14030fe0a21b60322c440ad2d20cf7685a376 foobar
$ cat .hgtags $ cat .hgtags
acb14030fe0a21b60322c440ad2d20cf7685a376 foobar acb14030fe0a21b60322c440ad2d20cf7685a376 foobar
$ cat .hg/localtags $ cat .hg/localtags
d4f0d2909abc9290e2773c08837d70c1794e3f5a bleah1 d4f0d2909abc9290e2773c08837d70c1794e3f5a bleah1
acb14030fe0a21b60322c440ad2d20cf7685a376 localblah acb14030fe0a21b60322c440ad2d20cf7685a376 localblah
hook: +A 0f26aaea6f74c3ed6c4aad8844403c9ba128d23a new-topo-head hook: +A 0f26aaea6f74c3ed6c4aad8844403c9ba128d23a new-topo-head
tagging on null rev tagging on null rev
$ hg up null $ hg up null
0 files updated, 0 files merged, 2 files removed, 0 files unresolved 0 files updated, 0 files merged, 2 files removed, 0 files unresolved
$ hg tag nullrev $ hg tag nullrev
abort: working directory is not at a branch head (use -f to force) abort: working directory is not at a branch head (use -f to force)
[255] [10]
$ hg init empty $ hg init empty
$ hg tag -R empty nullrev $ hg tag -R empty nullrev
abort: cannot tag null revision abort: cannot tag null revision
[255] [10]
$ hg tag -R empty -r 00000000000 -f nulltag $ hg tag -R empty -r 00000000000 -f nulltag
abort: cannot tag null revision abort: cannot tag null revision
[255] [10]
issue5539: pruned tags do not appear in .hgtags issue5539: pruned tags do not appear in .hgtags
$ cat >> $HGRCPATH << EOF $ cat >> $HGRCPATH << EOF
> [experimental] > [experimental]
> evolution.exchange = True > evolution.exchange = True
> evolution.createmarkers=True > evolution.createmarkers=True
> EOF > EOF

tests/test-tags.t

tip 5:5f6e8655b1c7 tip 5:5f6e8655b1c7
$ hg tags # again, try to expose cache bugs $ hg tags # again, try to expose cache bugs
tip 5:5f6e8655b1c7 tip 5:5f6e8655b1c7
Remove nonexistent tag: Remove nonexistent tag:
$ hg tag --remove foobar $ hg tag --remove foobar
abort: tag 'foobar' does not exist abort: tag 'foobar' does not exist
[255] [10]
$ hg tip $ hg tip
changeset: 5:5f6e8655b1c7 changeset: 5:5f6e8655b1c7
tag: tip tag: tip
user: test user: test
date: Thu Jan 01 00:00:00 1970 +0000 date: Thu Jan 01 00:00:00 1970 +0000
summary: Removed tag bar summary: Removed tag bar
$ hg tags $ hg tags
tip 6:735c3ca72986 tip 6:735c3ca72986
bar 0:bbd179dfa0a7 bar 0:bbd179dfa0a7
Don't allow moving tag without -f: Don't allow moving tag without -f:
$ hg tag -r 3 bar $ hg tag -r 3 bar
abort: tag 'bar' already exists (use -f to force) abort: tag 'bar' already exists (use -f to force)
[255] [10]
$ hg tags $ hg tags
tip 6:735c3ca72986 tip 6:735c3ca72986
bar 0:bbd179dfa0a7 bar 0:bbd179dfa0a7
Strip 1: expose an old head: Strip 1: expose an old head:
$ hg --config extensions.mq= strip 5 $ hg --config extensions.mq= strip 5
saved backup bundle to $TESTTMP/t3/.hg/strip-backup/*-backup.hg (glob) saved backup bundle to $TESTTMP/t3/.hg/strip-backup/*-backup.hg (glob)
$ echo foo > foo $ echo foo > foo
$ hg add $ hg add
adding foo adding foo
$ hg ci -m 'add foo' # rev 0 $ hg ci -m 'add foo' # rev 0
$ hg tag -r 0 -l localtag $ hg tag -r 0 -l localtag
$ hg tag --remove localtag $ hg tag --remove localtag
abort: tag 'localtag' is not a global tag abort: tag 'localtag' is not a global tag
[255] [10]
$ $
$ hg tag -r 0 globaltag $ hg tag -r 0 globaltag
$ hg tag --remove -l globaltag $ hg tag --remove -l globaltag
abort: tag 'globaltag' is not a local tag abort: tag 'globaltag' is not a local tag
[255] [10]
$ hg tags -v $ hg tags -v
tip 1:a0b6fe111088 tip 1:a0b6fe111088
localtag 0:bbd179dfa0a7 local localtag 0:bbd179dfa0a7 local
globaltag 0:bbd179dfa0a7 globaltag 0:bbd179dfa0a7
Templated output: Templated output:
(immediate values) (immediate values)
changeset: 0:a8a82d372bb3 changeset: 0:a8a82d372bb3
user: test user: test
date: Thu Jan 01 00:00:00 1970 +0000 date: Thu Jan 01 00:00:00 1970 +0000
summary: add a summary: add a
$ hg tag --remove a $ hg tag --remove a
abort: tag 'a' is already removed abort: tag 'a' is already removed
[255] [10]
$ hg log $ hg log
changeset: 2:e7feacc7ec9e changeset: 2:e7feacc7ec9e
tag: tip tag: tip
user: test user: test
date: Thu Jan 01 00:00:00 1970 +0000 date: Thu Jan 01 00:00:00 1970 +0000
summary: Removed tag a summary: Removed tag a
changeset: 1:bd7ee4f3939b changeset: 1:bd7ee4f3939b

tests/test-transplant.t

$ hg init t $ hg init t
$ cd t $ cd t
$ hg transplant $ hg transplant
abort: no source URL, branch revision, or revision list provided abort: no source URL, branch revision, or revision list provided
[255] [255]
$ hg transplant --continue --all $ hg transplant --continue --all
abort: cannot specify both --continue and --all abort: cannot specify both --continue and --all
[255] [10]
$ hg transplant --stop --all $ hg transplant --stop --all
abort: cannot specify both --stop and --all abort: cannot specify both --stop and --all
[255] [10]
$ hg transplant --all tip $ hg transplant --all tip
abort: --all requires a branch revision abort: --all requires a branch revision
[255] [255]
$ hg transplant --all --branch default tip $ hg transplant --all --branch default tip
abort: --all is incompatible with a revision list abort: --all is incompatible with a revision list
[255] [255]
$ echo r1 > r1 $ echo r1 > r1
$ hg ci -Amr1 -d'0 0' $ hg ci -Amr1 -d'0 0'

tests/test-uncommit.t

date: Mon Jun 30 12:12:12 1980 +0000 date: Mon Jun 30 12:12:12 1980 +0000
summary: uncommit with message summary: uncommit with message
Bad option combinations Bad option combinations
$ hg rollback -q --config ui.rollback=True $ hg rollback -q --config ui.rollback=True
$ hg uncommit -U --user 'user' $ hg uncommit -U --user 'user'
abort: cannot specify both --user and --currentuser abort: cannot specify both --user and --currentuser
[255] [10]
$ hg uncommit -D --date today $ hg uncommit -D --date today
abort: cannot specify both --date and --currentdate abort: cannot specify both --date and --currentdate
[255] [10]
`uncommit <dir>` and `cd <dir> && uncommit .` behave the same... `uncommit <dir>` and `cd <dir> && uncommit .` behave the same...
$ echo 2 > dir/file2.txt $ echo 2 > dir/file2.txt
$ hg ci -Aqm 'add file2 in directory' $ hg ci -Aqm 'add file2 in directory'
$ hg uncommit dir $ hg uncommit dir
note: keeping empty commit note: keeping empty commit
$ hg status $ hg status

tests/test-update-dest.t

Test update.requiredest Test update.requiredest
$ cd $TESTTMP $ cd $TESTTMP
$ cat >> $HGRCPATH <<EOF $ cat >> $HGRCPATH <<EOF
> [commands] > [commands]
> update.requiredest = True > update.requiredest = True
> EOF > EOF
$ hg init repo $ hg init repo
$ cd repo $ cd repo
$ echo a >> a $ echo a >> a
$ hg commit -qAm aa $ hg commit -qAm aa
$ hg up $ hg up
abort: you must specify a destination abort: you must specify a destination
(for example: hg update ".::") (for example: hg update ".::")
[255] [10]
$ hg up . $ hg up .
0 files updated, 0 files merged, 0 files removed, 0 files unresolved 0 files updated, 0 files merged, 0 files removed, 0 files unresolved
$ HGPLAIN=1 hg up $ HGPLAIN=1 hg up
0 files updated, 0 files merged, 0 files removed, 0 files unresolved 0 files updated, 0 files merged, 0 files removed, 0 files unresolved
$ hg --config commands.update.requiredest=False up $ hg --config commands.update.requiredest=False up
0 files updated, 0 files merged, 0 files removed, 0 files unresolved 0 files updated, 0 files merged, 0 files removed, 0 files unresolved
$ cd .. $ cd ..
Check update.requiredest interaction with pull --update Check update.requiredest interaction with pull --update
$ hg clone repo clone $ hg clone repo clone
updating to branch default updating to branch default
1 files updated, 0 files merged, 0 files removed, 0 files unresolved 1 files updated, 0 files merged, 0 files removed, 0 files unresolved
$ cd repo $ cd repo
$ echo a >> a $ echo a >> a
$ hg commit -qAm aa $ hg commit -qAm aa
$ cd ../clone $ cd ../clone
$ hg pull --update $ hg pull --update
abort: update destination required by configuration abort: update destination required by configuration
(use hg pull followed by hg update DEST) (use hg pull followed by hg update DEST)
[255] [10]
$ cd .. $ cd ..
update.requiredest should silent the "hg update" text after pull update.requiredest should silent the "hg update" text after pull
$ hg init repo1 $ hg init repo1
$ cd repo1 $ cd repo1
$ hg pull ../repo $ hg pull ../repo
pulling from ../repo pulling from ../repo
requesting all changes requesting all changes
adding changesets adding changesets
adding manifests adding manifests
adding file changes adding file changes
added 2 changesets with 2 changes to 1 files added 2 changesets with 2 changes to 1 files
new changesets 8f0162e483d0:048c2cb95949 new changesets 8f0162e483d0:048c2cb95949