( )⚙ D12255 tests: remove from __future__ from inline Python in tests

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D12255

tests: remove from __future__ from inline Python in tests
ClosedPublic

Authored by indygreg on Mar 1 2022, 7:36 PM.

Details

Reviewers
durin42
Alphare
Group Reviewers
hg-reviewers
Commits
rHG42d2b31cee0b: tests: remove from __future__ from inline Python in tests
Summary

This is no longer required since we require Python 3 and the linter
no longer requires these statements.

Diff Detail

Repository
rHG Mercurial
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

Event Timeline

indygreg created this revision.Mar 1 2022, 7:36 PM
Alphare accepted this revision.Mar 2 2022, 6:01 AM
This revision is now accepted and ready to land.Mar 2 2022, 6:01 AM

Revision Contents
Changeset List

PathPackages
Mtests/test-annotate.t (1 line)
Mtests/test-arbitraryfilectx.t (1 line)
Mtests/test-archive.t (3 lines)
Mtests/test-bisect.t (1 line)
Mtests/test-blackbox.t (2 lines)
Mtests/test-bookmarks.t (1 line)
Mtests/test-bugzilla.t (1 line)
Mtests/test-bundle.t (1 line)
Mtests/test-bundle2-pushback.t (1 line)
Mtests/test-check-help.t (1 line)
Mtests/test-chg.t (1 line)
Mtests/test-commit-interactive.t (1 line)
Mtests/test-commit.t (3 lines)
Mtests/test-context-metadata.t (1 line)
Mtests/test-convert-clonebranches.t (1 line)
Mtests/test-dirstate.t (1 line)
Mtests/test-eol.t (1 line)
Mtests/test-extension.t (13 lines)
Mtests/test-fastannotate-hg.t (1 line)
Mtests/test-filebranch.t (1 line)
Mtests/test-fncache.t (5 lines)
Mtests/test-hardlinks.t (2 lines)
Mtests/test-help.t (1 line)
Mtests/test-hgweb-no-path-info.t (1 line)
Mtests/test-hgweb-no-request-uri.t (1 line)
Mtests/test-hgweb-non-interactive.t (1 line)
Mtests/test-hook.t (1 line)
Mtests/test-impexp-branch.t (1 line)
Mtests/test-import.t (1 line)
Mtests/test-imports-checker.t (58 lines)
Mtests/test-inherit-mode.t (2 lines)
Mtests/test-largefiles-cache.t (1 line)
Mtests/test-largefiles-small-disk.t (1 line)
Mtests/test-log-exthook.t (1 line)
Mtests/test-log.t (1 line)
Mtests/test-logtoprocess.t (1 line)
Mtests/test-merge-symlinks.t (1 line)
Mtests/test-merge1.t (2 lines)
Mtests/test-narrow-clone-non-narrow-server.t (1 line)
Mtests/test-notify.t (1 line)
Mtests/test-obsolete.t (2 lines)
Mtests/test-pager.t (1 line)
Mtests/test-parseindex.t (3 lines)
Mtests/test-patch.t (1 line)
Mtests/test-patchbomb.t (1 line)
Mtests/test-profile.t (2 lines)
Mtests/test-progress.t (1 line)
Mtests/test-rebase-dest.t (1 line)
Mtests/test-rebase-scenario-global.t (1 line)
Mtests/test-relink.t (1 line)
Mtests/test-requires.t (1 line)
Mtests/test-revert.t (1 line)
Mtests/test-revlog-mmapindex.t (1 line)
Mtests/test-revset.t (1 line)
Mtests/test-share-bookmarks.t (1 line)
Mtests/test-ssh-proto-unbundle.t (1 line)
Mtests/test-strip.t (1 line)
Mtests/test-template-functions.t (1 line)
Mtests/test-template-map.t (1 line)
Mtests/test-update-atomic.t (2 lines)
Mtests/test-verify.t (1 line)
Mtests/test-walk.t (1 line)
Mtests/test-worker.t (3 lines)

Diff 32330

tests/test-annotate.t

merging between the revision and its ancestor merging between the revision and its ancestor
to reproduce the situation with recent Mercurial, this script uses (1) to reproduce the situation with recent Mercurial, this script uses (1)
"hg debugsetparents" to merge without ancestor check by "hg merge", "hg debugsetparents" to merge without ancestor check by "hg merge",
and (2) the extension to allow filelog merging between the revision and (2) the extension to allow filelog merging between the revision
and its ancestor by overriding "repo._filecommit". and its ancestor by overriding "repo._filecommit".
$ cat > ../legacyrepo.py <<EOF $ cat > ../legacyrepo.py <<EOF
> from __future__ import absolute_import
> from mercurial import commit, error, extensions > from mercurial import commit, error, extensions
> def _filecommit(orig, repo, fctx, manifest1, manifest2, > def _filecommit(orig, repo, fctx, manifest1, manifest2,
> linkrev, tr, includecopymeta, ms): > linkrev, tr, includecopymeta, ms):
> fname = fctx.path() > fname = fctx.path()
> text = fctx.data() > text = fctx.data()
> flog = repo.file(fname) > flog = repo.file(fname)
> fparent1 = manifest1.get(fname, repo.nullid) > fparent1 = manifest1.get(fname, repo.nullid)
> fparent2 = manifest2.get(fname, repo.nullid) > fparent2 = manifest2.get(fname, repo.nullid)

tests/test-arbitraryfilectx.t

Setup: Setup:
$ cat > eval.py <<EOF $ cat > eval.py <<EOF
> from __future__ import absolute_import
> import filecmp > import filecmp
> from mercurial import commands, context, pycompat, registrar > from mercurial import commands, context, pycompat, registrar
> cmdtable = {} > cmdtable = {}
> command = registrar.command(cmdtable) > command = registrar.command(cmdtable)
> @command(b'eval', [], b'hg eval CMD') > @command(b'eval', [], b'hg eval CMD')
> def eval_(ui, repo, *cmds, **opts): > def eval_(ui, repo, *cmds, **opts):
> cmd = b" ".join(cmds) > cmd = b" ".join(cmds)
> res = pycompat.bytestr(eval(cmd, globals(), locals())) > res = pycompat.bytestr(eval(cmd, globals(), locals()))

tests/test-archive.t

invalid arch type should give 404 invalid arch type should give 404
$ get-with-headers.py localhost:$HGPORT "archive/tip.invalid" | head -n 1 $ get-with-headers.py localhost:$HGPORT "archive/tip.invalid" | head -n 1
404 Unsupported archive type: None 404 Unsupported archive type: None
$ TIP=`hg id -v | cut -f1 -d' '` $ TIP=`hg id -v | cut -f1 -d' '`
$ QTIP=`hg id -q` $ QTIP=`hg id -q`
$ cat > getarchive.py <<EOF $ cat > getarchive.py <<EOF
> from __future__ import absolute_import
> import os > import os
> import sys > import sys
> from mercurial import ( > from mercurial import (
> util, > util,
> ) > )
> try: > try:
> # Set stdout to binary mode for win32 platforms > # Set stdout to binary mode for win32 platforms
> import msvcrt > import msvcrt
$ for ext in tar tar.gz tgz tar.bz2 tbz2 zip; do $ for ext in tar tar.gz tgz tar.bz2 tbz2 zip; do
> hg archive auto_test.$ext > hg archive auto_test.$ext
> if [ -d auto_test.$ext ]; then > if [ -d auto_test.$ext ]; then
> echo "extension $ext was not autodetected." > echo "extension $ext was not autodetected."
> fi > fi
> done > done
$ cat > md5comp.py <<EOF $ cat > md5comp.py <<EOF
> from __future__ import absolute_import, print_function
> import hashlib > import hashlib
> import sys > import sys
> f1, f2 = sys.argv[1:3] > f1, f2 = sys.argv[1:3]
> h1 = hashlib.md5(open(f1, 'rb').read()).hexdigest() > h1 = hashlib.md5(open(f1, 'rb').read()).hexdigest()
> h2 = hashlib.md5(open(f2, 'rb').read()).hexdigest() > h2 = hashlib.md5(open(f2, 'rb').read()).hexdigest()
> print(h1 == h2 or "md5 differ: " + repr((h1, h2))) > print(h1 == h2 or "md5 differ: " + repr((h1, h2)))
> EOF > EOF
$ mkdir issue3600 $ mkdir issue3600
$ cd issue3600 $ cd issue3600
$ hg init repo $ hg init repo
$ echo a > repo/a $ echo a > repo/a
$ hg -R repo add repo/a $ hg -R repo add repo/a
$ hg -R repo commit -m '#0' -d '456789012 21600' $ hg -R repo commit -m '#0' -d '456789012 21600'
$ cat > show_mtime.py <<EOF $ cat > show_mtime.py <<EOF
> from __future__ import absolute_import, print_function
> import os > import os
> import sys > import sys
> print(int(os.stat(sys.argv[1]).st_mtime)) > print(int(os.stat(sys.argv[1]).st_mtime))
> EOF > EOF
$ hg -R repo archive --prefix tar-extracted archive.tar $ hg -R repo archive --prefix tar-extracted archive.tar
$ (TZ=UTC-3; export TZ; tar xf archive.tar) $ (TZ=UTC-3; export TZ; tar xf archive.tar)
$ "$PYTHON" show_mtime.py tar-extracted/a $ "$PYTHON" show_mtime.py tar-extracted/a
456789012 456789012
$ hg -R repo archive --prefix zip-extracted archive.zip $ hg -R repo archive --prefix zip-extracted archive.zip
$ (TZ=UTC-3; export TZ; unzip -q archive.zip) $ (TZ=UTC-3; export TZ; unzip -q archive.zip)
$ "$PYTHON" show_mtime.py zip-extracted/a $ "$PYTHON" show_mtime.py zip-extracted/a
456789012 456789012
$ cd .. $ cd ..

tests/test-bisect.t

abort: failed to execute exit 127 abort: failed to execute exit 127
[255] [255]
test bisecting command test bisecting command
$ cat > script.py <<EOF $ cat > script.py <<EOF
> #!$PYTHON > #!$PYTHON
> from __future__ import absolute_import
> import sys > import sys
> from mercurial import hg, ui as uimod > from mercurial import hg, ui as uimod
> repo = hg.repository(uimod.ui.load(), b'.') > repo = hg.repository(uimod.ui.load(), b'.')
> if repo[b'.'].rev() < 6: > if repo[b'.'].rev() < 6:
> sys.exit(1) > sys.exit(1)
> EOF > EOF
$ chmod +x script.py $ chmod +x script.py
$ hg bisect -r $ hg bisect -r

tests/test-blackbox.t

1970-01-01 00:00:00.000 bob @0000000000000000000000000000000000000000 (5000) [command]> blackbox 1970-01-01 00:00:00.000 bob @0000000000000000000000000000000000000000 (5000) [command]> blackbox
$ cd $TESTTMP $ cd $TESTTMP
#if chg #if chg
when using chg, blackbox.log should get rotated correctly when using chg, blackbox.log should get rotated correctly
$ cat > $TESTTMP/noop.py << EOF $ cat > $TESTTMP/noop.py << EOF
> from __future__ import absolute_import
> import time > import time
> from mercurial import registrar, scmutil > from mercurial import registrar, scmutil
> cmdtable = {} > cmdtable = {}
> command = registrar.command(cmdtable) > command = registrar.command(cmdtable)
> @command(b'noop') > @command(b'noop')
> def noop(ui, repo): > def noop(ui, repo):
> pass > pass
> EOF > EOF
$ rm -rf $TESTTMP/repo1 $ rm -rf $TESTTMP/repo1
$ hg --config extensions.a=! init repo1 $ hg --config extensions.a=! init repo1
#endif #endif
blackbox should work if repo.ui.log is not called (issue5518) blackbox should work if repo.ui.log is not called (issue5518)
$ cat > $TESTTMP/raise.py << EOF $ cat > $TESTTMP/raise.py << EOF
> from __future__ import absolute_import
> from mercurial import registrar, scmutil > from mercurial import registrar, scmutil
> cmdtable = {} > cmdtable = {}
> command = registrar.command(cmdtable) > command = registrar.command(cmdtable)
> @command(b'raise') > @command(b'raise')
> def raisecmd(*args): > def raisecmd(*args):
> raise RuntimeError('raise') > raise RuntimeError('raise')
> EOF > EOF

tests/test-bookmarks.t

