test: replace a many occurence of `python` with `$PYTHON`

Otherwise this can use the wrong python version, or worse, not find any python
at all.

Differential Revision: https://phab.mercurial-scm.org/D9730

tests/library-infinitepush.sh

@@ -1,49 +1,49 b''
 scratchnodes() {
   for node in `find ../repo/.hg/scratchbranches/index/nodemap/* | sort`; do
      echo ${node##*/} `cat $node`
   done
 }
 
 scratchbookmarks() {
   for bookmark in `find ../repo/.hg/scratchbranches/index/bookmarkmap/* -type f | sort`; do
      echo "${bookmark##*/bookmarkmap/} `cat $bookmark`"
   done
 }
 
 setupcommon() {
   cat >> $HGRCPATH << EOF
 [extensions]
 infinitepush=
 [ui]
-ssh = python "$TESTDIR/dummyssh"
+ssh = $PYTHON "$TESTDIR/dummyssh"
 [infinitepush]
 branchpattern=re:scratch/.*
 EOF
 }
 
 setupserver() {
 cat >> .hg/hgrc << EOF
 [infinitepush]
 server=yes
 indextype=disk
 storetype=disk
 reponame=babar
 EOF
 }
 
 waitbgbackup() {
   sleep 1
   hg debugwaitbackup
 }
 
 mkcommitautobackup() {
     echo $1 > $1
     hg add $1
     hg ci -m $1 --config infinitepushbackup.autobackup=True
 }
 
 setuplogdir() {
   mkdir $TESTTMP/logs
   chmod 0755 $TESTTMP/logs
   chmod +t $TESTTMP/logs
 }

tests/remotefilelog-library.sh

@@ -1,75 +1,75 b''
 CACHEDIR=$PWD/hgcache
 cat >> $HGRCPATH <<EOF
 [remotefilelog]
 cachepath=$CACHEDIR
 debug=True
 [extensions]
 remotefilelog=
 rebase=
 strip=
 [ui]
-ssh=python "$TESTDIR/dummyssh"
+ssh=$PYTHON "$TESTDIR/dummyssh"
 [server]
 preferuncompressed=True
 [experimental]
 changegroup3=True
 [rebase]
 singletransaction=True
 EOF
 
 hgcloneshallow() {
   local name
   local dest
   orig=$1
   shift
   dest=$1
   shift
   hg clone --shallow --config remotefilelog.reponame=master $orig $dest $@
   cat >> $dest/.hg/hgrc <<EOF
 [remotefilelog]
 reponame=master
 [phases]
 publish=False
 EOF
 }
 
 hgcloneshallowlfs() {
   local name
   local dest
   local lfsdir
   orig=$1
   shift
   dest=$1
   shift
   lfsdir=$1
   shift
   hg clone --shallow --config "extensions.lfs=" --config "lfs.url=$lfsdir" --config remotefilelog.reponame=master $orig $dest $@
   cat >> $dest/.hg/hgrc <<EOF
 [extensions]
 lfs=
 [lfs]
 url=$lfsdir
 [remotefilelog]
 reponame=master
 [phases]
 publish=False
 EOF
 }
 
 clearcache() {
   rm -rf $CACHEDIR/*
 }
 
 mkcommit() {
   echo "$1" > "$1"
   hg add "$1"
   hg ci -m "$1"
 }
 
 ls_l() {
   $PYTHON $TESTDIR/ls-l.py "$@"
 }
 
 identifyrflcaps() {
     xargs -n 1 echo | egrep '(remotefilelog|getflogheads|getfile)' | sort
 }

tests/test-demandimport.py

@@ -1,238 +1,238 b''
 from __future__ import absolute_import, print_function
 
 from mercurial import demandimport
 
 demandimport.enable()
 
 import os
 import subprocess
 import sys
 import types
 
 # Don't import pycompat because it has too many side-effects.
 ispy3 = sys.version_info[0] >= 3
 
 # Only run if demandimport is allowed
 if subprocess.call(
-    ['python', '%s/hghave' % os.environ['TESTDIR'], 'demandimport']
+    [os.environ['PYTHON'], '%s/hghave' % os.environ['TESTDIR'], 'demandimport']
 ):
     sys.exit(80)
 
 # We rely on assert, which gets optimized out.
 if sys.flags.optimize:
     sys.exit(80)
 
 # The demand importer doesn't work on Python 3.5.
 if sys.version_info[0:2] == (3, 5):
     sys.exit(80)
 
 if ispy3:
     from importlib.util import _LazyModule
 
     try:
         from importlib.util import _Module as moduletype
     except ImportError:
         moduletype = types.ModuleType
 else:
     moduletype = types.ModuleType
 
 if os.name != 'nt':
     try:
         import distutils.msvc9compiler
 
         print(
             'distutils.msvc9compiler needs to be an immediate '
             'importerror on non-windows platforms'
         )
         distutils.msvc9compiler
     except ImportError:
         pass
 
 import re
 
 rsub = re.sub
 
 
 def f(obj):
     l = repr(obj)
     l = rsub("0x[0-9a-fA-F]+", "0x?", l)
     l = rsub("from '.*'", "from '?'", l)
     l = rsub("'<[a-z]*>'", "'<whatever>'", l)
     return l
 
 
 demandimport.disable()
 os.environ['HGDEMANDIMPORT'] = 'disable'
 # this enable call should not actually enable demandimport!
 demandimport.enable()
 from mercurial import node
 
 # We use assert instead of a unittest test case because having imports inside
 # functions changes behavior of the demand importer.
 if ispy3:
     assert not isinstance(node, _LazyModule)
 else:
     assert f(node) == "<module 'mercurial.node' from '?'>", f(node)
 
 # now enable it for real
 del os.environ['HGDEMANDIMPORT']
 demandimport.enable()
 
 # Test access to special attributes through demandmod proxy
 assert 'mercurial.error' not in sys.modules
 from mercurial import error as errorproxy
 
 if ispy3:
     # unsure why this isn't lazy.
     assert not isinstance(f, _LazyModule)
     assert f(errorproxy) == "<module 'mercurial.error' from '?'>", f(errorproxy)
 else:
     assert f(errorproxy) == "<unloaded module 'error'>", f(errorproxy)
 
 doc = ' '.join(errorproxy.__doc__.split()[:3])
 assert doc == 'Mercurial exceptions. This', doc
 assert errorproxy.__name__ == 'mercurial.error', errorproxy.__name__
 
 # __name__ must be accessible via __dict__ so the relative imports can be
 # resolved
 name = errorproxy.__dict__['__name__']
 assert name == 'mercurial.error', name
 
 if ispy3:
     assert not isinstance(errorproxy, _LazyModule)
     assert f(errorproxy) == "<module 'mercurial.error' from '?'>", f(errorproxy)
 else:
     assert f(errorproxy) == "<proxied module 'error'>", f(errorproxy)
 
 import os
 
 if ispy3:
     assert not isinstance(os, _LazyModule)
     assert f(os) == "<module 'os' from '?'>", f(os)
 else:
     assert f(os) == "<unloaded module 'os'>", f(os)
 
 assert f(os.system) == '<built-in function system>', f(os.system)
 assert f(os) == "<module 'os' from '?'>", f(os)
 
 assert 'mercurial.utils.procutil' not in sys.modules
 from mercurial.utils import procutil
 
 if ispy3:
     assert isinstance(procutil, _LazyModule)
     assert f(procutil) == "<module 'mercurial.utils.procutil' from '?'>", f(
         procutil
     )
 else:
     assert f(procutil) == "<unloaded module 'procutil'>", f(procutil)
 
 assert f(procutil.system) == '<function system at 0x?>', f(procutil.system)
 assert procutil.__class__ == moduletype, procutil.__class__
 assert f(procutil) == "<module 'mercurial.utils.procutil' from '?'>", f(
     procutil
 )
 assert f(procutil.system) == '<function system at 0x?>', f(procutil.system)
 
 assert 'mercurial.hgweb' not in sys.modules
 from mercurial import hgweb
 
 if ispy3:
     assert isinstance(hgweb, _LazyModule)
     assert f(hgweb) == "<module 'mercurial.hgweb' from '?'>", f(hgweb)
     assert isinstance(hgweb.hgweb_mod, _LazyModule)
     assert (
         f(hgweb.hgweb_mod) == "<module 'mercurial.hgweb.hgweb_mod' from '?'>"
     ), f(hgweb.hgweb_mod)
 else:
     assert f(hgweb) == "<unloaded module 'hgweb'>", f(hgweb)
     assert f(hgweb.hgweb_mod) == "<unloaded module 'hgweb_mod'>", f(
         hgweb.hgweb_mod
     )
 
 assert f(hgweb) == "<module 'mercurial.hgweb' from '?'>", f(hgweb)
 
 import re as fred
 
 if ispy3:
     assert not isinstance(fred, _LazyModule)
     assert f(fred) == "<module 're' from '?'>"
 else:
     assert f(fred) == "<unloaded module 're'>", f(fred)
 
 import re as remod
 
 if ispy3:
     assert not isinstance(remod, _LazyModule)
     assert f(remod) == "<module 're' from '?'>"
 else:
     assert f(remod) == "<unloaded module 're'>", f(remod)
 
 import sys as re
 
 if ispy3:
     assert not isinstance(re, _LazyModule)
     assert f(re) == "<module 'sys' (built-in)>"
 else:
     assert f(re) == "<unloaded module 'sys'>", f(re)
 
 if ispy3:
     assert not isinstance(fred, _LazyModule)
     assert f(fred) == "<module 're' from '?'>", f(fred)
 else:
     assert f(fred) == "<unloaded module 're'>", f(fred)
 
 assert f(fred.sub) == '<function sub at 0x?>', f(fred.sub)
 
 if ispy3:
     assert not isinstance(fred, _LazyModule)
     assert f(fred) == "<module 're' from '?'>", f(fred)
 else:
     assert f(fred) == "<proxied module 're'>", f(fred)
 
 remod.escape  # use remod
 assert f(remod) == "<module 're' from '?'>", f(remod)
 
 if ispy3:
     assert not isinstance(re, _LazyModule)
     assert f(re) == "<module 'sys' (built-in)>"
     assert f(type(re.stderr)) == "<class '_io.TextIOWrapper'>", f(
         type(re.stderr)
     )
     assert f(re) == "<module 'sys' (built-in)>"
 else:
     assert f(re) == "<unloaded module 'sys'>", f(re)
     assert f(re.stderr) == "<open file '<whatever>', mode 'w' at 0x?>", f(
         re.stderr
     )
     assert f(re) == "<proxied module 'sys'>", f(re)
 
 assert 'telnetlib' not in sys.modules
 import telnetlib
 
 if ispy3:
     assert isinstance(telnetlib, _LazyModule)
     assert f(telnetlib) == "<module 'telnetlib' from '?'>"
 else:
     assert f(telnetlib) == "<unloaded module 'telnetlib'>", f(telnetlib)
 
 try:
     from telnetlib import unknownattr
 
     assert False, (
         'no demandmod should be created for attribute of non-package '
         'module:\ntelnetlib.unknownattr = %s' % f(unknownattr)
     )
 except ImportError as inst:
     assert rsub(r"'", '', str(inst)).startswith(
         'cannot import name unknownattr'
     )
 
 from mercurial import util
 
 # Unlike the import statement, __import__() function should not raise
 # ImportError even if fromlist has an unknown item
 # (see Python/import.c:import_module_level() and ensure_fromlist())
 assert 'ftplib' not in sys.modules
 zipfileimp = __import__('ftplib', globals(), locals(), ['unknownattr'])
 assert f(zipfileimp) == "<module 'ftplib' from '?'>", f(zipfileimp)
 assert not util.safehasattr(zipfileimp, 'unknownattr')

tests/test-infinitepush-ci.t

@@ -1,443 +1,443 b''
 #require no-reposimplestore
 
 Testing the case when there is no infinitepush extension present on the client
 side and the server routes each push to bundlestore. This case is very much
 similar to CI use case.
 
 Setup
 -----
 
   $ . "$TESTDIR/library-infinitepush.sh"
   $ cat >> $HGRCPATH <<EOF
   > [ui]
-  > ssh = python "$TESTDIR/dummyssh"
+  > ssh = $PYTHON "$TESTDIR/dummyssh"
   > [alias]
   > glog = log -GT "{rev}:{node|short} {desc}\n{phase}"
   > EOF
   $ cp $HGRCPATH $TESTTMP/defaulthgrc
   $ hg init repo
   $ cd repo
   $ setupserver
   $ echo "pushtobundlestore = True" >> .hg/hgrc
   $ echo "[extensions]" >> .hg/hgrc
   $ echo "infinitepush=" >> .hg/hgrc
   $ echo initialcommit > initialcommit
   $ hg ci -Aqm "initialcommit"
   $ hg phase --public .
 
   $ cd ..
   $ hg clone repo client -q
   $ hg clone repo client2 -q
   $ hg clone ssh://user@dummy/repo client3 -q
   $ cd client
 
 Pushing a new commit from the client to the server
 -----------------------------------------------------
 
   $ echo foobar > a
   $ hg ci -Aqm "added a"
   $ hg glog
   @  1:6cb0989601f1 added a
   |  draft
   o  0:67145f466344 initialcommit
      public
 
   $ hg push
   pushing to $TESTTMP/repo
   searching for changes
   storing changesets on the bundlestore
   pushing 1 commit:
       6cb0989601f1  added a
 
   $ scratchnodes
   6cb0989601f1fb5805238edfb16f3606713d9a0b 3b414252ff8acab801318445d88ff48faf4a28c3
 
 Understanding how data is stored on the bundlestore in server
 -------------------------------------------------------------
 
 There are two things, filebundlestore and index
   $ ls ../repo/.hg/scratchbranches
   filebundlestore
   index
 
 filebundlestore stores the bundles
   $ ls ../repo/.hg/scratchbranches/filebundlestore/3b/41/
   3b414252ff8acab801318445d88ff48faf4a28c3
 
 index/nodemap stores a map of node id and file in which bundle is stored in filebundlestore
   $ ls ../repo/.hg/scratchbranches/index/
   nodemap
   $ ls ../repo/.hg/scratchbranches/index/nodemap/
   6cb0989601f1fb5805238edfb16f3606713d9a0b
 
   $ cd ../repo
 
 Checking that the commit was not applied to revlog on the server
 ------------------------------------------------------------------
 
   $ hg glog
   @  0:67145f466344 initialcommit
      public
 
 Applying the changeset from the bundlestore
 --------------------------------------------
 
   $ hg unbundle .hg/scratchbranches/filebundlestore/3b/41/3b414252ff8acab801318445d88ff48faf4a28c3
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   new changesets 6cb0989601f1
   (run 'hg update' to get a working copy)
 
   $ hg glog
   o  1:6cb0989601f1 added a
   |  public
   @  0:67145f466344 initialcommit
      public
 
 Pushing more changesets from the local repo
 --------------------------------------------
 
   $ cd ../client
   $ echo b > b
   $ hg ci -Aqm "added b"
   $ echo c > c
   $ hg ci -Aqm "added c"
   $ hg glog
   @  3:bf8a6e3011b3 added c
   |  draft
   o  2:eaba929e866c added b
   |  draft
   o  1:6cb0989601f1 added a
   |  public
   o  0:67145f466344 initialcommit
      public
 
   $ hg push
   pushing to $TESTTMP/repo
   searching for changes
   storing changesets on the bundlestore
   pushing 2 commits:
       eaba929e866c  added b
       bf8a6e3011b3  added c
 
 Checking that changesets are not applied on the server
 ------------------------------------------------------
 
   $ hg glog -R ../repo
   o  1:6cb0989601f1 added a
   |  public
   @  0:67145f466344 initialcommit
      public
 
 Both of the new changesets are stored in a single bundle-file
   $ scratchnodes
   6cb0989601f1fb5805238edfb16f3606713d9a0b 3b414252ff8acab801318445d88ff48faf4a28c3
   bf8a6e3011b345146bbbedbcb1ebd4837571492a 239585f5e61f0c09ce7106bdc1097bff731738f4
   eaba929e866c59bc9a6aada5a9dd2f6990db83c0 239585f5e61f0c09ce7106bdc1097bff731738f4
 
 Pushing more changesets to the server
 -------------------------------------
 
   $ echo d > d
   $ hg ci -Aqm "added d"
   $ echo e > e
   $ hg ci -Aqm "added e"
 
 XXX: we should have pushed only the parts which are not in bundlestore
   $ hg push
   pushing to $TESTTMP/repo
   searching for changes
   storing changesets on the bundlestore
   pushing 4 commits:
       eaba929e866c  added b
       bf8a6e3011b3  added c
       1bb96358eda2  added d
       b4e4bce66051  added e
 
 Sneak peek into the bundlestore at the server
   $ scratchnodes
   1bb96358eda285b536c6d1c66846a7cdb2336cea 98fbae0016662521b0007da1b7bc349cd3caacd1
   6cb0989601f1fb5805238edfb16f3606713d9a0b 3b414252ff8acab801318445d88ff48faf4a28c3
   b4e4bce660512ad3e71189e14588a70ac8e31fef 98fbae0016662521b0007da1b7bc349cd3caacd1
   bf8a6e3011b345146bbbedbcb1ebd4837571492a 98fbae0016662521b0007da1b7bc349cd3caacd1
   eaba929e866c59bc9a6aada5a9dd2f6990db83c0 98fbae0016662521b0007da1b7bc349cd3caacd1
 
 Checking if `hg pull` pulls something or `hg incoming` shows something
 -----------------------------------------------------------------------
 
   $ hg incoming
   comparing with $TESTTMP/repo
   searching for changes
   no changes found
   [1]
 
   $ hg pull
   pulling from $TESTTMP/repo
   searching for changes
   no changes found
 
 Pulling from second client which is a localpeer to test `hg pull -r <rev>`
 --------------------------------------------------------------------------
 
 Pulling the revision which is applied
 
   $ cd ../client2
   $ hg pull -r 6cb0989601f1
   pulling from $TESTTMP/repo
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   new changesets 6cb0989601f1
   (run 'hg update' to get a working copy)
   $ hg glog
   o  1:6cb0989601f1 added a
   |  public
   @  0:67145f466344 initialcommit
      public
 
 Pulling the revision which is in bundlestore
 XXX: we should support pulling revisions from a local peers bundlestore without
 client side wrapping
 
   $ hg pull -r b4e4bce660512ad3e71189e14588a70ac8e31fef
   pulling from $TESTTMP/repo
   abort: unknown revision 'b4e4bce660512ad3e71189e14588a70ac8e31fef'
   [255]
   $ hg glog
   o  1:6cb0989601f1 added a
   |  public
   @  0:67145f466344 initialcommit
      public
 
   $ cd ../client
 
 Pulling from third client which is not a localpeer
 ---------------------------------------------------
 
 Pulling the revision which is applied
 
   $ cd ../client3
   $ hg pull -r 6cb0989601f1
   pulling from ssh://user@dummy/repo
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   new changesets 6cb0989601f1
   (run 'hg update' to get a working copy)
   $ hg glog
   o  1:6cb0989601f1 added a
   |  public
   @  0:67145f466344 initialcommit
      public
 
 Pulling the revision which is in bundlestore
 
 Trying to specify short hash
 XXX: we should support this
   $ hg pull -r b4e4bce660512
   pulling from ssh://user@dummy/repo
   abort: unknown revision 'b4e4bce660512'
   [255]
 
 XXX: we should show better message when the pull is happening from bundlestore
   $ hg pull -r b4e4bce660512ad3e71189e14588a70ac8e31fef
   pulling from ssh://user@dummy/repo
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 4 changesets with 4 changes to 4 files
   new changesets eaba929e866c:b4e4bce66051
   (run 'hg update' to get a working copy)
   $ hg glog
   o  5:b4e4bce66051 added e
   |  public
   o  4:1bb96358eda2 added d
   |  public
   o  3:bf8a6e3011b3 added c
   |  public
   o  2:eaba929e866c added b
   |  public
   o  1:6cb0989601f1 added a
   |  public
   @  0:67145f466344 initialcommit
      public
 
   $ cd ../client
 
 Checking storage of phase information with the bundle on bundlestore
 ---------------------------------------------------------------------
 
 creating a draft commit
   $ cat >> $HGRCPATH <<EOF
   > [phases]
   > publish = False
   > EOF
   $ echo f > f
   $ hg ci -Aqm "added f"
   $ hg glog -r '.^::'
   @  6:9b42578d4447 added f
   |  draft
   o  5:b4e4bce66051 added e
   |  public
   ~
 
   $ hg push
   pushing to $TESTTMP/repo
   searching for changes
   storing changesets on the bundlestore
   pushing 5 commits:
       eaba929e866c  added b
       bf8a6e3011b3  added c
       1bb96358eda2  added d
       b4e4bce66051  added e
       9b42578d4447  added f
 
 XXX: the phase of 9b42578d4447 should not be changed here
   $ hg glog -r .
   @  6:9b42578d4447 added f
   |  public
   ~
 
 applying the bundle on the server to check preservation of phase-information
 
   $ cd ../repo
   $ scratchnodes
   1bb96358eda285b536c6d1c66846a7cdb2336cea 280a46a259a268f0e740c81c5a7751bdbfaec85f
   6cb0989601f1fb5805238edfb16f3606713d9a0b 3b414252ff8acab801318445d88ff48faf4a28c3
   9b42578d44473575994109161430d65dd147d16d 280a46a259a268f0e740c81c5a7751bdbfaec85f
   b4e4bce660512ad3e71189e14588a70ac8e31fef 280a46a259a268f0e740c81c5a7751bdbfaec85f
   bf8a6e3011b345146bbbedbcb1ebd4837571492a 280a46a259a268f0e740c81c5a7751bdbfaec85f
   eaba929e866c59bc9a6aada5a9dd2f6990db83c0 280a46a259a268f0e740c81c5a7751bdbfaec85f
 
   $ hg unbundle .hg/scratchbranches/filebundlestore/28/0a/280a46a259a268f0e740c81c5a7751bdbfaec85f
   adding changesets
   adding manifests
   adding file changes
   added 5 changesets with 5 changes to 5 files
   new changesets eaba929e866c:9b42578d4447 (1 drafts)
   (run 'hg update' to get a working copy)
 
   $ hg glog
   o  6:9b42578d4447 added f
   |  draft
   o  5:b4e4bce66051 added e
   |  public
   o  4:1bb96358eda2 added d
   |  public
   o  3:bf8a6e3011b3 added c
   |  public
   o  2:eaba929e866c added b
   |  public
   o  1:6cb0989601f1 added a
   |  public
   @  0:67145f466344 initialcommit
      public
 
 Checking storage of obsmarkers in the bundlestore
 --------------------------------------------------
 
 enabling obsmarkers and rebase extension
 
   $ cat >> $HGRCPATH << EOF
   > [experimental]
   > evolution = all
   > [extensions]
   > rebase =
   > EOF
 
   $ cd ../client
 
   $ hg phase -r . --draft --force
   $ hg rebase -r 6 -d 3
   rebasing 6:9b42578d4447 tip "added f"
 
   $ hg glog
   @  7:99949238d9ac added f
   |  draft
   | o  5:b4e4bce66051 added e
   | |  public
   | o  4:1bb96358eda2 added d
   |/   public
   o  3:bf8a6e3011b3 added c
   |  public
   o  2:eaba929e866c added b
   |  public
   o  1:6cb0989601f1 added a
   |  public
   o  0:67145f466344 initialcommit
      public
 
   $ hg push -f
   pushing to $TESTTMP/repo
   searching for changes
   storing changesets on the bundlestore
   pushing 1 commit:
       99949238d9ac  added f
 
 XXX: the phase should not have changed here
   $ hg glog -r .
   @  7:99949238d9ac added f
   |  public
   ~
 
 Unbundling on server to see obsmarkers being applied
 
   $ cd ../repo
 
   $ scratchnodes
   1bb96358eda285b536c6d1c66846a7cdb2336cea 280a46a259a268f0e740c81c5a7751bdbfaec85f
   6cb0989601f1fb5805238edfb16f3606713d9a0b 3b414252ff8acab801318445d88ff48faf4a28c3
   99949238d9ac7f2424a33a46dface6f866afd059 090a24fe63f31d3b4bee714447f835c8c362ff57
   9b42578d44473575994109161430d65dd147d16d 280a46a259a268f0e740c81c5a7751bdbfaec85f
   b4e4bce660512ad3e71189e14588a70ac8e31fef 280a46a259a268f0e740c81c5a7751bdbfaec85f
   bf8a6e3011b345146bbbedbcb1ebd4837571492a 280a46a259a268f0e740c81c5a7751bdbfaec85f
   eaba929e866c59bc9a6aada5a9dd2f6990db83c0 280a46a259a268f0e740c81c5a7751bdbfaec85f
 
   $ hg glog
   o  6:9b42578d4447 added f
   |  draft
   o  5:b4e4bce66051 added e
   |  public
   o  4:1bb96358eda2 added d
   |  public
   o  3:bf8a6e3011b3 added c
   |  public
   o  2:eaba929e866c added b
   |  public
   o  1:6cb0989601f1 added a
   |  public
   @  0:67145f466344 initialcommit
      public
 
   $ hg unbundle .hg/scratchbranches/filebundlestore/09/0a/090a24fe63f31d3b4bee714447f835c8c362ff57
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 0 changes to 1 files (+1 heads)
   1 new obsolescence markers
   obsoleted 1 changesets
   new changesets 99949238d9ac (1 drafts)
   (run 'hg heads' to see heads, 'hg merge' to merge)
 
   $ hg glog
   o  7:99949238d9ac added f
   |  draft
   | o  5:b4e4bce66051 added e
   | |  public
   | o  4:1bb96358eda2 added d
   |/   public
   o  3:bf8a6e3011b3 added c
   |  public
   o  2:eaba929e866c added b
   |  public
   o  1:6cb0989601f1 added a
   |  public
   @  0:67145f466344 initialcommit
      public

tests/test-nointerrupt.t

@@ -1,85 +1,85 b''
 #require no-windows
 
 Dummy extension simulating unsafe long running command
   $ cat > sleepext.py <<EOF
   > import itertools
   > import time
   > 
   > from mercurial.i18n import _
   > from mercurial import registrar
   > 
   > cmdtable = {}
   > command = registrar.command(cmdtable)
   > 
   > @command(b'sleep', [], _(b'TIME'), norepo=True)
   > def sleep(ui, sleeptime=b"1", **opts):
   >     with ui.uninterruptible():
   >         for _i in itertools.repeat(None, int(sleeptime)):
   >             time.sleep(1)
   >         ui.warn(b"end of unsafe operation\n")
   >     ui.warn(b"%s second(s) passed\n" % sleeptime)
   > EOF
 
 Kludge to emulate timeout(1) which is not generally available.
   $ cat > timeout.py <<EOF
   > from __future__ import print_function
   > import argparse
   > import signal
   > import subprocess
   > import sys
   > import time
   > 
   > ap = argparse.ArgumentParser()
   > ap.add_argument('-s', nargs=1, default='SIGTERM')
   > ap.add_argument('duration', nargs=1, type=int)
   > ap.add_argument('argv', nargs='*')
   > opts = ap.parse_args()
   > try:
   >     sig = int(opts.s[0])
   > except ValueError:
   >     sname = opts.s[0]
   >     if not sname.startswith('SIG'):
   >         sname = 'SIG' + sname
   >     sig = getattr(signal, sname)
   > proc = subprocess.Popen(opts.argv)
   > time.sleep(opts.duration[0])
   > proc.poll()
   > if proc.returncode is None:
   >     proc.send_signal(sig)
   >     proc.wait()
   >     sys.exit(124)
   > EOF
 
 Set up repository
   $ hg init repo
   $ cd repo
   $ cat >> $HGRCPATH << EOF
   > [extensions]
   > sleepext = ../sleepext.py
   > EOF
 
 Test ctrl-c
-  $ python $TESTTMP/timeout.py -s INT 1 hg sleep 2
+  $ $PYTHON $TESTTMP/timeout.py -s INT 1 hg sleep 2
   interrupted!
   [124]
 
   $ cat >> $HGRCPATH << EOF
   > [experimental]
   > nointerrupt = yes
   > EOF
 
-  $ python $TESTTMP/timeout.py -s INT 1 hg sleep 2
+  $ $PYTHON $TESTTMP/timeout.py -s INT 1 hg sleep 2
   interrupted!
   [124]
 
   $ cat >> $HGRCPATH << EOF
   > [experimental]
   > nointerrupt-interactiveonly = False
   > EOF
 
-  $ python $TESTTMP/timeout.py -s INT 1 hg sleep 2
+  $ $PYTHON $TESTTMP/timeout.py -s INT 1 hg sleep 2
   shutting down cleanly
   press ^C again to terminate immediately (dangerous)
   end of unsafe operation
   interrupted!
   [124]

tests/test-remotefilelog-cacheprocess.t

@@ -1,125 +1,125 b''
 #require no-windows
 
   $ . "$TESTDIR/remotefilelog-library.sh"
 
   $ hg init repo
   $ cd repo
   $ cat >> .hg/hgrc <<EOF
   > [remotefilelog]
   > server=True
   > EOF
   $ echo x > x
   $ echo y > y
   $ echo z > z
   $ hg commit -qAm xy
   $ cd ..
 
   $ cat > cacheprocess-logger.py <<EOF
   > import os
   > import shutil
   > import sys
   > if sys.version_info[0] > 2:
   >     xrange = range
   > f = open('$TESTTMP/cachelog.log', 'w')
   > srccache = os.path.join('$TESTTMP', 'oldhgcache')
   > def log(message):
   >     f.write(message)
   >     f.flush()
   > destcache = sys.argv[-1]
   > try:
   >     while True:
   >         cmd = sys.stdin.readline().strip()
   >         log('got command %r\n' % cmd)
   >         if cmd == 'exit':
   >             sys.exit(0)
   >         elif cmd == 'get':
   >             count = int(sys.stdin.readline())
   >             log('client wants %r blobs\n' % count)
   >             wants = []
   >             for _ in xrange(count):
   >                 key = sys.stdin.readline()[:-1]
   >                 wants.append(key)
   >                 if '\0' in key:
   >                     _, key = key.split('\0')
   >                 srcpath = os.path.join(srccache, key)
   >                 if os.path.exists(srcpath):
   >                     dest = os.path.join(destcache, key)
   >                     destdir = os.path.dirname(dest)
   >                     if not os.path.exists(destdir):
   >                         os.makedirs(destdir)
   >                     shutil.copyfile(srcpath, dest)
   >                 else:
   >                     # report a cache miss
   >                     sys.stdout.write(key + '\n')
   >             sys.stdout.write('0\n')
   >             for key in sorted(wants):
   >                 log('requested %r\n' % key)
   >             sys.stdout.flush()
   >         elif cmd == 'set':
   >             raise Exception('todo writing')
   >         else:
   >             raise Exception('unknown command! %r' % cmd)
   > except Exception as e:
   >     log('Exception! %s\n' % e)
   >     raise
   > EOF
 
   $ cat >> $HGRCPATH <<EOF
   > [remotefilelog]
-  > cacheprocess = python $TESTTMP/cacheprocess-logger.py
+  > cacheprocess = $PYTHON $TESTTMP/cacheprocess-logger.py
   > EOF
 
 Test cache keys and cache misses.
   $ hgcloneshallow ssh://user@dummy/repo clone -q
   3 files fetched over 1 fetches - (3 misses, 0.00% hit ratio) over *s (glob)
   $ cat cachelog.log
   got command 'get'
   client wants 3 blobs
   requested 'master/11/f6ad8ec52a2984abaafd7c3b516503785c2072/1406e74118627694268417491f018a4a883152f0'
   requested 'master/39/5df8f7c51f007019cb30201c49e884b46b92fa/69a1b67522704ec122181c0890bd16e9d3e7516a'
   requested 'master/95/cb0bfd2977c761298d9624e4b4d4c72a39974a/076f5e2225b3ff0400b98c92aa6cdf403ee24cca'
   got command 'set'
   Exception! todo writing
 
 Test cache hits.
   $ mv hgcache oldhgcache
   $ rm cachelog.log
   $ hgcloneshallow ssh://user@dummy/repo clone-cachehit -q
   3 files fetched over 1 fetches - (0 misses, 100.00% hit ratio) over *s (glob)
   $ cat cachelog.log | grep -v exit
   got command 'get'
   client wants 3 blobs
   requested 'master/11/f6ad8ec52a2984abaafd7c3b516503785c2072/1406e74118627694268417491f018a4a883152f0'
   requested 'master/39/5df8f7c51f007019cb30201c49e884b46b92fa/69a1b67522704ec122181c0890bd16e9d3e7516a'
   requested 'master/95/cb0bfd2977c761298d9624e4b4d4c72a39974a/076f5e2225b3ff0400b98c92aa6cdf403ee24cca'
 
   $ cat >> $HGRCPATH <<EOF
   > [remotefilelog]
   > cacheprocess.includepath = yes
   > EOF
 
 Test cache keys and cache misses with includepath.
   $ rm -r hgcache oldhgcache
   $ rm cachelog.log
   $ hgcloneshallow ssh://user@dummy/repo clone-withpath -q
   3 files fetched over 1 fetches - (3 misses, 0.00% hit ratio) over *s (glob)
   $ cat cachelog.log
   got command 'get'
   client wants 3 blobs
   requested 'x\x00master/11/f6ad8ec52a2984abaafd7c3b516503785c2072/1406e74118627694268417491f018a4a883152f0'
   requested 'y\x00master/95/cb0bfd2977c761298d9624e4b4d4c72a39974a/076f5e2225b3ff0400b98c92aa6cdf403ee24cca'
   requested 'z\x00master/39/5df8f7c51f007019cb30201c49e884b46b92fa/69a1b67522704ec122181c0890bd16e9d3e7516a'
   got command 'set'
   Exception! todo writing
 
 Test cache hits with includepath.
   $ mv hgcache oldhgcache
   $ rm cachelog.log
   $ hgcloneshallow ssh://user@dummy/repo clone-withpath-cachehit -q
   3 files fetched over 1 fetches - (0 misses, 100.00% hit ratio) over *s (glob)
   $ cat cachelog.log | grep -v exit
   got command 'get'
   client wants 3 blobs
   requested 'x\x00master/11/f6ad8ec52a2984abaafd7c3b516503785c2072/1406e74118627694268417491f018a4a883152f0'
   requested 'y\x00master/95/cb0bfd2977c761298d9624e4b4d4c72a39974a/076f5e2225b3ff0400b98c92aa6cdf403ee24cca'
   requested 'z\x00master/39/5df8f7c51f007019cb30201c49e884b46b92fa/69a1b67522704ec122181c0890bd16e9d3e7516a'

tests/test-update-atomic.t

@@ -1,147 +1,147 b''
 #require execbit unix-permissions no-chg
 
 Checking that experimental.atomic-file works.
 
   $ cat > $TESTTMP/show_mode.py <<EOF
   > from __future__ import print_function
   > import os
   > import stat
   > import sys
   > ST_MODE = stat.ST_MODE
   > 
   > for file_path in sys.argv[1:]:
   >     file_stat = os.stat(file_path)
   >     octal_mode = oct(file_stat[ST_MODE] & 0o777).replace('o', '')
   >     print("%s:%s" % (file_path, octal_mode))
   > 
   > EOF
 
   $ hg init repo
   $ cd repo
 
   $ cat > .hg/showwrites.py <<EOF
   > from __future__ import print_function
   > from mercurial import pycompat
   > from mercurial.utils import stringutil
   > def uisetup(ui):
   >   from mercurial import vfs
   >   class newvfs(vfs.vfs):
   >     def __call__(self, *args, **kwargs):
   >       print(pycompat.sysstr(stringutil.pprint(
   >           ('vfs open', args, sorted(list(kwargs.items()))))))
   >       return super(newvfs, self).__call__(*args, **kwargs)
   >   vfs.vfs = newvfs
   > EOF
 
   $ for v in a1 a2 b1 b2 c ro; do echo $v > $v; done
   $ chmod +x b*
   $ hg commit -Aqm _
 
 # We check that
 # - the changes are actually atomic
 # - that permissions are correct (all 4 cases of (executable before) * (executable after))
 # - that renames work, though they should be atomic anyway
 # - that it works when source files are read-only (but directories are read-write still)
 
   $ for v in a1 a2 b1 b2 ro; do echo changed-$v > $v; done
   $ chmod -x *1; chmod +x *2
   $ hg rename c d
   $ hg commit -qm _
 
 Check behavior without update.atomic-file
 
   $ hg update -r 0 -q
   $ hg update -r 1 --config extensions.showwrites=.hg/showwrites.py 2>&1 | grep "a1'.*wb"
   ('vfs open', ('a1', 'wb'), [('atomictemp', False), ('backgroundclose', True)])
 
-  $ python $TESTTMP/show_mode.py *
+  $ $PYTHON $TESTTMP/show_mode.py *
   a1:0644
   a2:0755
   b1:0644
   b2:0755
   d:0644
   ro:0644
 
 Add a second revision for the ro file so we can test update when the file is
 present or not
 
   $ echo "ro" > ro
 
   $ hg commit -qm _
 
 Check behavior without update.atomic-file first
 
   $ hg update -C -r 0 -q
 
   $ hg update -r 1
   6 files updated, 0 files merged, 1 files removed, 0 files unresolved
 
-  $ python $TESTTMP/show_mode.py *
+  $ $PYTHON $TESTTMP/show_mode.py *
   a1:0644
   a2:0755
   b1:0644
   b2:0755
   d:0644
   ro:0644
 
 Manually reset the mode of the read-only file
 
   $ chmod a-w ro
 
-  $ python $TESTTMP/show_mode.py ro
+  $ $PYTHON $TESTTMP/show_mode.py ro
   ro:0444
 
 Now the file is present, try to update and check the permissions of the file
 
   $ hg up -r 2
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
-  $ python $TESTTMP/show_mode.py ro
+  $ $PYTHON $TESTTMP/show_mode.py ro
   ro:0644
 
 # The file which was read-only is now writable in the default behavior
 
 Check behavior with update.atomic-files
 
 
   $ cat >> .hg/hgrc <<EOF
   > [experimental]
   > update.atomic-file = true
   > EOF
 
   $ hg update -C -r 0 -q
   $ hg update -r 1 --config extensions.showwrites=.hg/showwrites.py 2>&1 | grep "a1'.*wb"
   ('vfs open', ('a1', 'wb'), [('atomictemp', True), ('backgroundclose', True)])
   $ hg st -A --rev 1
   C a1
   C a2
   C b1
   C b2
   C d
   C ro
 
 Check the file permission after update
-  $ python $TESTTMP/show_mode.py *
+  $ $PYTHON $TESTTMP/show_mode.py *
   a1:0644
   a2:0755
   b1:0644
   b2:0755
   d:0644
   ro:0644
 
 Manually reset the mode of the read-only file
 
   $ chmod a-w ro
 
-  $ python $TESTTMP/show_mode.py ro
+  $ $PYTHON $TESTTMP/show_mode.py ro
   ro:0444
 
 Now the file is present, try to update and check the permissions of the file
 
   $ hg update -r 2 --traceback
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
-  $ python $TESTTMP/show_mode.py ro
+  $ $PYTHON $TESTTMP/show_mode.py ro
   ro:0644
 
 # The behavior is the same as without atomic update

tests/test-verify-repo-operations.py

@@ -1,640 +1,642 b''
 from __future__ import print_function, absolute_import
 
 """Fuzz testing for operations against a Mercurial repository
 
 This uses Hypothesis's stateful testing to generate random repository
 operations and test Mercurial using them, both to see if there are any
 unexpected errors and to compare different versions of it."""
 
 import os
 import subprocess
 import sys
 
 # Only run if slow tests are allowed
-if subprocess.call(['python', '%s/hghave' % os.environ['TESTDIR'], 'slow']):
+if subprocess.call(
+    [os.environ['PYTHON'], '%s/hghave' % os.environ['TESTDIR'], 'slow']
+):
     sys.exit(80)
 
 # These tests require Hypothesis and pytz to be installed.
 # Running 'pip install hypothesis pytz' will achieve that.
 # Note: This won't work if you're running Python < 2.7.
 try:
     from hypothesis.extra.datetime import datetimes
 except ImportError:
     sys.stderr.write("skipped: hypothesis or pytz not installed" + os.linesep)
     sys.exit(80)
 
 # If you are running an old version of pip you may find that the enum34
 # backport is not installed automatically. If so 'pip install enum34' will
 # fix this problem.
 try:
     import enum
 
     assert enum  # Silence pyflakes
 except ImportError:
     sys.stderr.write("skipped: enum34 not installed" + os.linesep)
     sys.exit(80)
 
 import binascii
 from contextlib import contextmanager
 import errno
 import pipes
 import shutil
 import silenttestrunner
 import subprocess
 
 from hypothesis.errors import HypothesisException
 from hypothesis.stateful import (
     rule,
     RuleBasedStateMachine,
     Bundle,
     precondition,
 )
 from hypothesis import settings, note, strategies as st
 from hypothesis.configuration import set_hypothesis_home_dir
 from hypothesis.database import ExampleDatabase
 
 testdir = os.path.abspath(os.environ["TESTDIR"])
 
 # We store Hypothesis examples here rather in the temporary test directory
 # so that when rerunning a failing test this always results in refinding the
 # previous failure. This directory is in .hgignore and should not be checked in
 # but is useful to have for development.
 set_hypothesis_home_dir(os.path.join(testdir, ".hypothesis"))
 
 runtests = os.path.join(os.environ["RUNTESTDIR"], "run-tests.py")
 testtmp = os.environ["TESTTMP"]
 assert os.path.isdir(testtmp)
 
 generatedtests = os.path.join(testdir, "hypothesis-generated")
 
 try:
     os.makedirs(generatedtests)
 except OSError:
     pass
 
 # We write out generated .t files to a file in order to ease debugging and to
 # give a starting point for turning failures Hypothesis finds into normal
 # tests. In order to ensure that multiple copies of this test can be run in
 # parallel we use atomic file create to ensure that we always get a unique
 # name.
 file_index = 0
 while True:
     file_index += 1
     savefile = os.path.join(
         generatedtests, "test-generated-%d.t" % (file_index,)
     )
     try:
         os.close(os.open(savefile, os.O_CREAT | os.O_EXCL | os.O_WRONLY))
         break
     except OSError as e:
         if e.errno != errno.EEXIST:
             raise
 assert os.path.exists(savefile)
 
 hgrc = os.path.join(".hg", "hgrc")
 
 filecharacters = (
     "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
     "[]^_`;=@{}~ !#$%&'()+,-"
 )
 
 files = (
     st.text(filecharacters, min_size=1)
     .map(lambda x: x.strip())
     .filter(bool)
     .map(lambda s: s.encode('ascii'))
 )
 
 safetext = st.text(
     st.characters(
         min_codepoint=1, max_codepoint=127, blacklist_categories=('Cc', 'Cs')
     ),
     min_size=1,
 ).map(lambda s: s.encode('utf-8'))
 
 extensions = st.sampled_from(
     (
         'shelve',
         'mq',
         'blackbox',
     )
 )
 
 
 @contextmanager
 def acceptableerrors(*args):
     """Sometimes we know an operation we're about to perform might fail, and
     we're OK with some of the failures. In those cases this may be used as a
     context manager and will swallow expected failures, as identified by
     substrings of the error message Mercurial emits."""
     try:
         yield
     except subprocess.CalledProcessError as e:
         if not any(a in e.output for a in args):
             note(e.output)
             raise
 
 
 reponames = st.text("abcdefghijklmnopqrstuvwxyz01234556789", min_size=1).map(
     lambda s: s.encode('ascii')
 )
 
 
 class verifyingstatemachine(RuleBasedStateMachine):
     """This defines the set of acceptable operations on a Mercurial repository
     using Hypothesis's RuleBasedStateMachine.
 
     The general concept is that we manage multiple repositories inside a
     repos/ directory in our temporary test location. Some of these are freshly
     inited, some are clones of the others. Our current working directory is
     always inside one of these repositories while the tests are running.
 
     Hypothesis then performs a series of operations against these repositories,
     including hg commands, generating contents and editing the .hgrc file.
     If these operations fail in unexpected ways or behave differently in
     different configurations of Mercurial, the test will fail and a minimized
     .t test file will be written to the hypothesis-generated directory to
     exhibit that failure.
 
     Operations are defined as methods with @rule() decorators. See the
     Hypothesis documentation at
     http://hypothesis.readthedocs.org/en/release/stateful.html for more
     details."""
 
     # A bundle is a reusable collection of previously generated data which may
     # be provided as arguments to future operations.
     repos = Bundle('repos')
     paths = Bundle('paths')
     contents = Bundle('contents')
     branches = Bundle('branches')
     committimes = Bundle('committimes')
 
     def __init__(self):
         super(verifyingstatemachine, self).__init__()
         self.repodir = os.path.join(testtmp, "repos")
         if os.path.exists(self.repodir):
             shutil.rmtree(self.repodir)
         os.chdir(testtmp)
         self.log = []
         self.failed = False
         self.configperrepo = {}
         self.all_extensions = set()
         self.non_skippable_extensions = set()
 
         self.mkdirp("repos")
         self.cd("repos")
         self.mkdirp("repo1")
         self.cd("repo1")
         self.hg("init")
 
     def teardown(self):
         """On teardown we clean up after ourselves as usual, but we also
         do some additional testing: We generate a .t file based on our test
         run using run-test.py -i to get the correct output.
 
         We then test it in a number of other configurations, verifying that
         each passes the same test."""
         super(verifyingstatemachine, self).teardown()
         try:
             shutil.rmtree(self.repodir)
         except OSError:
             pass
         ttest = os.linesep.join("  " + l for l in self.log)
         os.chdir(testtmp)
         path = os.path.join(testtmp, "test-generated.t")
         with open(path, 'w') as o:
             o.write(ttest + os.linesep)
         with open(os.devnull, "w") as devnull:
             rewriter = subprocess.Popen(
                 [runtests, "--local", "-i", path],
                 stdin=subprocess.PIPE,
                 stdout=devnull,
                 stderr=devnull,
             )
             rewriter.communicate("yes")
             with open(path, 'r') as i:
                 ttest = i.read()
 
         e = None
         if not self.failed:
             try:
                 output = subprocess.check_output(
                     [runtests, path, "--local", "--pure"],
                     stderr=subprocess.STDOUT,
                 )
                 assert "Ran 1 test" in output, output
                 for ext in self.all_extensions - self.non_skippable_extensions:
                     tf = os.path.join(
                         testtmp, "test-generated-no-%s.t" % (ext,)
                     )
                     with open(tf, 'w') as o:
                         for l in ttest.splitlines():
                             if l.startswith("  $ hg"):
                                 l = l.replace(
                                     "--config %s=" % (extensionconfigkey(ext),),
                                     "",
                                 )
                             o.write(l + os.linesep)
                     with open(tf, 'r') as r:
                         t = r.read()
                         assert ext not in t, t
                     output = subprocess.check_output(
                         [
                             runtests,
                             tf,
                             "--local",
                         ],
                         stderr=subprocess.STDOUT,
                     )
                     assert "Ran 1 test" in output, output
             except subprocess.CalledProcessError as e:
                 note(e.output)
         if self.failed or e is not None:
             with open(savefile, "wb") as o:
                 o.write(ttest)
         if e is not None:
             raise e
 
     def execute_step(self, step):
         try:
             return super(verifyingstatemachine, self).execute_step(step)
         except (HypothesisException, KeyboardInterrupt):
             raise
         except Exception:
             self.failed = True
             raise
 
     # Section: Basic commands.
     def mkdirp(self, path):
         if os.path.exists(path):
             return
         self.log.append(
             "$ mkdir -p -- %s" % (pipes.quote(os.path.relpath(path)),)
         )
         os.makedirs(path)
 
     def cd(self, path):
         path = os.path.relpath(path)
         if path == ".":
             return
         os.chdir(path)
         self.log.append("$ cd -- %s" % (pipes.quote(path),))
 
     def hg(self, *args):
         extra_flags = []
         for key, value in self.config.items():
             extra_flags.append("--config")
             extra_flags.append("%s=%s" % (key, value))
         self.command("hg", *(tuple(extra_flags) + args))
 
     def command(self, *args):
         self.log.append("$ " + ' '.join(map(pipes.quote, args)))
         subprocess.check_output(args, stderr=subprocess.STDOUT)
 
     # Section: Set up basic data
     # This section has no side effects but generates data that we will want
     # to use later.
     @rule(
         target=paths,
         source=st.lists(files, min_size=1).map(lambda l: os.path.join(*l)),
     )
     def genpath(self, source):
         return source
 
     @rule(
         target=committimes,
         when=datetimes(min_year=1970, max_year=2038) | st.none(),
     )
     def gentime(self, when):
         return when
 
     @rule(
         target=contents,
         content=st.one_of(
             st.binary(), st.text().map(lambda x: x.encode('utf-8'))
         ),
     )
     def gencontent(self, content):
         return content
 
     @rule(
         target=branches,
         name=safetext,
     )
     def genbranch(self, name):
         return name
 
     @rule(target=paths, source=paths)
     def lowerpath(self, source):
         return source.lower()
 
     @rule(target=paths, source=paths)
     def upperpath(self, source):
         return source.upper()
 
     # Section: Basic path operations
     @rule(path=paths, content=contents)
     def writecontent(self, path, content):
         self.unadded_changes = True
         if os.path.isdir(path):
             return
         parent = os.path.dirname(path)
         if parent:
             try:
                 self.mkdirp(parent)
             except OSError:
                 # It may be the case that there is a regular file that has
                 # previously been created that has the same name as an ancestor
                 # of the current path. This will cause mkdirp to fail with this
                 # error. We just turn this into a no-op in that case.
                 return
         with open(path, 'wb') as o:
             o.write(content)
         self.log.append(
             (
-                "$ python -c 'import binascii; "
+                "$ $PYTHON -c 'import binascii; "
                 "print(binascii.unhexlify(\"%s\"))' > %s"
             )
             % (
                 binascii.hexlify(content),
                 pipes.quote(path),
             )
         )
 
     @rule(path=paths)
     def addpath(self, path):
         if os.path.exists(path):
             self.hg("add", "--", path)
 
     @rule(path=paths)
     def forgetpath(self, path):
         if os.path.exists(path):
             with acceptableerrors(
                 "file is already untracked",
             ):
                 self.hg("forget", "--", path)
 
     @rule(s=st.none() | st.integers(0, 100))
     def addremove(self, s):
         args = ["addremove"]
         if s is not None:
             args.extend(["-s", str(s)])
         self.hg(*args)
 
     @rule(path=paths)
     def removepath(self, path):
         if os.path.exists(path):
             with acceptableerrors(
                 'file is untracked',
                 'file has been marked for add',
                 'file is modified',
             ):
                 self.hg("remove", "--", path)
 
     @rule(
         message=safetext,
         amend=st.booleans(),
         when=committimes,
         addremove=st.booleans(),
         secret=st.booleans(),
         close_branch=st.booleans(),
     )
     def maybecommit(
         self, message, amend, when, addremove, secret, close_branch
     ):
         command = ["commit"]
         errors = ["nothing changed"]
         if amend:
             errors.append("cannot amend public changesets")
             command.append("--amend")
         command.append("-m" + pipes.quote(message))
         if secret:
             command.append("--secret")
         if close_branch:
             command.append("--close-branch")
             errors.append("can only close branch heads")
         if addremove:
             command.append("--addremove")
         if when is not None:
             if when.year == 1970:
                 errors.append('negative date value')
             if when.year == 2038:
                 errors.append('exceeds 32 bits')
             command.append(
                 "--date=%s" % (when.strftime('%Y-%m-%d %H:%M:%S %z'),)
             )
 
         with acceptableerrors(*errors):
             self.hg(*command)
 
     # Section: Repository management
     @property
     def currentrepo(self):
         return os.path.basename(os.getcwd())
 
     @property
     def config(self):
         return self.configperrepo.setdefault(self.currentrepo, {})
 
     @rule(
         target=repos,
         source=repos,
         name=reponames,
     )
     def clone(self, source, name):
         if not os.path.exists(os.path.join("..", name)):
             self.cd("..")
             self.hg("clone", source, name)
             self.cd(name)
         return name
 
     @rule(
         target=repos,
         name=reponames,
     )
     def fresh(self, name):
         if not os.path.exists(os.path.join("..", name)):
             self.cd("..")
             self.mkdirp(name)
             self.cd(name)
             self.hg("init")
         return name
 
     @rule(name=repos)
     def switch(self, name):
         self.cd(os.path.join("..", name))
         assert self.currentrepo == name
         assert os.path.exists(".hg")
 
     @rule(target=repos)
     def origin(self):
         return "repo1"
 
     @rule()
     def pull(self, repo=repos):
         with acceptableerrors(
             "repository default not found",
             "repository is unrelated",
         ):
             self.hg("pull")
 
     @rule(newbranch=st.booleans())
     def push(self, newbranch):
         with acceptableerrors(
             "default repository not configured",
             "no changes found",
         ):
             if newbranch:
                 self.hg("push", "--new-branch")
             else:
                 with acceptableerrors("creates new branches"):
                     self.hg("push")
 
     # Section: Simple side effect free "check" operations
     @rule()
     def log(self):
         self.hg("log")
 
     @rule()
     def verify(self):
         self.hg("verify")
 
     @rule()
     def diff(self):
         self.hg("diff", "--nodates")
 
     @rule()
     def status(self):
         self.hg("status")
 
     @rule()
     def export(self):
         self.hg("export")
 
     # Section: Branch management
     @rule()
     def checkbranch(self):
         self.hg("branch")
 
     @rule(branch=branches)
     def switchbranch(self, branch):
         with acceptableerrors(
             'cannot use an integer as a name',
             'cannot be used in a name',
             'a branch of the same name already exists',
             'is reserved',
         ):
             self.hg("branch", "--", branch)
 
     @rule(branch=branches, clean=st.booleans())
     def update(self, branch, clean):
         with acceptableerrors(
             'unknown revision',
             'parse error',
         ):
             if clean:
                 self.hg("update", "-C", "--", branch)
             else:
                 self.hg("update", "--", branch)
 
     # Section: Extension management
     def hasextension(self, extension):
         return extensionconfigkey(extension) in self.config
 
     def commandused(self, extension):
         assert extension in self.all_extensions
         self.non_skippable_extensions.add(extension)
 
     @rule(extension=extensions)
     def addextension(self, extension):
         self.all_extensions.add(extension)
         self.config[extensionconfigkey(extension)] = ""
 
     @rule(extension=extensions)
     def removeextension(self, extension):
         self.config.pop(extensionconfigkey(extension), None)
 
     # Section: Commands from the shelve extension
     @rule()
     @precondition(lambda self: self.hasextension("shelve"))
     def shelve(self):
         self.commandused("shelve")
         with acceptableerrors("nothing changed"):
             self.hg("shelve")
 
     @rule()
     @precondition(lambda self: self.hasextension("shelve"))
     def unshelve(self):
         self.commandused("shelve")
         with acceptableerrors("no shelved changes to apply"):
             self.hg("unshelve")
 
 
 class writeonlydatabase(ExampleDatabase):
     def __init__(self, underlying):
         super(ExampleDatabase, self).__init__()
         self.underlying = underlying
 
     def fetch(self, key):
         return ()
 
     def save(self, key, value):
         self.underlying.save(key, value)
 
     def delete(self, key, value):
         self.underlying.delete(key, value)
 
     def close(self):
         self.underlying.close()
 
 
 def extensionconfigkey(extension):
     return "extensions." + extension
 
 
 settings.register_profile(
     'default',
     settings(
         timeout=300,
         stateful_step_count=50,
         max_examples=10,
     ),
 )
 
 settings.register_profile(
     'fast',
     settings(
         timeout=10,
         stateful_step_count=20,
         max_examples=5,
         min_satisfying_examples=1,
         max_shrinks=0,
     ),
 )
 
 settings.register_profile(
     'continuous',
     settings(
         timeout=-1,
         stateful_step_count=1000,
         max_examples=10 ** 8,
         max_iterations=10 ** 8,
         database=writeonlydatabase(settings.default.database),
     ),
 )
 
 settings.load_profile(os.getenv('HYPOTHESIS_PROFILE', 'default'))
 
 verifyingtest = verifyingstatemachine.TestCase
 
 verifyingtest.settings = settings.default
 
 if __name__ == '__main__':
     try:
         silenttestrunner.main(__name__)
     finally:
         # So as to prevent proliferation of useless test files, if we never
         # actually wrote a failing test we clean up after ourselves and delete
         # the file for doing so that we owned.
         if os.path.exists(savefile) and os.path.getsize(savefile) == 0:
             os.unlink(savefile)