( )⚙ D12235 tests: collapse some more trivial if PYTHON3 blocks

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D12235

tests: collapse some more trivial if PYTHON3 blocks
ClosedPublic

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

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHG41c552a20716: tests: collapse some more trivial if PYTHON3 blocks
Summary

This doesn't account for all of the references to PYTHON3. But it
accounts for the ones that are more trivial and don't entail logical
changes.

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:34 PM
Alphare accepted this revision.Mar 2 2022, 5:29 AM
This revision is now accepted and ready to land.Mar 2 2022, 5:29 AM
indygreg added a commit: rHG41c552a20716: tests: collapse some more trivial if PYTHON3 blocks.Mar 3 2022, 11:41 AM
Closed by commit rHG41c552a20716: tests: collapse some more trivial if PYTHON3 blocks (authored by indygreg). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mtests/run-tests.py (74 lines)

Diff 32310

tests/run-tests.py

defaults = default_defaults.copy() defaults = default_defaults.copy()
def canonpath(path): def canonpath(path):
return os.path.realpath(os.path.expanduser(path)) return os.path.realpath(os.path.expanduser(path))
def which(exe): def which(exe):
if PYTHON3:
# shutil.which only accept bytes from 3.8 # shutil.which only accept bytes from 3.8
cmd = _bytes2sys(exe) cmd = _bytes2sys(exe)
real_exec = shutil.which(cmd) real_exec = shutil.which(cmd)
return _sys2bytes(real_exec) return _sys2bytes(real_exec)
else:
# let us do the os work
for p in osenvironb[b'PATH'].split(os.pathsep):
f = os.path.join(p, exe)
if os.path.isfile(f):
return f
return None
def parselistfiles(files, listtype, warn=True): def parselistfiles(files, listtype, warn=True):
entries = dict() entries = dict()
for filename in files: for filename in files:
try: try:
path = os.path.expanduser(os.path.expandvars(filename)) path = os.path.expanduser(os.path.expandvars(filename))
f = open(path, "rb") f = open(path, "rb")
inpython = False inpython = False
if self._debug: if self._debug:
script.append(b'set -x\n') script.append(b'set -x\n')
if os.getenv('MSYSTEM'): if os.getenv('MSYSTEM'):
script.append(b'alias pwd="pwd -W"\n') script.append(b'alias pwd="pwd -W"\n')
if hgcatapult and hgcatapult != os.devnull: if hgcatapult and hgcatapult != os.devnull:
if PYTHON3:
hgcatapult = hgcatapult.encode('utf8') hgcatapult = hgcatapult.encode('utf8')
cataname = self.name.encode('utf8') cataname = self.name.encode('utf8')
else:
cataname = self.name
# Kludge: use a while loop to keep the pipe from getting # Kludge: use a while loop to keep the pipe from getting
# closed by our echo commands. The still-running file gets # closed by our echo commands. The still-running file gets
# reaped at the end of the script, which causes the while # reaped at the end of the script, which causes the while
# loop to exit and closes the pipe. Sigh. # loop to exit and closes the pipe. Sigh.
script.append( script.append(
b'rtendtracing() {\n' b'rtendtracing() {\n'
b' echo END %(session)s %(name)s >> %(catapult)s\n' b' echo END %(session)s %(name)s >> %(catapult)s\n'
conditions = [c for c in m.group(2).split(b' ')] conditions = [c for c in m.group(2).split(b' ')]
el = m.group(1) + b"\n" el = m.group(1) + b"\n"
if not self._iftest(conditions): if not self._iftest(conditions):
# listed feature missing, should not match # listed feature missing, should not match
return "retry", False return "retry", False
if el.endswith(b" (esc)\n"): if el.endswith(b" (esc)\n"):
if PYTHON3:
el = el[:-7].decode('unicode_escape') + '\n' el = el[:-7].decode('unicode_escape') + '\n'
el = el.encode('latin-1') el = el.encode('latin-1')
else:
el = el[:-7].decode('string-escape') + '\n'
if el == l or WINDOWS and el[:-1] + b'\r\n' == l: if el == l or WINDOWS and el[:-1] + b'\r\n' == l:
return True, True return True, True
if el.endswith(b" (re)\n"): if el.endswith(b" (re)\n"):
return (TTest.rematch(el[:-6], l) or retry), False return (TTest.rematch(el[:-6], l) or retry), False
if el.endswith(b" (glob)\n"): if el.endswith(b" (glob)\n"):
# ignore '(glob)' added to l by 'replacements' # ignore '(glob)' added to l by 'replacements'
if l.endswith(b" (glob)\n"): if l.endswith(b" (glob)\n"):
l = l[:-8] + b"\n" l = l[:-8] + b"\n"
def _stringescape(s): def _stringescape(s):
return TTest.ESCAPESUB(TTest._escapef, s) return TTest.ESCAPESUB(TTest._escapef, s)
iolock = threading.RLock() iolock = threading.RLock()
firstlock = threading.RLock() firstlock = threading.RLock()
firsterror = False firsterror = False
if PYTHON3:
base_class = unittest.TextTestResult base_class = unittest.TextTestResult
else:
base_class = unittest._TextTestResult
class TestResult(base_class): class TestResult(base_class):
"""Holds results when executing via unittest.""" """Holds results when executing via unittest."""
def __init__(self, options, *args, **kwargs): def __init__(self, options, *args, **kwargs):
super(TestResult, self).__init__(*args, **kwargs) super(TestResult, self).__init__(*args, **kwargs)
) )
else: else:
servefail, lines = getdiff( servefail, lines = getdiff(
expected, got, test.refpath, test.errpath expected, got, test.refpath, test.errpath
) )
self.stream.write('\n') self.stream.write('\n')
for line in lines: for line in lines:
line = highlightdiff(line, self.color) line = highlightdiff(line, self.color)
if PYTHON3:
self.stream.flush() self.stream.flush()
self.stream.buffer.write(line) self.stream.buffer.write(line)
self.stream.buffer.flush() self.stream.buffer.flush()
else:
self.stream.write(line)
self.stream.flush()
if servefail: if servefail:
raise test.failureException( raise test.failureException(
'server failed to start (HGPORT=%s)' % test._startport 'server failed to start (HGPORT=%s)' % test._startport
) )
# handle interactive prompt without releasing iolock # handle interactive prompt without releasing iolock
if self._options.interactive: if self._options.interactive:
osenvironb.pop(b'PYOXIDIZED_INSTALLED_AS_HG', None) osenvironb.pop(b'PYOXIDIZED_INSTALLED_AS_HG', None)
osenvironb[b"BINDIR"] = self._bindir osenvironb[b"BINDIR"] = self._bindir
osenvironb[b"PYTHON"] = PYTHON osenvironb[b"PYTHON"] = PYTHON
fileb = _sys2bytes(__file__) fileb = _sys2bytes(__file__)
runtestdir = os.path.abspath(os.path.dirname(fileb)) runtestdir = os.path.abspath(os.path.dirname(fileb))
osenvironb[b'RUNTESTDIR'] = runtestdir osenvironb[b'RUNTESTDIR'] = runtestdir
if PYTHON3:
sepb = _sys2bytes(os.pathsep) sepb = _sys2bytes(os.pathsep)
else:
sepb = os.pathsep
path = [self._bindir, runtestdir] + osenvironb[b"PATH"].split(sepb) path = [self._bindir, runtestdir] + osenvironb[b"PATH"].split(sepb)
if os.path.islink(__file__): if os.path.islink(__file__):
# test helper will likely be at the end of the symlink # test helper will likely be at the end of the symlink
realfile = os.path.realpath(fileb) realfile = os.path.realpath(fileb)
realdir = os.path.abspath(os.path.dirname(realfile)) realdir = os.path.abspath(os.path.dirname(realfile))
path.insert(2, realdir) path.insert(2, realdir)
if chgbindir != self._bindir: if chgbindir != self._bindir:
path.insert(1, chgbindir) path.insert(1, chgbindir)
def _usecorrectpython(self): def _usecorrectpython(self):
"""Configure the environment to use the appropriate Python in tests.""" """Configure the environment to use the appropriate Python in tests."""
# Tests must use the same interpreter as us or bad things will happen. # Tests must use the same interpreter as us or bad things will happen.
if WINDOWS and PYTHON3: if WINDOWS and PYTHON3:
pyexe_names = [b'python', b'python3', b'python.exe'] pyexe_names = [b'python', b'python3', b'python.exe']
elif WINDOWS: elif WINDOWS:
pyexe_names = [b'python', b'python.exe'] pyexe_names = [b'python', b'python.exe']
elif PYTHON3:
pyexe_names = [b'python', b'python3']
else: else:
pyexe_names = [b'python', b'python2'] pyexe_names = [b'python', b'python3']
# os.symlink() is a thing with py3 on Windows, but it requires # os.symlink() is a thing with py3 on Windows, but it requires
# Administrator rights. # Administrator rights.
if not WINDOWS and getattr(os, 'symlink', None): if not WINDOWS and getattr(os, 'symlink', None):
msg = "# Making python executable in test path a symlink to '%s'" msg = "# Making python executable in test path a symlink to '%s'"
msg %= sysexecutable msg %= sysexecutable
vlog(msg) vlog(msg)
for pyexename in pyexe_names: for pyexename in pyexe_names:
try: try:
os.remove(installerrs) os.remove(installerrs)
except OSError as e: except OSError as e:
if e.errno != errno.ENOENT: if e.errno != errno.ENOENT:
raise raise
else: else:
with open(installerrs, 'rb') as f: with open(installerrs, 'rb') as f:
for line in f: for line in f:
if PYTHON3:
sys.stdout.buffer.write(line) sys.stdout.buffer.write(line)
else:
sys.stdout.write(line)
sys.exit(1) sys.exit(1)
os.chdir(self._testdir) os.chdir(self._testdir)
hgbat = os.path.join(self._bindir, b'hg.bat') hgbat = os.path.join(self._bindir, b'hg.bat')
if os.path.isfile(hgbat): if os.path.isfile(hgbat):
# hg.bat expects to be put in bin/scripts while run-tests.py # hg.bat expects to be put in bin/scripts while run-tests.py
# installation layout put it in bin/ directly. Fix it # installation layout put it in bin/ directly. Fix it
with open(hgbat, 'rb') as f: with open(hgbat, 'rb') as f:
shell=True, shell=True,
cwd=cwd, cwd=cwd,
stdin=subprocess.PIPE, stdin=subprocess.PIPE,
stdout=subprocess.PIPE, stdout=subprocess.PIPE,
stderr=subprocess.STDOUT, stderr=subprocess.STDOUT,
) )
out, _err = proc.communicate() out, _err = proc.communicate()
if proc.returncode != 0: if proc.returncode != 0:
if PYTHON3:
sys.stdout.buffer.write(out) sys.stdout.buffer.write(out)
else:
sys.stdout.write(out)
sys.exit(1) sys.exit(1)
def _installrhg(self): def _installrhg(self):
"""Install rhg into the test environment""" """Install rhg into the test environment"""
vlog('# Performing temporary installation of rhg') vlog('# Performing temporary installation of rhg')
assert os.path.dirname(self._bindir) == self._installdir assert os.path.dirname(self._bindir) == self._installdir
assert self._hgroot, 'must be called after _installhg()' assert self._hgroot, 'must be called after _installhg()'
cmd = b'"%(make)s" install-rhg PREFIX="%(prefix)s"' % { cmd = b'"%(make)s" install-rhg PREFIX="%(prefix)s"' % {
b'make': b'make', # TODO: switch by option or environment? b'make': b'make', # TODO: switch by option or environment?
b'prefix': self._installdir, b'prefix': self._installdir,
} }
cwd = self._hgroot cwd = self._hgroot
vlog("# Running", cmd) vlog("# Running", cmd)
proc = subprocess.Popen( proc = subprocess.Popen(
cmd, cmd,
shell=True, shell=True,
cwd=cwd, cwd=cwd,
stdin=subprocess.PIPE, stdin=subprocess.PIPE,
stdout=subprocess.PIPE, stdout=subprocess.PIPE,
stderr=subprocess.STDOUT, stderr=subprocess.STDOUT,
) )
out, _err = proc.communicate() out, _err = proc.communicate()
if proc.returncode != 0: if proc.returncode != 0:
if PYTHON3:
sys.stdout.buffer.write(out) sys.stdout.buffer.write(out)
else:
sys.stdout.write(out)
sys.exit(1) sys.exit(1)
def _build_pyoxidized(self): def _build_pyoxidized(self):
"""build a pyoxidized version of mercurial into the test environment """build a pyoxidized version of mercurial into the test environment
Ideally this function would be `install_pyoxidier` and would both build Ideally this function would be `install_pyoxidier` and would both build
and install pyoxidier. However we are starting small to get pyoxidizer and install pyoxidier. However we are starting small to get pyoxidizer
build binary to testing quickly. build binary to testing quickly.
shell=True, shell=True,
cwd=_bytes2sys(cwd), cwd=_bytes2sys(cwd),
stdin=subprocess.PIPE, stdin=subprocess.PIPE,
stdout=subprocess.PIPE, stdout=subprocess.PIPE,
stderr=subprocess.STDOUT, stderr=subprocess.STDOUT,
) )
out, _err = proc.communicate() out, _err = proc.communicate()
if proc.returncode != 0: if proc.returncode != 0:
if PYTHON3:
sys.stdout.buffer.write(out) sys.stdout.buffer.write(out)
else:
sys.stdout.write(out)
sys.exit(1) sys.exit(1)
def _outputcoverage(self): def _outputcoverage(self):
"""Produce code coverage output.""" """Produce code coverage output."""
import coverage import coverage
coverage = coverage.coverage coverage = coverage.coverage