$ hg init orderrepo $ hg init orderrepo
$ cd orderrepo $ cd orderrepo
$ touch a $ touch a
$ hg commit -Aqm one $ hg commit -Aqm one
$ hg book mybook $ hg book mybook
$ echo a > a $ echo a > a
$ cat > $TESTTMP/pausefinalize.py <<EOF $ cat > $TESTTMP/pausefinalize.py <<EOF
> from __future__ import absolute_import
> import os > import os
> import time > import time
> from mercurial import extensions, localrepo > from mercurial import extensions, localrepo
> def transaction(orig, self, desc, report=None): > def transaction(orig, self, desc, report=None):
> tr = orig(self, desc, report) > tr = orig(self, desc, report)
> def sleep(*args, **kwargs): > def sleep(*args, **kwargs):
> retry = 20 > retry = 20
> while retry > 0 and not os.path.exists(b"$TESTTMP/unpause"): > while retry > 0 and not os.path.exists(b"$TESTTMP/unpause"):

tests/test-bugzilla.t

mock bugzilla driver for testing template output: mock bugzilla driver for testing template output:
$ cat <<EOF > bzmock.py $ cat <<EOF > bzmock.py
> from __future__ import absolute_import
> from mercurial import extensions > from mercurial import extensions
> from mercurial import pycompat > from mercurial import pycompat
> from mercurial import registrar > from mercurial import registrar
> from mercurial.utils import stringutil > from mercurial.utils import stringutil
> >
> configtable = {} > configtable = {}
> configitem = registrar.configitem(configtable) > configitem = registrar.configitem(configtable)
> >

tests/test-bundle.t

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
> from __future__ import absolute_import
> >
> def showtip(ui, repo, hooktype, **kwargs): > def showtip(ui, repo, hooktype, **kwargs):
> ui.warn(b'%s: %s\n' % (hooktype, repo[b'tip'].hex()[:12])) > ui.warn(b'%s: %s\n' % (hooktype, repo[b'tip'].hex()[:12]))
> >
> def reposetup(ui, repo): > def reposetup(ui, repo):
> # this confirms (and ensures) that (empty) 00changelog.i > # this confirms (and ensures) that (empty) 00changelog.i
> # before streamclone is already cached as repo.changelog > # before streamclone is already cached as repo.changelog
> ui.setconfig(b'hooks', b'pretxnopen.showtip', showtip) > ui.setconfig(b'hooks', b'pretxnopen.showtip', showtip)

tests/test-bundle2-pushback.t

$ cat > bundle2.py << EOF $ cat > bundle2.py << EOF
> """A small extension to test bundle2 pushback parts. > """A small extension to test bundle2 pushback parts.
> Current bundle2 implementation doesn't provide a way to generate those > Current bundle2 implementation doesn't provide a way to generate those
> parts, so they must be created by extensions. > parts, so they must be created by extensions.
> """ > """
> from __future__ import absolute_import
> from mercurial import bundle2, exchange, pushkey, util > from mercurial import bundle2, exchange, pushkey, util
> def _newhandlechangegroup(op, inpart): > def _newhandlechangegroup(op, inpart):
> """This function wraps the changegroup part handler for getbundle. > """This function wraps the changegroup part handler for getbundle.
> It issues an additional pushkey part to send a new > It issues an additional pushkey part to send a new
> bookmark back to the client""" > bookmark back to the client"""
> result = bundle2.handlechangegroup(op, inpart) > result = bundle2.handlechangegroup(op, inpart)
> if b'pushback' in op.reply.capabilities: > if b'pushback' in op.reply.capabilities:
> params = {b'namespace': b'bookmarks', > params = {b'namespace': b'bookmarks',

tests/test-check-help.t

#require test-repo #require test-repo
$ . "$TESTDIR/helpers-testrepo.sh" $ . "$TESTDIR/helpers-testrepo.sh"
$ cat <<'EOF' > scanhelptopics.py $ cat <<'EOF' > scanhelptopics.py
> from __future__ import absolute_import, print_function
> import re > import re
> import sys > import sys
> if sys.platform == "win32": > if sys.platform == "win32":
> import msvcrt > import msvcrt
> import os > import os
> msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY) > msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY)
> stdout = getattr(sys.stdout, 'buffer', sys.stdout) > stdout = getattr(sys.stdout, 'buffer', sys.stdout)
> topics = set() > topics = set()

tests/test-chg.t

> command = registrar.command(cmdtable) > command = registrar.command(cmdtable)
> @command(b'crash') > @command(b'crash')
> def pagercrash(ui, repo, *pats, **opts): > def pagercrash(ui, repo, *pats, **opts):
> ui.write(b'going to crash\n') > ui.write(b'going to crash\n')
> raise Exception('.') > raise Exception('.')
> EOF > EOF
$ cat > $TESTTMP/fakepager.py <<EOF $ cat > $TESTTMP/fakepager.py <<EOF
> from __future__ import absolute_import
> import sys > import sys
> import time > import time
> for line in iter(sys.stdin.readline, ''): > for line in iter(sys.stdin.readline, ''):
> if 'crash' in line: # only interested in lines containing 'crash' > if 'crash' in line: # only interested in lines containing 'crash'
> # if chg exits when pager is sleeping (incorrectly), the output > # if chg exits when pager is sleeping (incorrectly), the output
> # will be captured by the next test case > # will be captured by the next test case
> time.sleep(1) > time.sleep(1)
> sys.stdout.write('crash-pager: %s' % line) > sys.stdout.write('crash-pager: %s' % line)

tests/test-commit-interactive.t

replacement makes message meaningless. replacement makes message meaningless.
This tests that translated help message is lower()-ed correctly. This tests that translated help message is lower()-ed correctly.
$ LANGUAGE=ja $ LANGUAGE=ja
$ export LANGUAGE $ export LANGUAGE
$ cat > $TESTTMP/escape.py <<EOF $ cat > $TESTTMP/escape.py <<EOF
> from __future__ import absolute_import
> from mercurial import ( > from mercurial import (
> pycompat, > pycompat,
> ) > )
> from mercurial.utils import ( > from mercurial.utils import (
> procutil, > procutil,
> ) > )
> def escape(c): > def escape(c):
> o = ord(c) > o = ord(c)

tests/test-commit.t

date: Thu Jan 01 00:00:00 1970 +0000 date: Thu Jan 01 00:00:00 1970 +0000
description: description:
empty commit empty commit
verify pathauditor blocks evil filepaths verify pathauditor blocks evil filepaths
$ cat > evil-commit.py <<EOF $ cat > evil-commit.py <<EOF
> from __future__ import absolute_import
> from mercurial import context, hg, ui as uimod > from mercurial import context, hg, ui as uimod
> notrc = u".h\u200cg".encode('utf-8') + b'/hgrc' > notrc = u".h\u200cg".encode('utf-8') + b'/hgrc'
> u = uimod.ui.load() > u = uimod.ui.load()
> r = hg.repository(u, b'.') > r = hg.repository(u, b'.')
> def filectxfn(repo, memctx, path): > def filectxfn(repo, memctx, path):
> return context.memfilectx(repo, memctx, path, > return context.memfilectx(repo, memctx, path,
> b'[hooks]\nupdate = echo owned') > b'[hooks]\nupdate = echo owned')
> c = context.memctx(r, [r.changelog.tip(), r.nullid], > c = context.memctx(r, [r.changelog.tip(), r.nullid],
$ hg co --clean tip $ hg co --clean tip
abort: path contains illegal component: .h\xe2\x80\x8cg/hgrc (esc) abort: path contains illegal component: .h\xe2\x80\x8cg/hgrc (esc)
[10] [10]
#endif #endif
$ hg rollback -f $ hg rollback -f
repository tip rolled back to revision 2 (undo commit) repository tip rolled back to revision 2 (undo commit)
$ cat > evil-commit.py <<EOF $ cat > evil-commit.py <<EOF
> from __future__ import absolute_import
> from mercurial import context, hg, ui as uimod > from mercurial import context, hg, ui as uimod
> notrc = b"HG~1/hgrc" > notrc = b"HG~1/hgrc"
> u = uimod.ui.load() > u = uimod.ui.load()
> r = hg.repository(u, b'.') > r = hg.repository(u, b'.')
> def filectxfn(repo, memctx, path): > def filectxfn(repo, memctx, path):
> return context.memfilectx(repo, memctx, path, > return context.memfilectx(repo, memctx, path,
> b'[hooks]\nupdate = echo owned') > b'[hooks]\nupdate = echo owned')
> c = context.memctx(r, [r[b'tip'].node(), r.nullid], > c = context.memctx(r, [r[b'tip'].node(), r.nullid],
> b'evil', [notrc], filectxfn, 0) > b'evil', [notrc], filectxfn, 0)
> r.commitctx(c) > r.commitctx(c)
> EOF > EOF
$ "$PYTHON" evil-commit.py $ "$PYTHON" evil-commit.py
$ hg co --clean tip $ hg co --clean tip
abort: path contains illegal component: HG~1/hgrc abort: path contains illegal component: HG~1/hgrc
[10] [10]
$ hg rollback -f $ hg rollback -f
repository tip rolled back to revision 2 (undo commit) repository tip rolled back to revision 2 (undo commit)
$ cat > evil-commit.py <<EOF $ cat > evil-commit.py <<EOF
> from __future__ import absolute_import
> from mercurial import context, hg, ui as uimod > from mercurial import context, hg, ui as uimod
> notrc = b"HG8B6C~2/hgrc" > notrc = b"HG8B6C~2/hgrc"
> u = uimod.ui.load() > u = uimod.ui.load()
> r = hg.repository(u, b'.') > r = hg.repository(u, b'.')
> def filectxfn(repo, memctx, path): > def filectxfn(repo, memctx, path):
> return context.memfilectx(repo, memctx, path, > return context.memfilectx(repo, memctx, path,
> b'[hooks]\nupdate = echo owned') > b'[hooks]\nupdate = echo owned')
> c = context.memctx(r, [r[b'tip'].node(), r.nullid], > c = context.memctx(r, [r[b'tip'].node(), r.nullid],

tests/test-context-metadata.t

Tests about metadataonlyctx Tests about metadataonlyctx
$ hg init $ hg init
$ echo A > A $ echo A > A
$ hg commit -A A -m 'Add A' $ hg commit -A A -m 'Add A'
$ echo B > B $ echo B > B
$ hg commit -A B -m 'Add B' $ hg commit -A B -m 'Add B'
$ hg rm A $ hg rm A
$ echo C > C $ echo C > C
$ echo B2 > B $ echo B2 > B
$ hg add C -q $ hg add C -q
$ hg commit -m 'Remove A' $ hg commit -m 'Remove A'
$ cat > metaedit.py <<EOF $ cat > metaedit.py <<EOF
> from __future__ import absolute_import
> from mercurial import context, pycompat, registrar > from mercurial import context, pycompat, registrar
> cmdtable = {} > cmdtable = {}
> command = registrar.command(cmdtable) > command = registrar.command(cmdtable)
> @command(b'metaedit') > @command(b'metaedit')
> def metaedit(ui, repo, arg): > def metaedit(ui, repo, arg):
> # Modify commit message to "FOO" > # Modify commit message to "FOO"
> with repo.wlock(), repo.lock(), repo.transaction(b'metaedit'): > with repo.wlock(), repo.lock(), repo.transaction(b'metaedit'):
> old = repo[b'.'] > old = repo[b'.']

tests/test-convert-clonebranches.t

(branch merge, don't forget to commit) (branch merge, don't forget to commit)
$ hg ci -qm mergeab $ hg ci -qm mergeab
$ hg tag -ql mergeab $ hg tag -ql mergeab
$ cd .. $ cd ..
Miss perl... sometimes Miss perl... sometimes
$ cat > filter.py <<EOF $ cat > filter.py <<EOF
> from __future__ import absolute_import
> import re > import re
> import sys > import sys
> >
> r = re.compile(r'^(?:\d+|pulling from)') > r = re.compile(r'^(?:\d+|pulling from)')
> sys.stdout.writelines([l for l in sys.stdin if r.search(l)]) > sys.stdout.writelines([l for l in sys.stdin if r.search(l)])
> EOF > EOF
convert convert

tests/test-dirstate.t

$ hg debugstate $ hg debugstate
n 644 2 2018-01-19 15:14:08 a n 644 2 2018-01-19 15:14:08 a
#endif #endif
Verify that exceptions during a dirstate change leave the dirstate Verify that exceptions during a dirstate change leave the dirstate
coherent (issue4353) coherent (issue4353)
$ cat > ../dirstateexception.py <<EOF $ cat > ../dirstateexception.py <<EOF
> from __future__ import absolute_import
> from mercurial import ( > from mercurial import (
> error, > error,
> extensions, > extensions,
> mergestate as mergestatemod, > mergestate as mergestatemod,
> ) > )
> >
> def wraprecordupdates(*args): > def wraprecordupdates(*args):
> raise error.Abort(b"simulated error while recording dirstateupdates") > raise error.Abort(b"simulated error while recording dirstateupdates")

tests/test-eol.t

Test EOL extension Test EOL extension
$ cat >> $HGRCPATH <<EOF $ cat >> $HGRCPATH <<EOF
> [diff] > [diff]
> git = True > git = True
> EOF > EOF
Set up helpers Set up helpers
$ cat > switch-eol.py <<'EOF' $ cat > switch-eol.py <<'EOF'
> from __future__ import absolute_import
> import os > import os
> import sys > import sys
> try: > try:
> import msvcrt > import msvcrt
> msvcrt.setmode(sys.stdin.fileno(), os.O_BINARY) > msvcrt.setmode(sys.stdin.fileno(), os.O_BINARY)
> msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY) > msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY)
> except ImportError: > except ImportError:
> pass > pass

tests/test-extension.t

reposetup called for a (chg !) reposetup called for a (chg !)
ui == repo.ui (chg !) ui == repo.ui (chg !)
Foo Foo
$ echo 'barfoo = !' >> $HGRCPATH $ echo 'barfoo = !' >> $HGRCPATH
Check that extensions are loaded in phases: Check that extensions are loaded in phases:
$ cat > foo.py <<EOF $ cat > foo.py <<EOF
> from __future__ import print_function
> import os > import os
> from mercurial import exthelper > from mercurial import exthelper
> from mercurial.utils import procutil > from mercurial.utils import procutil
> >
> def write(msg): > def write(msg):
> procutil.stdout.write(msg) > procutil.stdout.write(msg)
> procutil.stdout.flush() > procutil.stdout.flush()
> >
$ mkdir $TESTTMP/libroot $ mkdir $TESTTMP/libroot
$ echo "s = 'libroot/ambig.py'" > $TESTTMP/libroot/ambig.py $ echo "s = 'libroot/ambig.py'" > $TESTTMP/libroot/ambig.py
$ mkdir $TESTTMP/libroot/mod $ mkdir $TESTTMP/libroot/mod
$ touch $TESTTMP/libroot/mod/__init__.py $ touch $TESTTMP/libroot/mod/__init__.py
$ echo "s = 'libroot/mod/ambig.py'" > $TESTTMP/libroot/mod/ambig.py $ echo "s = 'libroot/mod/ambig.py'" > $TESTTMP/libroot/mod/ambig.py
$ cat > $TESTTMP/libroot/mod/ambigabs.py <<NO_CHECK_EOF $ cat > $TESTTMP/libroot/mod/ambigabs.py <<NO_CHECK_EOF
> from __future__ import absolute_import, print_function
> import ambig # should load "libroot/ambig.py" > import ambig # should load "libroot/ambig.py"
> s = ambig.s > s = ambig.s
> NO_CHECK_EOF > NO_CHECK_EOF
$ cat > loadabs.py <<NO_CHECK_EOF $ cat > loadabs.py <<NO_CHECK_EOF
> import mod.ambigabs as ambigabs > import mod.ambigabs as ambigabs
> def extsetup(ui): > def extsetup(ui):
> print('ambigabs.s=%s' % ambigabs.s, flush=True) > print('ambigabs.s=%s' % ambigabs.s, flush=True)
> NO_CHECK_EOF > NO_CHECK_EOF
$ "$PYTHON" $TESTTMP/unflush.py loadabs.py $ "$PYTHON" $TESTTMP/unflush.py loadabs.py
$ (PYTHONPATH=${PYTHONPATH}${PATHSEP}${TESTTMP}/libroot; hg --config extensions.loadabs=loadabs.py root) $ (PYTHONPATH=${PYTHONPATH}${PATHSEP}${TESTTMP}/libroot; hg --config extensions.loadabs=loadabs.py root)
ambigabs.s=libroot/ambig.py ambigabs.s=libroot/ambig.py
$TESTTMP/a $TESTTMP/a
#if no-py3 #if no-py3
$ cat > $TESTTMP/libroot/mod/ambigrel.py <<NO_CHECK_EOF $ cat > $TESTTMP/libroot/mod/ambigrel.py <<NO_CHECK_EOF
> from __future__ import print_function
> import ambig # should load "libroot/mod/ambig.py" > import ambig # should load "libroot/mod/ambig.py"
> s = ambig.s > s = ambig.s
> NO_CHECK_EOF > NO_CHECK_EOF
$ cat > loadrel.py <<NO_CHECK_EOF $ cat > loadrel.py <<NO_CHECK_EOF
> import mod.ambigrel as ambigrel > import mod.ambigrel as ambigrel
> def extsetup(ui): > def extsetup(ui):
> print('ambigrel.s=%s' % ambigrel.s, flush=True) > print('ambigrel.s=%s' % ambigrel.s, flush=True)
> NO_CHECK_EOF > NO_CHECK_EOF
$ mkdir $TESTTMP/extroot/sub1 $ mkdir $TESTTMP/extroot/sub1
$ cat > $TESTTMP/extroot/sub1/__init__.py <<NO_CHECK_EOF $ cat > $TESTTMP/extroot/sub1/__init__.py <<NO_CHECK_EOF
> s = b'this is extroot.sub1.__init__' > s = b'this is extroot.sub1.__init__'
> NO_CHECK_EOF > NO_CHECK_EOF
$ cat > $TESTTMP/extroot/sub1/baz.py <<NO_CHECK_EOF $ cat > $TESTTMP/extroot/sub1/baz.py <<NO_CHECK_EOF
> s = b'this is extroot.sub1.baz' > s = b'this is extroot.sub1.baz'
> NO_CHECK_EOF > NO_CHECK_EOF
$ cat > $TESTTMP/extroot/__init__.py <<NO_CHECK_EOF $ cat > $TESTTMP/extroot/__init__.py <<NO_CHECK_EOF
> from __future__ import absolute_import
> s = b'this is extroot.__init__' > s = b'this is extroot.__init__'
> from . import foo > from . import foo
> def extsetup(ui): > def extsetup(ui):
> ui.write(b'(extroot) ', foo.func(), b'\n') > ui.write(b'(extroot) ', foo.func(), b'\n')
> ui.flush() > ui.flush()
> NO_CHECK_EOF > NO_CHECK_EOF
$ cat > $TESTTMP/extroot/foo.py <<NO_CHECK_EOF $ cat > $TESTTMP/extroot/foo.py <<NO_CHECK_EOF
importing with "absolute_import" feature isn't tested, because "level importing with "absolute_import" feature isn't tested, because "level
>=1 " doesn't cause instantiation of demandmod. >=1 " doesn't cause instantiation of demandmod.
$ mkdir -p $TESTTMP/extlibroot/recursedown/abs $ mkdir -p $TESTTMP/extlibroot/recursedown/abs
$ cat > $TESTTMP/extlibroot/recursedown/abs/used.py <<NO_CHECK_EOF $ cat > $TESTTMP/extlibroot/recursedown/abs/used.py <<NO_CHECK_EOF
> detail = b"this is extlibroot.recursedown.abs.used" > detail = b"this is extlibroot.recursedown.abs.used"
> NO_CHECK_EOF > NO_CHECK_EOF
$ cat > $TESTTMP/extlibroot/recursedown/abs/__init__.py <<NO_CHECK_EOF $ cat > $TESTTMP/extlibroot/recursedown/abs/__init__.py <<NO_CHECK_EOF
> from __future__ import absolute_import
> from extlibroot.recursedown.abs.used import detail > from extlibroot.recursedown.abs.used import detail
> NO_CHECK_EOF > NO_CHECK_EOF
$ mkdir -p $TESTTMP/extlibroot/recursedown/legacy $ mkdir -p $TESTTMP/extlibroot/recursedown/legacy
$ cat > $TESTTMP/extlibroot/recursedown/legacy/used.py <<NO_CHECK_EOF $ cat > $TESTTMP/extlibroot/recursedown/legacy/used.py <<NO_CHECK_EOF
> detail = b"this is extlibroot.recursedown.legacy.used" > detail = b"this is extlibroot.recursedown.legacy.used"
> NO_CHECK_EOF > NO_CHECK_EOF
$ cat > $TESTTMP/extlibroot/recursedown/legacy/__init__.py <<NO_CHECK_EOF $ cat > $TESTTMP/extlibroot/recursedown/legacy/__init__.py <<NO_CHECK_EOF
> # legacy style (level == -1) import > # legacy style (level == -1) import
> from extlibroot.recursedown.legacy.used import detail > from extlibroot.recursedown.legacy.used import detail
> NO_CHECK_EOF > NO_CHECK_EOF
$ cat > $TESTTMP/extlibroot/recursedown/__init__.py <<NO_CHECK_EOF $ cat > $TESTTMP/extlibroot/recursedown/__init__.py <<NO_CHECK_EOF
> from __future__ import absolute_import
> from extlibroot.recursedown.abs import detail as absdetail > from extlibroot.recursedown.abs import detail as absdetail
> from .legacy import detail as legacydetail > from .legacy import detail as legacydetail
> NO_CHECK_EOF > NO_CHECK_EOF
Setup package that re-exports an attribute of its submodule as the same Setup package that re-exports an attribute of its submodule as the same
name. This leaves 'shadowing.used' pointing to 'used.detail', but still name. This leaves 'shadowing.used' pointing to 'used.detail', but still
the submodule 'used' should be somehow accessible. (issue5617) the submodule 'used' should be somehow accessible. (issue5617)
$ mkdir -p $TESTTMP/extlibroot/shadowing $ mkdir -p $TESTTMP/extlibroot/shadowing
$ cat > $TESTTMP/extlibroot/shadowing/used.py <<NO_CHECK_EOF $ cat > $TESTTMP/extlibroot/shadowing/used.py <<NO_CHECK_EOF
> detail = b"this is extlibroot.shadowing.used" > detail = b"this is extlibroot.shadowing.used"
> NO_CHECK_EOF > NO_CHECK_EOF
$ cat > $TESTTMP/extlibroot/shadowing/proxied.py <<NO_CHECK_EOF $ cat > $TESTTMP/extlibroot/shadowing/proxied.py <<NO_CHECK_EOF
> from __future__ import absolute_import
> from extlibroot.shadowing.used import detail > from extlibroot.shadowing.used import detail
> NO_CHECK_EOF > NO_CHECK_EOF
$ cat > $TESTTMP/extlibroot/shadowing/__init__.py <<NO_CHECK_EOF $ cat > $TESTTMP/extlibroot/shadowing/__init__.py <<NO_CHECK_EOF
> from __future__ import absolute_import
> from .used import detail as used > from .used import detail as used
> NO_CHECK_EOF > NO_CHECK_EOF
Setup extension local modules to be imported with "absolute_import" Setup extension local modules to be imported with "absolute_import"
feature. feature.
$ mkdir -p $TESTTMP/absextroot/xsub1/xsub2 $ mkdir -p $TESTTMP/absextroot/xsub1/xsub2
$ touch $TESTTMP/absextroot/xsub1/__init__.py $ touch $TESTTMP/absextroot/xsub1/__init__.py
Setup extension local modules to examine whether demand importing Setup extension local modules to examine whether demand importing
works as expected in "level > 1" case. works as expected in "level > 1" case.
$ cat > $TESTTMP/absextroot/relimportee.py <<NO_CHECK_EOF $ cat > $TESTTMP/absextroot/relimportee.py <<NO_CHECK_EOF
> detail = b"this is absextroot.relimportee" > detail = b"this is absextroot.relimportee"
> NO_CHECK_EOF > NO_CHECK_EOF
$ cat > $TESTTMP/absextroot/xsub1/xsub2/relimporter.py <<NO_CHECK_EOF $ cat > $TESTTMP/absextroot/xsub1/xsub2/relimporter.py <<NO_CHECK_EOF
> from __future__ import absolute_import
> from mercurial import pycompat > from mercurial import pycompat
> from ... import relimportee > from ... import relimportee
> detail = b"this relimporter imports %r" % ( > detail = b"this relimporter imports %r" % (
> pycompat.bytestr(relimportee.detail)) > pycompat.bytestr(relimportee.detail))
> NO_CHECK_EOF > NO_CHECK_EOF
Setup modules, which actually import extension local modules at Setup modules, which actually import extension local modules at
runtime. runtime.
$ cat > $TESTTMP/absextroot/absolute.py << NO_CHECK_EOF $ cat > $TESTTMP/absextroot/absolute.py << NO_CHECK_EOF
> from __future__ import absolute_import
> >
> # import extension local modules absolutely (level = 0) > # import extension local modules absolutely (level = 0)
> from absextroot.xsub1.xsub2 import used, unused > from absextroot.xsub1.xsub2 import used, unused
> from absextroot.xsub1.xsub2.called import func > from absextroot.xsub1.xsub2.called import func
> >
> def getresult(): > def getresult():
> result = [] > result = []
> result.append(used.detail) > result.append(used.detail)
> result.append(func()) > result.append(func())
> return result > return result
> NO_CHECK_EOF > NO_CHECK_EOF
$ cat > $TESTTMP/absextroot/relative.py << NO_CHECK_EOF $ cat > $TESTTMP/absextroot/relative.py << NO_CHECK_EOF
> from __future__ import absolute_import
> >
> # import extension local modules relatively (level == 1) > # import extension local modules relatively (level == 1)
> from .xsub1.xsub2 import used, unused > from .xsub1.xsub2 import used, unused
> from .xsub1.xsub2.called import func > from .xsub1.xsub2.called import func
> >
> # import a module, which implies "importing with level > 1" > # import a module, which implies "importing with level > 1"
> from .xsub1.xsub2 import relimporter > from .xsub1.xsub2 import relimporter
> >
> def getresult(): > def getresult():
> result = [] > result = []
> result.append(used.detail) > result.append(used.detail)
> result.append(func()) > result.append(func())
> result.append(relimporter.detail) > result.append(relimporter.detail)
> return result > return result
> NO_CHECK_EOF > NO_CHECK_EOF
Setup main procedure of extension. Setup main procedure of extension.
$ cat > $TESTTMP/absextroot/__init__.py <<NO_CHECK_EOF $ cat > $TESTTMP/absextroot/__init__.py <<NO_CHECK_EOF
> from __future__ import absolute_import
> from mercurial import registrar > from mercurial import registrar
> cmdtable = {} > cmdtable = {}
> command = registrar.command(cmdtable) > command = registrar.command(cmdtable)
> >
> # "absolute" and "relative" shouldn't be imported before actual > # "absolute" and "relative" shouldn't be imported before actual
> # command execution, because (1) they import same modules, and (2) > # command execution, because (1) they import same modules, and (2)
> # preceding import (= instantiate "demandmod" object instead of > # preceding import (= instantiate "demandmod" object instead of
> # real "module" object) might hide problem of succeeding import. > # real "module" object) might hide problem of succeeding import.
GREPME make sure that this is in the help! GREPME make sure that this is in the help!
$ cd .. $ cd ..
Prohibit the use of unicode strings as the default value of options Prohibit the use of unicode strings as the default value of options
$ hg init $TESTTMP/opt-unicode-default $ hg init $TESTTMP/opt-unicode-default
$ cat > $TESTTMP/test_unicode_default_value.py << EOF $ cat > $TESTTMP/test_unicode_default_value.py << EOF
> from __future__ import print_function
> from mercurial import registrar > from mercurial import registrar
> cmdtable = {} > cmdtable = {}
> command = registrar.command(cmdtable) > command = registrar.command(cmdtable)
> @command(b'dummy', [(b'', b'opt', u'value', u'help')], 'ext [OPTIONS]') > @command(b'dummy', [(b'', b'opt', u'value', u'help')], 'ext [OPTIONS]')
> def ext(*args, **opts): > def ext(*args, **opts):
> print(opts[b'opt'], flush=True) > print(opts[b'opt'], flush=True)
> EOF > EOF
$ "$PYTHON" $TESTTMP/unflush.py $TESTTMP/test_unicode_default_value.py $ "$PYTHON" $TESTTMP/unflush.py $TESTTMP/test_unicode_default_value.py

tests/test-fastannotate-hg.t

merging between the revision and its ancestor merging between the revision and its ancestor
to reproduce the situation with recent Mercurial, this script uses (1) to reproduce the situation with recent Mercurial, this script uses (1)
"hg debugsetparents" to merge without ancestor check by "hg merge", "hg debugsetparents" to merge without ancestor check by "hg merge",
and (2) the extension to allow filelog merging between the revision and (2) the extension to allow filelog merging between the revision
and its ancestor by overriding "repo._filecommit". and its ancestor by overriding "repo._filecommit".
$ cat > ../legacyrepo.py <<EOF $ cat > ../legacyrepo.py <<EOF
> from __future__ import absolute_import
> from mercurial import commit, error, extensions > from mercurial import commit, error, extensions
> def _filecommit(orig, repo, fctx, manifest1, manifest2, > def _filecommit(orig, repo, fctx, manifest1, manifest2,
> linkrev, tr, includecopymeta, ms): > linkrev, tr, includecopymeta, ms):
> fname = fctx.path() > fname = fctx.path()
> text = fctx.data() > text = fctx.data()
> flog = repo.file(fname) > flog = repo.file(fname)
> fparent1 = manifest1.get(fname, repo.nullid) > fparent1 = manifest1.get(fname, repo.nullid)
> fparent2 = manifest2.get(fname, repo.nullid) > fparent2 = manifest2.get(fname, repo.nullid)

tests/test-filebranch.t

This test makes sure that we don't mark a file as merged with its ancestor This test makes sure that we don't mark a file as merged with its ancestor
when we do a merge. when we do a merge.
$ cat <<EOF > merge $ cat <<EOF > merge
> from __future__ import print_function
> import sys, os > import sys, os
> print("merging for", os.path.basename(sys.argv[1])) > print("merging for", os.path.basename(sys.argv[1]))
> EOF > EOF
$ HGMERGE="\"$PYTHON\" ../merge"; export HGMERGE $ HGMERGE="\"$PYTHON\" ../merge"; export HGMERGE
Creating base: Creating base:
$ hg init a $ hg init a

tests/test-fncache.t

#require repofncache #require repofncache
An extension which will set fncache chunksize to 1 byte to make sure that logic An extension which will set fncache chunksize to 1 byte to make sure that logic
does not break does not break
$ cat > chunksize.py <<EOF $ cat > chunksize.py <<EOF
> from __future__ import absolute_import
> from mercurial import store > from mercurial import store
> store.fncache_chunksize = 1 > store.fncache_chunksize = 1
> EOF > EOF
$ cat >> $HGRCPATH <<EOF $ cat >> $HGRCPATH <<EOF
> [extensions] > [extensions]
> chunksize = $TESTTMP/chunksize.py > chunksize = $TESTTMP/chunksize.py
> EOF > EOF
.hg/store/dh/enterpri/openesba/contrib-/corba-bc/netbeans/wsdlexte/src/main/java/org.net7018f27961fdf338a598a40c4683429e7ffb9743.i .hg/store/dh/enterpri/openesba/contrib-/corba-bc/netbeans/wsdlexte/src/main/java/org.net7018f27961fdf338a598a40c4683429e7ffb9743.i
.hg/store/dh/project_/resource/anotherl/followed/andanoth/andthenanextremelylongfilename0d8e1f4187c650e2f1fdca9fd90f786bc0976b6b.i .hg/store/dh/project_/resource/anotherl/followed/andanoth/andthenanextremelylongfilename0d8e1f4187c650e2f1fdca9fd90f786bc0976b6b.i
$ cd .. $ cd ..
Aborting lock does not prevent fncache writes Aborting lock does not prevent fncache writes
$ cat > exceptionext.py <<EOF $ cat > exceptionext.py <<EOF
> from __future__ import absolute_import
> import os > import os
> from mercurial import commands, error, extensions > from mercurial import commands, error, extensions
> >
> def lockexception(orig, vfs, lockname, wait, releasefn, *args, **kwargs): > def lockexception(orig, vfs, lockname, wait, releasefn, *args, **kwargs):
> def releasewrap(): > def releasewrap():
> l.held = False # ensure __del__ is a noop > l.held = False # ensure __del__ is a noop
> raise error.Abort(b"forced lock failure") > raise error.Abort(b"forced lock failure")
> l = orig(vfs, lockname, wait, releasewrap, *args, **kwargs) > l = orig(vfs, lockname, wait, releasewrap, *args, **kwargs)
abort: forced lock failure abort: forced lock failure
[255] [255]
$ cat .hg/store/fncache $ cat .hg/store/fncache
data/y.i data/y.i
Aborting transaction prevents fncache change Aborting transaction prevents fncache change
$ cat > ../exceptionext.py <<EOF $ cat > ../exceptionext.py <<EOF
> from __future__ import absolute_import
> import os > import os
> from mercurial import commands, error, extensions, localrepo > from mercurial import commands, error, extensions, localrepo
> >
> def wrapper(orig, self, *args, **kwargs): > def wrapper(orig, self, *args, **kwargs):
> tr = orig(self, *args, **kwargs) > tr = orig(self, *args, **kwargs)
> def fail(tr): > def fail(tr):
> raise error.Abort(b"forced transaction failure") > raise error.Abort(b"forced transaction failure")
> # zzz prefix to ensure it sorted after store.write > # zzz prefix to ensure it sorted after store.write
abort: forced transaction failure abort: forced transaction failure
[255] [255]
$ cat .hg/store/fncache $ cat .hg/store/fncache
data/y.i data/y.i
Aborted transactions can be recovered later Aborted transactions can be recovered later
$ cat > ../exceptionext.py <<EOF $ cat > ../exceptionext.py <<EOF
> from __future__ import absolute_import
> import os > import os
> from mercurial import ( > from mercurial import (
> commands, > commands,
> error, > error,
> extensions, > extensions,
> localrepo, > localrepo,
> transaction, > transaction,
> ) > )
$ cd .. $ cd ..
In repositories that have accumulated a large number of files over time, the In repositories that have accumulated a large number of files over time, the
fncache file is going to be large. If we possibly can avoid loading it, so much the better. fncache file is going to be large. If we possibly can avoid loading it, so much the better.
The cache should not loaded when committing changes to existing files, or when unbundling The cache should not loaded when committing changes to existing files, or when unbundling
changesets that only contain changes to existing files: changesets that only contain changes to existing files:
$ cat > fncacheloadwarn.py << EOF $ cat > fncacheloadwarn.py << EOF
> from __future__ import absolute_import
> from mercurial import extensions, localrepo > from mercurial import extensions, localrepo
> >
> def extsetup(ui): > def extsetup(ui):
> def wrapstore(orig, requirements, *args): > def wrapstore(orig, requirements, *args):
> store = orig(requirements, *args) > store = orig(requirements, *args)
> if b'store' in requirements and b'fncache' in requirements: > if b'store' in requirements and b'fncache' in requirements:
> instrumentfncachestore(store, ui) > instrumentfncachestore(store, ui)
> return store > return store

tests/test-hardlinks.t

#require hardlink reporevlogstore #require hardlink reporevlogstore
$ cat > nlinks.py <<EOF $ cat > nlinks.py <<EOF
> from __future__ import print_function
> import sys > import sys
> from mercurial import pycompat, util > from mercurial import pycompat, util
> for f in sorted(sys.stdin.readlines()): > for f in sorted(sys.stdin.readlines()):
> f = f[:-1] > f = f[:-1]
> print(util.nlinks(pycompat.fsencode(f)), f) > print(util.nlinks(pycompat.fsencode(f)), f)
> EOF > EOF
$ nlinksdir() $ nlinksdir()
> { > {
> find "$@" -type f | "$PYTHON" $TESTTMP/nlinks.py > find "$@" -type f | "$PYTHON" $TESTTMP/nlinks.py
> } > }
Some implementations of cp can't create hardlinks (replaces 'cp -al' on Linux): Some implementations of cp can't create hardlinks (replaces 'cp -al' on Linux):
$ cat > linkcp.py <<EOF $ cat > linkcp.py <<EOF
> from __future__ import absolute_import
> import sys > import sys
> from mercurial import pycompat, util > from mercurial import pycompat, util
> util.copyfiles(pycompat.fsencode(sys.argv[1]), > util.copyfiles(pycompat.fsencode(sys.argv[1]),
> pycompat.fsencode(sys.argv[2]), hardlink=True) > pycompat.fsencode(sys.argv[2]), hardlink=True)
> EOF > EOF
$ linkcp() $ linkcp()
> { > {

tests/test-help.t

> >
> .. container:: verbose > .. container:: verbose
> >
> This paragraph is omitted, > This paragraph is omitted,
> if :hg:\`help\` is invoked without \`\`-v\`\` (for extension) > if :hg:\`help\` is invoked without \`\`-v\`\` (for extension)
> >
> This paragraph is never omitted, too (for extension) > This paragraph is never omitted, too (for extension)
> ''' > '''
> from __future__ import absolute_import
> from mercurial import commands, help > from mercurial import commands, help
> testtopic = br"""This paragraph is never omitted (for topic). > testtopic = br"""This paragraph is never omitted (for topic).
> >
> .. container:: verbose > .. container:: verbose
> >
> This paragraph is omitted, > This paragraph is omitted,
> if :hg:\`help\` is invoked without \`\`-v\`\` (for topic) > if :hg:\`help\` is invoked without \`\`-v\`\` (for topic)
> >

tests/test-hgweb-no-path-info.t

$ hg tip $ hg tip
changeset: 0:61c9426e69fe changeset: 0:61c9426e69fe
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
$ cat > request.py <<EOF $ cat > request.py <<EOF
> from __future__ import absolute_import
> import os > import os
> import sys > import sys
> from mercurial import ( > from mercurial import (
> hgweb, > hgweb,
> util, > util,
> ) > )
> stringio = util.stringio > stringio = util.stringio
> >

tests/test-hgweb-no-request-uri.t

$ hg tip $ hg tip
changeset: 0:61c9426e69fe changeset: 0:61c9426e69fe
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
$ cat > request.py <<EOF $ cat > request.py <<EOF
> from __future__ import absolute_import
> import os > import os
> import sys > import sys
> from mercurial import ( > from mercurial import (
> encoding, > encoding,
> hgweb, > hgweb,
> util, > util,
> ) > )
> stringio = util.stringio > stringio = util.stringio

tests/test-hgweb-non-interactive.t

Tests if hgweb can run without touching sys.stdin, as is required Tests if hgweb can run without touching sys.stdin, as is required
by the WSGI standard and strictly implemented by mod_wsgi. by the WSGI standard and strictly implemented by mod_wsgi.
$ hg init repo $ hg init repo
$ cd repo $ cd repo
$ echo foo > bar $ echo foo > bar
$ hg add bar $ hg add bar
$ hg commit -m "test" $ hg commit -m "test"
$ cat > request.py <<EOF $ cat > request.py <<EOF
> from __future__ import absolute_import
> import os > import os
> import sys > import sys
> from mercurial import ( > from mercurial import (
> dispatch, > dispatch,
> encoding, > encoding,
> hg, > hg,
> ui as uimod, > ui as uimod,
> util, > util,

tests/test-hook.t

HG_SOURCE=clone HG_SOURCE=clone
abort: preoutgoing.forbid hook exited with status 1 abort: preoutgoing.forbid hook exited with status 1
[40] [40]
$ cd "$TESTTMP/b" $ cd "$TESTTMP/b"
$ cat > hooktests.py <<EOF $ cat > hooktests.py <<EOF
> from __future__ import print_function
> from mercurial import ( > from mercurial import (
> error, > error,
> pycompat, > pycompat,
> ) > )
> >
> uncallable = 0 > uncallable = 0
> >
> def printargs(ui, args): > def printargs(ui, args):

tests/test-impexp-branch.t

$ echo '[extensions]' >> $HGRCPATH $ echo '[extensions]' >> $HGRCPATH
$ echo 'strip =' >> $HGRCPATH $ echo 'strip =' >> $HGRCPATH
$ cat >findbranch.py <<EOF $ cat >findbranch.py <<EOF
> from __future__ import absolute_import
> import re > import re
> import sys > import sys
> >
> head_re = re.compile(r'^#(?:(?:\\s+([A-Za-z][A-Za-z0-9_]*)(?:\\s.*)?)|(?:\\s*))$') > head_re = re.compile(r'^#(?:(?:\\s+([A-Za-z][A-Za-z0-9_]*)(?:\\s.*)?)|(?:\\s*))$')
> >
> for line in sys.stdin: > for line in sys.stdin:
> hmatch = head_re.match(line) > hmatch = head_re.match(line)
> if not hmatch: > if not hmatch:

tests/test-import.t

$ rm -r b $ rm -r b
import exported patch with external patcher import exported patch with external patcher
(this also tests that editor is invoked, if the '--edit' is specified, (this also tests that editor is invoked, if the '--edit' is specified,
regardless of the commit message in the patch) regardless of the commit message in the patch)
$ cat > dummypatch.py <<EOF $ cat > dummypatch.py <<EOF
> from __future__ import print_function
> print('patching file a') > print('patching file a')
> open('a', 'wb').write(b'line2\n') > open('a', 'wb').write(b'line2\n')
> EOF > EOF
$ hg clone -r0 a b $ hg clone -r0 a b
adding changesets adding changesets
adding manifests adding manifests
adding file changes adding file changes
added 1 changesets with 2 changes to 2 files added 1 changesets with 2 changes to 2 files

tests/test-imports-checker.t

$ "$PYTHON" -m doctest $import_checker $ "$PYTHON" -m doctest $import_checker
Run additional tests for the import checker Run additional tests for the import checker
$ mkdir testpackage $ mkdir testpackage
$ touch testpackage/__init__.py $ touch testpackage/__init__.py
$ cat > testpackage/multiple.py << EOF $ cat > testpackage/multiple.py << EOF
> from __future__ import absolute_import
> import os, sys > import os, sys
> EOF > EOF
$ cat > testpackage/unsorted.py << EOF $ cat > testpackage/unsorted.py << EOF
> from __future__ import absolute_import
> import sys > import sys
> import os > import os
> EOF > EOF
$ cat > testpackage/stdafterlocal.py << EOF $ cat > testpackage/stdafterlocal.py << EOF
> from __future__ import absolute_import
> from . import unsorted > from . import unsorted
> import os > import os
> EOF > EOF
$ cat > testpackage/requirerelative.py << EOF $ cat > testpackage/requirerelative.py << EOF
> from __future__ import absolute_import
> import testpackage.unsorted > import testpackage.unsorted
> EOF > EOF
$ cat > testpackage/importalias.py << EOF $ cat > testpackage/importalias.py << EOF
> from __future__ import absolute_import
> import ui > import ui
> EOF > EOF
$ cat > testpackage/relativestdlib.py << EOF $ cat > testpackage/relativestdlib.py << EOF
> from __future__ import absolute_import
> from .. import os > from .. import os
> EOF > EOF
$ cat > testpackage/stdlibfrom.py << EOF $ cat > testpackage/stdlibfrom.py << EOF
> from __future__ import absolute_import
> from collections import abc > from collections import abc
> EOF > EOF
$ cat > testpackage/symbolimport.py << EOF $ cat > testpackage/symbolimport.py << EOF
> from __future__ import absolute_import
> from .unsorted import foo > from .unsorted import foo
> EOF > EOF
$ cat > testpackage/latesymbolimport.py << EOF $ cat > testpackage/latesymbolimport.py << EOF
> from __future__ import absolute_import
> from . import unsorted > from . import unsorted
> from mercurial.node import hex > from mercurial.node import hex
> EOF > EOF
$ cat > testpackage/multiplegroups.py << EOF $ cat > testpackage/multiplegroups.py << EOF
> from __future__ import absolute_import
> from . import unsorted > from . import unsorted
> from . import more > from . import more
> EOF > EOF
$ mkdir testpackage/subpackage $ mkdir testpackage/subpackage
$ cat > testpackage/subpackage/levelpriority.py << EOF $ cat > testpackage/subpackage/levelpriority.py << EOF
> from __future__ import absolute_import
> from . import foo > from . import foo
> from .. import parent > from .. import parent
> EOF > EOF
$ touch testpackage/subpackage/foo.py $ touch testpackage/subpackage/foo.py
$ cat > testpackage/subpackage/__init__.py << EOF $ cat > testpackage/subpackage/__init__.py << EOF
> from __future__ import absolute_import
> from . import levelpriority # should not cause cycle > from . import levelpriority # should not cause cycle
> EOF > EOF
$ cat > testpackage/subpackage/localimport.py << EOF $ cat > testpackage/subpackage/localimport.py << EOF
> from __future__ import absolute_import
> from . import foo > from . import foo
> def bar(): > def bar():
> # should not cause "higher-level import should come first" > # should not cause "higher-level import should come first"
> from .. import unsorted > from .. import unsorted
> # but other errors should be detected > # but other errors should be detected
> from .. import more > from .. import more
> import testpackage.subpackage.levelpriority > import testpackage.subpackage.levelpriority
> EOF > EOF
$ cat > testpackage/importmodulefromsub.py << EOF $ cat > testpackage/importmodulefromsub.py << EOF
> from __future__ import absolute_import
> from .subpackage import foo # not a "direct symbol import" > from .subpackage import foo # not a "direct symbol import"
> EOF > EOF
$ cat > testpackage/importsymbolfromsub.py << EOF $ cat > testpackage/importsymbolfromsub.py << EOF
> from __future__ import absolute_import
> from .subpackage import foo, nonmodule > from .subpackage import foo, nonmodule
> EOF > EOF
$ cat > testpackage/sortedentries.py << EOF $ cat > testpackage/sortedentries.py << EOF
> from __future__ import absolute_import
> from . import ( > from . import (
> foo, > foo,
> bar, > bar,
> ) > )
> EOF > EOF
$ cat > testpackage/importfromalias.py << EOF $ cat > testpackage/importfromalias.py << EOF
> from __future__ import absolute_import
> from . import ui > from . import ui
> EOF > EOF
$ cat > testpackage/importfromrelative.py << EOF $ cat > testpackage/importfromrelative.py << EOF
> from __future__ import absolute_import
> from testpackage.unsorted import foo > from testpackage.unsorted import foo
> EOF > EOF
$ mkdir testpackage2 $ mkdir testpackage2
$ touch testpackage2/__init__.py $ touch testpackage2/__init__.py
$ cat > testpackage2/latesymbolimport.py << EOF $ cat > testpackage2/latesymbolimport.py << EOF
> from __future__ import absolute_import
> from testpackage import unsorted > from testpackage import unsorted
> from mercurial.node import hex > from mercurial.node import hex
> EOF > EOF
# Shadowing a stdlib module to test "relative import of stdlib module" is # Shadowing a stdlib module to test "relative import of stdlib module" is
# allowed if the module is also being checked # allowed if the module is also being checked
$ mkdir email $ mkdir email
$ touch email/__init__.py $ touch email/__init__.py
$ touch email/errors.py $ touch email/errors.py
$ cat > email/utils.py << EOF $ cat > email/utils.py << EOF
> from __future__ import absolute_import
> from . import errors > from . import errors
> EOF > EOF
$ "$PYTHON" "$import_checker" testpackage*/*.py testpackage/subpackage/*.py \ $ "$PYTHON" "$import_checker" testpackage*/*.py testpackage/subpackage/*.py \
> email/*.py > email/*.py
testpackage/importalias.py:2: ui module must be "as" aliased to uimod testpackage/importalias.py:1: ui module must be "as" aliased to uimod
testpackage/importfromalias.py:2: ui from testpackage must be "as" aliased to uimod testpackage/importfromalias.py:1: ui from testpackage must be "as" aliased to uimod
testpackage/importfromrelative.py:2: import should be relative: testpackage.unsorted testpackage/importfromrelative.py:1: import should be relative: testpackage.unsorted
testpackage/importfromrelative.py:2: direct symbol import foo from testpackage.unsorted testpackage/importfromrelative.py:1: direct symbol import foo from testpackage.unsorted
testpackage/importsymbolfromsub.py:2: direct symbol import nonmodule from testpackage.subpackage testpackage/importsymbolfromsub.py:1: direct symbol import nonmodule from testpackage.subpackage
testpackage/latesymbolimport.py:3: symbol import follows non-symbol import: mercurial.node testpackage/latesymbolimport.py:2: symbol import follows non-symbol import: mercurial.node
testpackage/multiple.py:2: multiple imported names: os, sys testpackage/multiple.py:1: multiple imported names: os, sys
testpackage/multiplegroups.py:3: multiple "from . import" statements testpackage/multiplegroups.py:2: multiple "from . import" statements
testpackage/relativestdlib.py:2: relative import of stdlib module testpackage/relativestdlib.py:1: relative import of stdlib module
testpackage/requirerelative.py:2: import should be relative: testpackage.unsorted testpackage/requirerelative.py:1: import should be relative: testpackage.unsorted
testpackage/sortedentries.py:2: imports from testpackage not lexically sorted: bar < foo testpackage/sortedentries.py:1: imports from testpackage not lexically sorted: bar < foo
testpackage/stdafterlocal.py:3: stdlib import "os" follows local import: testpackage testpackage/stdafterlocal.py:2: stdlib import "os" follows local import: testpackage
testpackage/stdlibfrom.py:2: direct symbol import abc from collections testpackage/stdlibfrom.py:1: direct symbol import abc from collections
testpackage/subpackage/levelpriority.py:3: higher-level import should come first: testpackage testpackage/subpackage/levelpriority.py:2: higher-level import should come first: testpackage
testpackage/subpackage/localimport.py:7: multiple "from .. import" statements testpackage/subpackage/localimport.py:6: multiple "from .. import" statements
testpackage/subpackage/localimport.py:8: import should be relative: testpackage.subpackage.levelpriority testpackage/subpackage/localimport.py:7: import should be relative: testpackage.subpackage.levelpriority
testpackage/symbolimport.py:2: direct symbol import foo from testpackage.unsorted testpackage/symbolimport.py:1: direct symbol import foo from testpackage.unsorted
testpackage/unsorted.py:3: imports not lexically sorted: os < sys testpackage/unsorted.py:2: imports not lexically sorted: os < sys
testpackage2/latesymbolimport.py:3: symbol import follows non-symbol import: mercurial.node testpackage2/latesymbolimport.py:2: symbol import follows non-symbol import: mercurial.node
[1] [1]

tests/test-inherit-mode.t

#require unix-permissions #require unix-permissions
test that new files created in .hg inherit the permissions from .hg/store test that new files created in .hg inherit the permissions from .hg/store
$ mkdir dir $ mkdir dir
just in case somebody has a strange $TMPDIR just in case somebody has a strange $TMPDIR
$ chmod g-s dir $ chmod g-s dir
$ cd dir $ cd dir
$ cat >printmodes.py <<EOF $ cat >printmodes.py <<EOF
> from __future__ import absolute_import, print_function
> import os > import os
> import sys > import sys
> >
> allnames = [] > allnames = []
> isdir = {} > isdir = {}
> for root, dirs, files in os.walk(sys.argv[1]): > for root, dirs, files in os.walk(sys.argv[1]):
> for d in dirs: > for d in dirs:
> name = os.path.join(root, d) > name = os.path.join(root, d)
> isdir[name] = 1 > isdir[name] = 1
> allnames.append(name) > allnames.append(name)
> for f in files: > for f in files:
> name = os.path.join(root, f) > name = os.path.join(root, f)
> allnames.append(name) > allnames.append(name)
> allnames.sort() > allnames.sort()
> for name in allnames: > for name in allnames:
> suffix = name in isdir and '/' or '' > suffix = name in isdir and '/' or ''
> print('%05o %s%s' % (os.lstat(name).st_mode & 0o7777, name, suffix)) > print('%05o %s%s' % (os.lstat(name).st_mode & 0o7777, name, suffix))
> EOF > EOF
$ cat >mode.py <<EOF $ cat >mode.py <<EOF
> from __future__ import absolute_import, print_function
> import os > import os
> import sys > import sys
> print('%05o' % os.lstat(sys.argv[1]).st_mode) > print('%05o' % os.lstat(sys.argv[1]).st_mode)
> EOF > EOF
$ umask 077 $ umask 077
$ hg init repo $ hg init repo

tests/test-largefiles-cache.t

(run 'hg update' to get a working copy) (run 'hg update' to get a working copy)
#if unix-permissions #if unix-permissions
Portable way to print file permissions: Portable way to print file permissions:
$ cat > ls-l.py <<EOF $ cat > ls-l.py <<EOF
> #!$PYTHON > #!$PYTHON
> from __future__ import absolute_import, print_function
> import os > import os
> import sys > import sys
> path = sys.argv[1] > path = sys.argv[1]
> print('%03o' % (os.lstat(path).st_mode & 0o777)) > print('%03o' % (os.lstat(path).st_mode & 0o777))
> EOF > EOF
$ chmod +x ls-l.py $ chmod +x ls-l.py
Test that files in .hg/largefiles inherit mode from .hg/store, not Test that files in .hg/largefiles inherit mode from .hg/store, not

tests/test-largefiles-small-disk.t

Test how largefiles abort in case the disk runs full Test how largefiles abort in case the disk runs full
$ cat > criple.py <<EOF $ cat > criple.py <<EOF
> from __future__ import absolute_import
> import errno > import errno
> import os > import os
> import shutil > import shutil
> from mercurial import util > from mercurial import util
> # > #
> # this makes the original largefiles code abort: > # this makes the original largefiles code abort:
> _origcopyfileobj = shutil.copyfileobj > _origcopyfileobj = shutil.copyfileobj
> def copyfileobj(fsrc, fdst, length=16 * 1024): > def copyfileobj(fsrc, fdst, length=16 * 1024):

tests/test-log-exthook.t

Test hg log changeset printer external hook Test hg log changeset printer external hook
------------------------------------------- -------------------------------------------
$ cat > $TESTTMP/logexthook.py <<EOF $ cat > $TESTTMP/logexthook.py <<EOF
> from __future__ import absolute_import
> import codecs > import codecs
> from mercurial import ( > from mercurial import (
> commands, > commands,
> logcmdutil, > logcmdutil,
> repair, > repair,
> ) > )
> def brot13(b): > def brot13(b):
> return codecs.encode(b.decode('utf8'), 'rot-13').encode('utf8') > return codecs.encode(b.decode('utf8'), 'rot-13').encode('utf8')

tests/test-log.t

[20] [20]
$ hg revert -aqC $ hg revert -aqC
Check that adding an arbitrary name shows up in log automatically Check that adding an arbitrary name shows up in log automatically
$ cat > ../names.py <<EOF $ cat > ../names.py <<EOF
> """A small extension to test adding arbitrary names to a repo""" > """A small extension to test adding arbitrary names to a repo"""
> from __future__ import absolute_import
> from mercurial import namespaces > from mercurial import namespaces
> >
> def reposetup(ui, repo): > def reposetup(ui, repo):
> if not repo.local(): > if not repo.local():
> return > return
> foo = {b'foo': repo[0].node()} > foo = {b'foo': repo[0].node()}
> names = lambda r: foo.keys() > names = lambda r: foo.keys()
> namemap = lambda r, name: foo.get(name) > namemap = lambda r, name: foo.get(name)

tests/test-logtoprocess.t

#require no-windows #require no-windows
ATTENTION: logtoprocess runs commands asynchronously. Be sure to append "| cat" ATTENTION: logtoprocess runs commands asynchronously. Be sure to append "| cat"
to hg commands, to wait for the output, if you want to test its output. to hg commands, to wait for the output, if you want to test its output.
Otherwise the test will be flaky. Otherwise the test will be flaky.
Test if logtoprocess correctly captures command-related log calls. Test if logtoprocess correctly captures command-related log calls.
$ hg init $ hg init
$ cat > $TESTTMP/foocommand.py << EOF $ cat > $TESTTMP/foocommand.py << EOF
> from __future__ import absolute_import
> from mercurial import registrar > from mercurial import registrar
> cmdtable = {} > cmdtable = {}
> command = registrar.command(cmdtable) > command = registrar.command(cmdtable)
> configtable = {} > configtable = {}
> configitem = registrar.configitem(configtable) > configitem = registrar.configitem(configtable)
> configitem(b'logtoprocess', b'foo', > configitem(b'logtoprocess', b'foo',
> default=None, > default=None,
> ) > )

tests/test-merge-symlinks.t

$ cat > echo.py <<EOF $ cat > echo.py <<EOF
> #!$PYTHON > #!$PYTHON
> from __future__ import absolute_import, print_function
> import os > import os
> import sys > import sys
> try: > try:
> import msvcrt > import msvcrt
> msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY) > msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY)
> msvcrt.setmode(sys.stderr.fileno(), os.O_BINARY) > msvcrt.setmode(sys.stderr.fileno(), os.O_BINARY)
> except ImportError: > except ImportError:
> pass > pass

tests/test-merge1.t

$ cat <<EOF > merge $ cat <<EOF > merge
> from __future__ import print_function
> import sys, os > import sys, os
> >
> try: > try:
> import msvcrt > import msvcrt
> msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY) > msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY)
> msvcrt.setmode(sys.stderr.fileno(), os.O_BINARY) > msvcrt.setmode(sys.stderr.fileno(), os.O_BINARY)
> except ImportError: > except ImportError:
> pass > pass
aren't changed), even if none of mode, size and timestamp of them aren't changed), even if none of mode, size and timestamp of them
isn't changed on the filesystem (see also issue4583). isn't changed on the filesystem (see also issue4583).
This test is now "best effort" as the mechanism to prevent such race are This test is now "best effort" as the mechanism to prevent such race are
getting better, it get more complicated to test a specific scenario that would getting better, it get more complicated to test a specific scenario that would
trigger it. If you see flakyness here, there is a race. trigger it. If you see flakyness here, there is a race.
$ cat > $TESTTMP/abort.py <<EOF $ cat > $TESTTMP/abort.py <<EOF
> from __future__ import absolute_import
> # emulate aborting before "recordupdates()". in this case, files > # emulate aborting before "recordupdates()". in this case, files
> # are changed without updating dirstate > # are changed without updating dirstate
> from mercurial import ( > from mercurial import (
> error, > error,
> extensions, > extensions,
> merge, > merge,
> ) > )
> def applyupdates(orig, *args, **kwargs): > def applyupdates(orig, *args, **kwargs):

tests/test-narrow-clone-non-narrow-server.t

> --pid-file=hg.pid > --pid-file=hg.pid
$ cat hg.pid >> "$DAEMON_PIDS" $ cat hg.pid >> "$DAEMON_PIDS"
$ hg serve -a localhost -p $HGPORT2 -d --pid-file=hg.pid $ hg serve -a localhost -p $HGPORT2 -d --pid-file=hg.pid
$ cat hg.pid >> "$DAEMON_PIDS" $ cat hg.pid >> "$DAEMON_PIDS"
Verify that narrow is advertised in the bundle2 capabilities: Verify that narrow is advertised in the bundle2 capabilities:
$ cat >> unquote.py <<EOF $ cat >> unquote.py <<EOF
> from __future__ import print_function
> import sys > import sys
> if sys.version[0] == '3': > if sys.version[0] == '3':
> import urllib.parse as up > import urllib.parse as up
> unquote = up.unquote_plus > unquote = up.unquote_plus
> else: > else:
> import urllib > import urllib
> unquote = urllib.unquote_plus > unquote = urllib.unquote_plus
> print(unquote(list(sys.stdin)[1])) > print(unquote(list(sys.stdin)[1]))

tests/test-notify.t

$ cat > $TESTTMP/filter.py <<EOF $ cat > $TESTTMP/filter.py <<EOF
> from __future__ import absolute_import, print_function
> import io > import io
> import re > import re
> import sys > import sys
> if sys.version_info[0] >= 3: > if sys.version_info[0] >= 3:
> sys.stdout = io.TextIOWrapper( > sys.stdout = io.TextIOWrapper(
> sys.stdout.buffer, > sys.stdout.buffer,
> sys.stdout.encoding, > sys.stdout.encoding,
> sys.stdout.errors, > sys.stdout.errors,

tests/test-obsolete.t

$ killdaemons.py $ killdaemons.py
#endif #endif
Test heads computation on pending index changes with obsolescence markers Test heads computation on pending index changes with obsolescence markers
$ cd .. $ cd ..
$ cat >$TESTTMP/test_extension.py << EOF $ cat >$TESTTMP/test_extension.py << EOF
> from __future__ import absolute_import
> from mercurial.i18n import _ > from mercurial.i18n import _
> from mercurial import cmdutil, pycompat, registrar > from mercurial import cmdutil, pycompat, registrar
> from mercurial.utils import stringutil > from mercurial.utils import stringutil
> >
> cmdtable = {} > cmdtable = {}
> command = registrar.command(cmdtable) > command = registrar.command(cmdtable)
> @command(b"amendtransient",[], _(b'hg amendtransient [rev]')) > @command(b"amendtransient",[], _(b'hg amendtransient [rev]'))
> def amend(ui, repo, *pats, **opts): > def amend(ui, repo, *pats, **opts):
1 new orphan changesets 1 new orphan changesets
[1, 2] [1, 2]
Test cache consistency for the visible filter Test cache consistency for the visible filter
1) We want to make sure that the cached filtered revs are invalidated when 1) We want to make sure that the cached filtered revs are invalidated when
bookmarks change bookmarks change
$ cd .. $ cd ..
$ cat >$TESTTMP/test_extension.py << EOF $ cat >$TESTTMP/test_extension.py << EOF
> from __future__ import absolute_import, print_function
> import weakref > import weakref
> from mercurial import ( > from mercurial import (
> bookmarks, > bookmarks,
> cmdutil, > cmdutil,
> extensions, > extensions,
> repoview, > repoview,
> ) > )
> def _bookmarkchanged(orig, bkmstoreinst, *args, **kwargs): > def _bookmarkchanged(orig, bkmstoreinst, *args, **kwargs):

tests/test-pager.t

$ echo append >> a $ echo append >> a
$ hg --config extensions.pushbuffer=$TESTTMP/pushbufferpager.py status --color=off $ hg --config extensions.pushbuffer=$TESTTMP/pushbufferpager.py status --color=off
content content
paged! 'M a\n' paged! 'M a\n'
Environment variables like LESS and LV are set automatically: Environment variables like LESS and LV are set automatically:
$ cat > $TESTTMP/printlesslv.py <<EOF $ cat > $TESTTMP/printlesslv.py <<EOF
> from __future__ import absolute_import
> import os > import os
> import sys > import sys
> sys.stdin.read() > sys.stdin.read()
> for name in ['LESS', 'LV']: > for name in ['LESS', 'LV']:
> sys.stdout.write(('%s=%s\n') % (name, os.environ.get(name, '-'))) > sys.stdout.write(('%s=%s\n') % (name, os.environ.get(name, '-')))
> sys.stdout.flush() > sys.stdout.flush()
> EOF > EOF

tests/test-parseindex.t

changeset: 1:26333235a41c changeset: 1:26333235a41c
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: change foo summary: change foo
$ cat >> test.py << EOF $ cat >> test.py << EOF
> from __future__ import print_function
> from mercurial import changelog, node, pycompat, vfs > from mercurial import changelog, node, pycompat, vfs
> >
> class singlebyteread(object): > class singlebyteread(object):
> def __init__(self, real): > def __init__(self, real):
> self.real = real > self.real = real
> >
> def read(self, size=-1): > def read(self, size=-1):
> if size == 65536: > if size == 65536:
#if no-pure #if no-pure
Test SEGV caused by bad revision passed to reachableroots() (issue4775): Test SEGV caused by bad revision passed to reachableroots() (issue4775):
$ cd a $ cd a
$ "$PYTHON" <<EOF $ "$PYTHON" <<EOF
> from __future__ import print_function
> from mercurial import changelog, vfs > from mercurial import changelog, vfs
> cl = changelog.changelog(vfs.vfs(b'.hg/store')) > cl = changelog.changelog(vfs.vfs(b'.hg/store'))
> print('good heads:') > print('good heads:')
> for head in [0, len(cl) - 1, -1]: > for head in [0, len(cl) - 1, -1]:
> print('%s: %r' % (head, cl.reachableroots(0, [head], [0]))) > print('%s: %r' % (head, cl.reachableroots(0, [head], [0])))
> print('bad heads:') > print('bad heads:')
> for head in [len(cl), 10000, -2, -10000, None]: > for head in [len(cl), 10000, -2, -10000, None]:
> print('%s:' % head, end=' ') > print('%s:' % head, end=' ')
1 0000 65 1 0 65536 26333235a41c 1 0000 65 1 0 65536 26333235a41c
$ hg -R segv debugdeltachain -c $ hg -R segv debugdeltachain -c
rev chain# chainlen prev delta size rawsize chainsize ratio lindist extradist extraratio rev chain# chainlen prev delta size rawsize chainsize ratio lindist extradist extraratio
0 1 1 -1 base 63 62 63 1.01613 63 0 0.00000 0 1 1 -1 base 63 62 63 1.01613 63 0 0.00000
1 2 1 -1 base 66 65 66 1.01538 66 0 0.00000 1 2 1 -1 base 66 65 66 1.01538 66 0 0.00000
$ cat <<EOF > test.py $ cat <<EOF > test.py
> from __future__ import print_function
> import sys > import sys
> from mercurial import changelog, pycompat, vfs > from mercurial import changelog, pycompat, vfs
> cl = changelog.changelog(vfs.vfs(pycompat.fsencode(sys.argv[1]))) > cl = changelog.changelog(vfs.vfs(pycompat.fsencode(sys.argv[1])))
> n0, n1 = cl.node(0), cl.node(1) > n0, n1 = cl.node(0), cl.node(1)
> ops = [ > ops = [
> ('reachableroots', > ('reachableroots',
> lambda: cl.index.reachableroots2(0, [1], [0], False)), > lambda: cl.index.reachableroots2(0, [1], [0], False)),
> ('compute_phases_map_sets', lambda: cl.computephases({1: {cl.node(0)}})), > ('compute_phases_map_sets', lambda: cl.computephases({1: {cl.node(0)}})),

tests/test-patch.t

$ cat > patchtool.py <<EOF $ cat > patchtool.py <<EOF
> from __future__ import absolute_import, print_function
> import sys > import sys
> print('Using custom patch') > print('Using custom patch')
> if '--binary' in sys.argv: > if '--binary' in sys.argv:
> print('--binary found !') > print('--binary found !')
> EOF > EOF
$ echo "[ui]" >> $HGRCPATH $ echo "[ui]" >> $HGRCPATH
$ echo "patch=\"$PYTHON\" ../patchtool.py" >> $HGRCPATH $ echo "patch=\"$PYTHON\" ../patchtool.py" >> $HGRCPATH

tests/test-patchbomb.t

Note for future hackers of patchbomb: this file is a bit heavy on Note for future hackers of patchbomb: this file is a bit heavy on
wildcards in test expectations due to how many things like hostnames wildcards in test expectations due to how many things like hostnames
tend to make it into outputs. As a result, you may need to perform the tend to make it into outputs. As a result, you may need to perform the
following regular expression substitutions: following regular expression substitutions:
Mercurial-patchbomb/.* -> Mercurial-patchbomb/* (glob) Mercurial-patchbomb/.* -> Mercurial-patchbomb/* (glob)
/mixed; boundary="===+[0-9]+==" -> /mixed; boundary="===*== (glob)" /mixed; boundary="===+[0-9]+==" -> /mixed; boundary="===*== (glob)"
--===+[0-9]+=+--$ -> --===*=-- (glob) --===+[0-9]+=+--$ -> --===*=-- (glob)
--===+[0-9]+=+$ -> --===*= (glob) --===+[0-9]+=+$ -> --===*= (glob)
$ cat > prune-blank-after-boundary.py <<EOF $ cat > prune-blank-after-boundary.py <<EOF
> from __future__ import absolute_import, print_function
> import sys > import sys
> skipblank = False > skipblank = False
> trim = lambda x: x.strip(' \r\n') > trim = lambda x: x.strip(' \r\n')
> for l in sys.stdin: > for l in sys.stdin:
> if trim(l).endswith('=--') or trim(l).endswith('=='): > if trim(l).endswith('=--') or trim(l).endswith('=='):
> skipblank = True > skipblank = True
> print(l, end='') > print(l, end='')
> continue > continue

tests/test-profile.t

[1] [1]
$ cd .. $ cd ..
#if no-chg #if no-chg
profiler extension could be loaded before other extensions profiler extension could be loaded before other extensions
$ cat > fooprof.py <<EOF $ cat > fooprof.py <<EOF
> from __future__ import absolute_import
> import contextlib > import contextlib
> import sys > import sys
> @contextlib.contextmanager > @contextlib.contextmanager
> def profile(ui, fp): > def profile(ui, fp):
> print('fooprof: start profile') > print('fooprof: start profile')
> sys.stdout.flush() > sys.stdout.flush()
> yield > yield
> print('fooprof: end profile') > print('fooprof: end profile')
> sys.stdout.flush() > sys.stdout.flush()
> def extsetup(ui): > def extsetup(ui):
> ui.write(b'fooprof: loaded\n') > ui.write(b'fooprof: loaded\n')
> EOF > EOF
$ cat > otherextension.py <<EOF $ cat > otherextension.py <<EOF
> from __future__ import absolute_import
> def extsetup(ui): > def extsetup(ui):
> ui.write(b'otherextension: loaded\n') > ui.write(b'otherextension: loaded\n')
> EOF > EOF
$ hg init b $ hg init b
$ cd b $ cd b
$ cat >> .hg/hgrc <<EOF $ cat >> .hg/hgrc <<EOF
> [extensions] > [extensions]

tests/test-progress.t

$ cat > loop.py <<EOF $ cat > loop.py <<EOF
> from __future__ import absolute_import
> import time > import time
> from mercurial import commands, registrar > from mercurial import commands, registrar
> >
> cmdtable = {} > cmdtable = {}
> command = registrar.command(cmdtable) > command = registrar.command(cmdtable)
> >
> class incrementingtime(object): > class incrementingtime(object):
> def __init__(self): > def __init__(self):

tests/test-rebase-dest.t

(use hg pull followed by hg rebase -d DEST) (use hg pull followed by hg rebase -d DEST)
[10] [10]
Setup rebase with multiple destinations Setup rebase with multiple destinations
$ cd $TESTTMP $ cd $TESTTMP
$ cat >> $TESTTMP/maprevset.py <<EOF $ cat >> $TESTTMP/maprevset.py <<EOF
> from __future__ import absolute_import
> from mercurial import registrar, revset, revsetlang, smartset > from mercurial import registrar, revset, revsetlang, smartset
> revsetpredicate = registrar.revsetpredicate() > revsetpredicate = registrar.revsetpredicate()
> cache = {} > cache = {}
> @revsetpredicate(b'map') > @revsetpredicate(b'map')
> def map(repo, subset, x): > def map(repo, subset, x):
> """(set, mapping)""" > """(set, mapping)"""
> setarg, maparg = revsetlang.getargs(x, 2, 2, b'') > setarg, maparg = revsetlang.getargs(x, 2, 2, b'')
> rset = revset.getset(repo, smartset.fullreposet(repo), setarg) > rset = revset.getset(repo, smartset.fullreposet(repo), setarg)

tests/test-rebase-scenario-global.t

summary: second source with subdir summary: second source with subdir
Testing rebase being called inside another transaction Testing rebase being called inside another transaction
$ cd $TESTTMP $ cd $TESTTMP
$ hg init tr-state $ hg init tr-state
$ cd tr-state $ cd tr-state
$ cat > $TESTTMP/wraprebase.py <<EOF $ cat > $TESTTMP/wraprebase.py <<EOF
> from __future__ import absolute_import
> from mercurial import extensions > from mercurial import extensions
> def _rebase(orig, ui, repo, *args, **kwargs): > def _rebase(orig, ui, repo, *args, **kwargs):
> with repo.wlock(): > with repo.wlock():
> with repo.lock(): > with repo.lock():
> with repo.transaction(b'wrappedrebase'): > with repo.transaction(b'wrappedrebase'):
> return orig(ui, repo, *args, **kwargs) > return orig(ui, repo, *args, **kwargs)
> def wraprebase(loaded): > def wraprebase(loaded):
> assert loaded > assert loaded

tests/test-relink.t

#require hardlink #require hardlink
$ echo "[extensions]" >> $HGRCPATH $ echo "[extensions]" >> $HGRCPATH
$ echo "relink=" >> $HGRCPATH $ echo "relink=" >> $HGRCPATH
$ fix_path() { $ fix_path() {
> tr '\\' / > tr '\\' /
> } > }
$ cat > arelinked.py <<EOF $ cat > arelinked.py <<EOF
> from __future__ import absolute_import, print_function
> import os > import os
> import sys > import sys
> from mercurial import ( > from mercurial import (
> pycompat, > pycompat,
> util, > util,
> ) > )
> path1, path2 = sys.argv[1:3] > path1, path2 = sys.argv[1:3]
> if util.samefile(pycompat.fsencode(path1), pycompat.fsencode(path2)): > if util.samefile(pycompat.fsencode(path1), pycompat.fsencode(path2)):

tests/test-requires.t

$ hg init supported $ hg init supported
$ echo a > supported/a $ echo a > supported/a
$ hg -R supported commit -Am '#0 at supported' $ hg -R supported commit -Am '#0 at supported'
adding a adding a
$ echo 'featuresetup-test' >> supported/.hg/requires $ echo 'featuresetup-test' >> supported/.hg/requires
$ cat > $TESTTMP/supported-locally/supportlocally.py <<EOF $ cat > $TESTTMP/supported-locally/supportlocally.py <<EOF
> from __future__ import absolute_import
> from mercurial import extensions, localrepo > from mercurial import extensions, localrepo
> def featuresetup(ui, supported): > def featuresetup(ui, supported):
> for name, module in extensions.extensions(ui): > for name, module in extensions.extensions(ui):
> if __name__ == module.__name__: > if __name__ == module.__name__:
> # support specific feature locally > # support specific feature locally
> supported |= {b'featuresetup-test'} > supported |= {b'featuresetup-test'}
> return > return
> def uisetup(ui): > def uisetup(ui):

tests/test-revert.t

missing_missing_missing-tracked missing_missing_missing-tracked
missing_missing_missing-untracked missing_missing_missing-untracked
Script to make a simple text version of the content Script to make a simple text version of the content
--------------------------------------------------- ---------------------------------------------------
$ cat << EOF >> dircontent.py $ cat << EOF >> dircontent.py
> # generate a simple text view of the directory for easy comparison > # generate a simple text view of the directory for easy comparison
> from __future__ import print_function
> import os > import os
> files = os.listdir('.') > files = os.listdir('.')
> files.sort() > files.sort()
> for filename in files: > for filename in files:
> if os.path.isdir(filename): > if os.path.isdir(filename):
> continue > continue
> content = open(filename).read() > content = open(filename).read()
> print('%-6s %s' % (content.strip(), filename)) > print('%-6s %s' % (content.strip(), filename))

tests/test-revlog-mmapindex.t

create verbosemmap.py create verbosemmap.py
$ cat << EOF > verbosemmap.py $ cat << EOF > verbosemmap.py
> # extension to make util.mmapread verbose > # extension to make util.mmapread verbose
> >
> from __future__ import absolute_import
> >
> from mercurial import ( > from mercurial import (
> extensions, > extensions,
> pycompat, > pycompat,
> util, > util,
> ) > )
> >
> def extsetup(ui): > def extsetup(ui):

tests/test-revset.t

$ log() { $ log() {
> hg log --template '{rev}\n' -r "$1" > hg log --template '{rev}\n' -r "$1"
> } > }
extension to build '_intlist()' and '_hexlist()', which is necessary because extension to build '_intlist()' and '_hexlist()', which is necessary because
these predicates use '\0' as a separator: these predicates use '\0' as a separator:
$ cat <<EOF > debugrevlistspec.py $ cat <<EOF > debugrevlistspec.py
> from __future__ import absolute_import
> from mercurial import ( > from mercurial import (
> node as nodemod, > node as nodemod,
> registrar, > registrar,
> revset, > revset,
> revsetlang, > revsetlang,
> ) > )
> from mercurial.utils import stringutil > from mercurial.utils import stringutil
> cmdtable = {} > cmdtable = {}

tests/test-share-bookmarks.t

bm1 3:b87954705719 bm1 3:b87954705719
bm4 5:92793bfc8cad bm4 5:92793bfc8cad
$ cd .. $ cd ..
verify that bookmarks are not written on failed transaction verify that bookmarks are not written on failed transaction
$ cat > failpullbookmarks.py << EOF $ cat > failpullbookmarks.py << EOF
> """A small extension that makes bookmark pulls fail, for testing""" > """A small extension that makes bookmark pulls fail, for testing"""
> from __future__ import absolute_import
> from mercurial import ( > from mercurial import (
> error, > error,
> exchange, > exchange,
> extensions, > extensions,
> ) > )
> def _pullbookmarks(orig, pullop): > def _pullbookmarks(orig, pullop):
> orig(pullop) > orig(pullop)
> raise error.HookAbort(b'forced failure by extension') > raise error.HookAbort(b'forced failure by extension')

tests/test-ssh-proto-unbundle.t

$ cd .. $ cd ..
Create a pretxnchangegroup hook that fails. Give it multiple modes of printing Create a pretxnchangegroup hook that fails. Give it multiple modes of printing
output so we can test I/O capture and behavior. output so we can test I/O capture and behavior.
Test pushing to a server that has a pretxnchangegroup Python hook that fails Test pushing to a server that has a pretxnchangegroup Python hook that fails
$ cat > $TESTTMP/failhook << EOF $ cat > $TESTTMP/failhook << EOF
> from __future__ import print_function
> import sys > import sys
> def hook1line(ui, repo, **kwargs): > def hook1line(ui, repo, **kwargs):
> ui.write(b'ui.write 1 line\n') > ui.write(b'ui.write 1 line\n')
> ui.flush() > ui.flush()
> return 1 > return 1
> def hook2lines(ui, repo, **kwargs): > def hook2lines(ui, repo, **kwargs):
> ui.write(b'ui.write 2 lines 1\n') > ui.write(b'ui.write 2 lines 1\n')
> ui.write(b'ui.write 2 lines 2\n') > ui.write(b'ui.write 2 lines 2\n')

tests/test-strip.t

> A Z > A Z
> EOS > EOS
$ cp -R . ../scmutilcleanup $ cp -R . ../scmutilcleanup
$ hg up -C I $ hg up -C I
2 files updated, 0 files merged, 0 files removed, 0 files unresolved 2 files updated, 0 files merged, 0 files removed, 0 files unresolved
$ echo 3 >> I $ echo 3 >> I
$ cat > $TESTTMP/delayedstrip.py <<EOF $ cat > $TESTTMP/delayedstrip.py <<EOF
> from __future__ import absolute_import
> from mercurial import commands, registrar, repair > from mercurial import commands, registrar, repair
> cmdtable = {} > cmdtable = {}
> command = registrar.command(cmdtable) > command = registrar.command(cmdtable)
> @command(b'testdelayedstrip') > @command(b'testdelayedstrip')
> def testdelayedstrip(ui, repo): > def testdelayedstrip(ui, repo):
> def getnodes(expr): > def getnodes(expr):
> return [repo.changelog.node(r) for r in repo.revs(expr)] > return [repo.changelog.node(r) for r in repo.revs(expr)]
> with repo.wlock(): > with repo.wlock():

tests/test-template-functions.t

$ hg log -T "{indent(date, ' ')}\n" -r 2:3 -R a $ hg log -T "{indent(date, ' ')}\n" -r 2:3 -R a
1200000.00 1200000.00
1300000.00 1300000.00
Test cbor filter: Test cbor filter:
$ cat <<'EOF' > "$TESTTMP/decodecbor.py" $ cat <<'EOF' > "$TESTTMP/decodecbor.py"
> from __future__ import absolute_import
> from mercurial import ( > from mercurial import (
> dispatch, > dispatch,
> ) > )
> from mercurial.utils import ( > from mercurial.utils import (
> cborutil, > cborutil,
> procutil, > procutil,
> stringutil, > stringutil,
> ) > )

tests/test-template-map.t

<extra key="branch">default</extra> <extra key="branch">default</extra>
</logentry> </logentry>
</log> </log>
test CBOR style: test CBOR style:
$ cat <<'EOF' > "$TESTTMP/decodecborarray.py" $ cat <<'EOF' > "$TESTTMP/decodecborarray.py"
> from __future__ import absolute_import
> from mercurial import ( > from mercurial import (
> dispatch, > dispatch,
> ) > )
> from mercurial.utils import ( > from mercurial.utils import (
> cborutil, > cborutil,
> procutil, > procutil,
> stringutil, > stringutil,
> ) > )

tests/test-update-atomic.t

#require execbit unix-permissions no-chg #require execbit unix-permissions no-chg
Checking that experimental.atomic-file works. Checking that experimental.atomic-file works.
$ cat > $TESTTMP/show_mode.py <<EOF $ cat > $TESTTMP/show_mode.py <<EOF
> from __future__ import print_function
> import os > import os
> import stat > import stat
> import sys > import sys
> ST_MODE = stat.ST_MODE > ST_MODE = stat.ST_MODE
> >
> for file_path in sys.argv[1:]: > for file_path in sys.argv[1:]:
> file_stat = os.stat(file_path) > file_stat = os.stat(file_path)
> octal_mode = oct(file_stat[ST_MODE] & 0o777).replace('o', '') > octal_mode = oct(file_stat[ST_MODE] & 0o777).replace('o', '')
> print("%s:%s" % (file_path, octal_mode)) > print("%s:%s" % (file_path, octal_mode))
> >
> EOF > EOF
$ hg init repo $ hg init repo
$ cd repo $ cd repo
$ cat > .hg/showwrites.py <<EOF $ cat > .hg/showwrites.py <<EOF
> from __future__ import print_function
> from mercurial import pycompat > from mercurial import pycompat
> from mercurial.utils import stringutil > from mercurial.utils import stringutil
> def uisetup(ui): > def uisetup(ui):
> from mercurial import vfs > from mercurial import vfs
> class newvfs(vfs.vfs): > class newvfs(vfs.vfs):
> def __call__(self, *args, **kwargs): > def __call__(self, *args, **kwargs):
> print(pycompat.sysstr(stringutil.pprint( > print(pycompat.sysstr(stringutil.pprint(
> ('vfs open', args, sorted(list(kwargs.items())))))) > ('vfs open', args, sorted(list(kwargs.items()))))))

tests/test-verify.t

$ hg verify $ hg verify
checking changesets checking changesets
checking manifests checking manifests
crosschecking files in changesets and manifests crosschecking files in changesets and manifests
checking files checking files
checked 1 changesets with 1 changes to 1 files checked 1 changesets with 1 changes to 1 files
$ cat >> $TESTTMP/break-base64.py <<EOF $ cat >> $TESTTMP/break-base64.py <<EOF
> from __future__ import absolute_import
> import base64 > import base64
> base64.b64decode=lambda x: x > base64.b64decode=lambda x: x
> EOF > EOF
$ cat >> .hg/hgrc <<EOF $ cat >> .hg/hgrc <<EOF
> breakbase64=$TESTTMP/break-base64.py > breakbase64=$TESTTMP/break-base64.py
> EOF > EOF
$ hg verify $ hg verify

tests/test-walk.t

$ cd .. $ cd ..
Test split patterns on overflow Test split patterns on overflow
$ cd t $ cd t
$ echo fennel > overflow.list $ echo fennel > overflow.list
$ cat >> printnum.py <<EOF $ cat >> printnum.py <<EOF
> from __future__ import print_function
> for i in range(20000 // 100): > for i in range(20000 // 100):
> print('x' * 100) > print('x' * 100)
> EOF > EOF
$ "$PYTHON" printnum.py >> overflow.list $ "$PYTHON" printnum.py >> overflow.list
$ echo fenugreek >> overflow.list $ echo fenugreek >> overflow.list
$ hg debugwalk 'listfile:overflow.list' 2>&1 | egrep -v '^xxx' $ hg debugwalk 'listfile:overflow.list' 2>&1 | egrep -v '^xxx'
f fennel fennel exact f fennel fennel exact
f fenugreek fenugreek exact f fenugreek fenugreek exact
$ cd .. $ cd ..

tests/test-worker.t

Test UI worker interaction Test UI worker interaction
$ cat > t.py <<EOF $ cat > t.py <<EOF
> from __future__ import absolute_import, print_function
> import sys > import sys
> import time > import time
> from mercurial import ( > from mercurial import (
> error, > error,
> registrar, > registrar,
> ui as uimod, > ui as uimod,
> worker, > worker,
> ) > )
$ hg --config "extensions.t=$abspath" --config 'worker.numcpus=8' \ $ hg --config "extensions.t=$abspath" --config 'worker.numcpus=8' \
> test 100000.0 exc 2>&1 | grep '^Exception' > test 100000.0 exc 2>&1 | grep '^Exception'
Exception: unknown exception Exception: unknown exception
Workers should not do cleanups in all cases Workers should not do cleanups in all cases
$ cat > $TESTTMP/detectcleanup.py <<EOF $ cat > $TESTTMP/detectcleanup.py <<EOF
> from __future__ import absolute_import
> import atexit > import atexit
> import os > import os
> import sys > import sys
> import time > import time
> sys.unraisablehook = lambda x: None > sys.unraisablehook = lambda x: None
> oldfork = os.fork > oldfork = os.fork
> count = 0 > count = 0
> parentpid = os.getpid() > parentpid = os.getpid()
> "extensions.d=$TESTTMP/detectcleanup.py" test 100000 abort > "extensions.d=$TESTTMP/detectcleanup.py" test 100000 abort
start start
abort: known exception abort: known exception
[255] [255]
Do not crash on partially read result Do not crash on partially read result
$ cat > $TESTTMP/detecttruncated.py <<EOF $ cat > $TESTTMP/detecttruncated.py <<EOF
> from __future__ import absolute_import
> import os > import os
> import sys > import sys
> import time > import time
> sys.unraisablehook = lambda x: None > sys.unraisablehook = lambda x: None
> oldwrite = os.write > oldwrite = os.write
> def splitwrite(fd, string): > def splitwrite(fd, string):
> ret = oldwrite(fd, string[:9]) > ret = oldwrite(fd, string[:9])
> if ret == 9: > if ret == 9: