upstream/mercurial-mirror Commit - r32303:dc131b97

1

#!/usr/bin/env python

1

#!/usr/bin/env python

2

#

2

#

3

# run-tests.py - Run a set of tests on Mercurial

3

# run-tests.py - Run a set of tests on Mercurial

4

#

4

#

5

6

#

6

#

7

# This software may be used and distributed according to the terms of the

7

# This software may be used and distributed according to the terms of the

8

# GNU General Public License version 2 or any later version.

8

# GNU General Public License version 2 or any later version.

9

10

# Modifying this script is tricky because it has many modes:

10

# Modifying this script is tricky because it has many modes:

11

# - serial (default) vs parallel (-jN, N > 1)

11

# - serial (default) vs parallel (-jN, N > 1)

12

# - no coverage (default) vs coverage (-c, -C, -s)

12

# - no coverage (default) vs coverage (-c, -C, -s)

13

# - temp install (default) vs specific hg script (--with-hg, --local)

13

# - temp install (default) vs specific hg script (--with-hg, --local)

14

# - tests are a mix of shell scripts and Python scripts

14

# - tests are a mix of shell scripts and Python scripts

15

#

15

#

16

# If you change this script, it is recommended that you ensure you

16

# If you change this script, it is recommended that you ensure you

17

# haven't broken it by running it in various modes with a representative

17

# haven't broken it by running it in various modes with a representative

18

# sample of test scripts. For example:

18

# sample of test scripts. For example:

19

#

19

#

20

# 1) serial, no coverage, temp install:

20

# 1) serial, no coverage, temp install:

21

# ./run-tests.py test-s*

21

# ./run-tests.py test-s*

22

# 2) serial, no coverage, local hg:

22

# 2) serial, no coverage, local hg:

23

# ./run-tests.py --local test-s*

23

# ./run-tests.py --local test-s*

24

# 3) serial, coverage, temp install:

24

# 3) serial, coverage, temp install:

25

# ./run-tests.py -c test-s*

25

# ./run-tests.py -c test-s*

26

# 4) serial, coverage, local hg:

26

# 4) serial, coverage, local hg:

27

# ./run-tests.py -c --local test-s* # unsupported

27

# ./run-tests.py -c --local test-s* # unsupported

28

# 5) parallel, no coverage, temp install:

28

# 5) parallel, no coverage, temp install:

29

# ./run-tests.py -j2 test-s*

29

# ./run-tests.py -j2 test-s*

30

# 6) parallel, no coverage, local hg:

30

# 6) parallel, no coverage, local hg:

31

# ./run-tests.py -j2 --local test-s*

31

# ./run-tests.py -j2 --local test-s*

32

# 7) parallel, coverage, temp install:

32

# 7) parallel, coverage, temp install:

33

# ./run-tests.py -j2 -c test-s* # currently broken

33

# ./run-tests.py -j2 -c test-s* # currently broken

34

# 8) parallel, coverage, local install:

34

# 8) parallel, coverage, local install:

35

# ./run-tests.py -j2 -c --local test-s* # unsupported (and broken)

35

# ./run-tests.py -j2 -c --local test-s* # unsupported (and broken)

36

# 9) parallel, custom tmp dir:

36

# 9) parallel, custom tmp dir:

37

# ./run-tests.py -j2 --tmpdir /tmp/myhgtests

37

# ./run-tests.py -j2 --tmpdir /tmp/myhgtests

38

# 10) parallel, pure, tests that call run-tests:

38

# 10) parallel, pure, tests that call run-tests:

39

# ./run-tests.py --pure `grep -l run-tests.py *.t`

39

# ./run-tests.py --pure `grep -l run-tests.py *.t`

40

#

40

#

41

# (You could use any subset of the tests: test-s* happens to match

41

# (You could use any subset of the tests: test-s* happens to match

42

# enough that it's worth doing parallel runs, few enough that it

42

# enough that it's worth doing parallel runs, few enough that it

43

# completes fairly quickly, includes both shell and Python scripts, and

43

# completes fairly quickly, includes both shell and Python scripts, and

44

# includes some scripts that run daemon processes.)

44

# includes some scripts that run daemon processes.)

45

46

from __future__ import absolute_import, print_function

46

from __future__ import absolute_import, print_function

47

48

import difflib

48

import difflib

49

import distutils.version as version

49

import distutils.version as version

50

import errno

50

import errno

51

import json

51

import json

52

import optparse

52

import optparse

53

import os

53

import os

54

import random

54

import random

55

import re

55

import re

56

import shutil

56

import shutil

57

import signal

57

import signal

58

import socket

58

import socket

59

import subprocess

59

import subprocess

60

import sys

60

import sys

61

import sysconfig

61

import sysconfig

62

import tempfile

62

import tempfile

63

import threading

63

import threading

64

import time

64

import time

65

import unittest

65

import unittest

66

import xml.dom.minidom as minidom

66

import xml.dom.minidom as minidom

67

68

try:

68

try:

69

import Queue as queue

69

import Queue as queue

70

except ImportError:

70

except ImportError:

71

import queue

71

import queue

72

73

if os.environ.get('RTUNICODEPEDANTRY', False):

73

if os.environ.get('RTUNICODEPEDANTRY', False):

74

try:

74

try:

75

reload(sys)

75

reload(sys)

76

sys.setdefaultencoding("undefined")

76

sys.setdefaultencoding("undefined")

77

except NameError:

77

except NameError:

78

pass

78

pass

79

80

osenvironb = getattr(os, 'environb', os.environ)

80

osenvironb = getattr(os, 'environb', os.environ)

81

processlock = threading.Lock()

81

processlock = threading.Lock()

82

83

if sys.version_info > (3, 5, 0):

83

if sys.version_info > (3, 5, 0):

84

PYTHON3 = True

84

PYTHON3 = True

85

xrange = range # we use xrange in one place, and we'd rather not use range

85

xrange = range # we use xrange in one place, and we'd rather not use range

86

def _bytespath(p):

86

def _bytespath(p):

87

return p.encode('utf-8')

87

return p.encode('utf-8')

88

89

def _strpath(p):

89

def _strpath(p):

90

return p.decode('utf-8')

90

return p.decode('utf-8')

91

92

elif sys.version_info >= (3, 0, 0):

92

elif sys.version_info >= (3, 0, 0):

93

print('%s is only supported on Python 3.5+ and 2.6-2.7, not %s' %

93

print('%s is only supported on Python 3.5+ and 2.6-2.7, not %s' %

94

(sys.argv[0], '.'.join(str(v) for v in sys.version_info[:3])))

94

(sys.argv[0], '.'.join(str(v) for v in sys.version_info[:3])))

95

sys.exit(70) # EX_SOFTWARE from `man 3 sysexit`

95

sys.exit(70) # EX_SOFTWARE from `man 3 sysexit`

96

else:

96

else:

97

PYTHON3 = False

97

PYTHON3 = False

98

99

# In python 2.x, path operations are generally done using

99

# In python 2.x, path operations are generally done using

100

# bytestrings by default, so we don't have to do any extra

100

# bytestrings by default, so we don't have to do any extra

101

# fiddling there. We define the wrapper functions anyway just to

101

# fiddling there. We define the wrapper functions anyway just to

102

# help keep code consistent between platforms.

102

# help keep code consistent between platforms.

103

def _bytespath(p):

103

def _bytespath(p):

104

return p

104

return p

105

106

_strpath = _bytespath

106

_strpath = _bytespath

107

108

# For Windows support

108

# For Windows support

109

wifexited = getattr(os, "WIFEXITED", lambda x: False)

109

wifexited = getattr(os, "WIFEXITED", lambda x: False)

110

111

# Whether to use IPv6

111

# Whether to use IPv6

112

def checksocketfamily(name, port=20058):

112

def checksocketfamily(name, port=20058):

113

"""return true if we can listen on localhost using family=name

113

"""return true if we can listen on localhost using family=name

114

115

name should be either 'AF_INET', or 'AF_INET6'.

115

name should be either 'AF_INET', or 'AF_INET6'.

116

port being used is okay - EADDRINUSE is considered as successful.

116

port being used is okay - EADDRINUSE is considered as successful.

117

"""

117

"""

118

family = getattr(socket, name, None)

118

family = getattr(socket, name, None)

119

if family is None:

119

if family is None:

120

return False

120

return False

121

try:

121

try:

122

s = socket.socket(family, socket.SOCK_STREAM)

122

s = socket.socket(family, socket.SOCK_STREAM)

123

s.bind(('localhost', port))

123

s.bind(('localhost', port))

124

s.close()

124

s.close()

125

return True

125

return True

126

except socket.error as exc:

126

except socket.error as exc:

127

if exc.errno == errno.EADDRINUSE:

127

if exc.errno == errno.EADDRINUSE:

128

return True

128

return True

129

elif exc.errno in (errno.EADDRNOTAVAIL, errno.EPROTONOSUPPORT):

129

elif exc.errno in (errno.EADDRNOTAVAIL, errno.EPROTONOSUPPORT):

130

return False

130

return False

131

else:

131

else:

132

raise

132

raise

133

else:

133

else:

134

return False

134

return False

135

136

# useipv6 will be set by parseargs

136

# useipv6 will be set by parseargs

137

useipv6 = None

137

useipv6 = None

138

139

def checkportisavailable(port):

139

def checkportisavailable(port):

140

"""return true if a port seems free to bind on localhost"""

140

"""return true if a port seems free to bind on localhost"""

141

if useipv6:

141

if useipv6:

142

family = socket.AF_INET6

142

family = socket.AF_INET6

143

else:

143

else:

144

family = socket.AF_INET

144

family = socket.AF_INET

145

try:

145

try:

146

s = socket.socket(family, socket.SOCK_STREAM)

146

s = socket.socket(family, socket.SOCK_STREAM)

147

s.bind(('localhost', port))

147

s.bind(('localhost', port))

148

s.close()

148

s.close()

149

return True

149

return True

150

except socket.error as exc:

150

except socket.error as exc:

151

if exc.errno not in (errno.EADDRINUSE, errno.EADDRNOTAVAIL,

151

if exc.errno not in (errno.EADDRINUSE, errno.EADDRNOTAVAIL,

152

errno.EPROTONOSUPPORT):

152

errno.EPROTONOSUPPORT):

153

raise

153

raise

154

return False

154

return False

155

156

closefds = os.name == 'posix'

156

closefds = os.name == 'posix'

157

def Popen4(cmd, wd, timeout, env=None):

157

def Popen4(cmd, wd, timeout, env=None):

158

processlock.acquire()

158

processlock.acquire()

159

p = subprocess.Popen(cmd, shell=True, bufsize=-1, cwd=wd, env=env,

159

p = subprocess.Popen(cmd, shell=True, bufsize=-1, cwd=wd, env=env,

160

close_fds=closefds,

160

close_fds=closefds,

161

stdin=subprocess.PIPE, stdout=subprocess.PIPE,

161

stdin=subprocess.PIPE, stdout=subprocess.PIPE,

162

stderr=subprocess.STDOUT)

162

stderr=subprocess.STDOUT)

163

processlock.release()

163

processlock.release()

164

165

p.fromchild = p.stdout

165

p.fromchild = p.stdout

166

p.tochild = p.stdin

166

p.tochild = p.stdin

167

p.childerr = p.stderr

167

p.childerr = p.stderr

168

169

p.timeout = False

169

p.timeout = False

170

if timeout:

170

if timeout:

171

def t():

171

def t():

172

start = time.time()

172

start = time.time()

173

while time.time() - start < timeout and p.returncode is None:

173

while time.time() - start < timeout and p.returncode is None:

174

time.sleep(.1)

174

time.sleep(.1)

175

p.timeout = True

175

p.timeout = True

176

if p.returncode is None:

176

if p.returncode is None:

177

terminate(p)

177

terminate(p)

178

threading.Thread(target=t).start()

178

threading.Thread(target=t).start()

179

180

return p

180

return p

181

182

PYTHON = _bytespath(sys.executable.replace('\\', '/'))

182

PYTHON = _bytespath(sys.executable.replace('\\', '/'))

183

IMPL_PATH = b'PYTHONPATH'

183

IMPL_PATH = b'PYTHONPATH'

184

if 'java' in sys.platform:

184

if 'java' in sys.platform:

185

IMPL_PATH = b'JYTHONPATH'

185

IMPL_PATH = b'JYTHONPATH'

186

187

defaults = {

187

defaults = {

188

'jobs': ('HGTEST_JOBS', 1),

188

'jobs': ('HGTEST_JOBS', 1),

189

'timeout': ('HGTEST_TIMEOUT', 180),

189

'timeout': ('HGTEST_TIMEOUT', 180),

190

'slowtimeout': ('HGTEST_SLOWTIMEOUT', 500),

190

'slowtimeout': ('HGTEST_SLOWTIMEOUT', 500),

191

'port': ('HGTEST_PORT', 20059),

191

'port': ('HGTEST_PORT', 20059),

192

'shell': ('HGTEST_SHELL', 'sh'),

192

'shell': ('HGTEST_SHELL', 'sh'),

193

}

193

}

194

195

def canonpath(path):

195

def canonpath(path):

196

return os.path.realpath(os.path.expanduser(path))

196

return os.path.realpath(os.path.expanduser(path))

197

198

def parselistfiles(files, listtype, warn=True):

198

def parselistfiles(files, listtype, warn=True):

199

entries = dict()

199

entries = dict()

200

for filename in files:

200

for filename in files:

201

try:

201

try:

202

path = os.path.expanduser(os.path.expandvars(filename))

202

path = os.path.expanduser(os.path.expandvars(filename))

203

f = open(path, "rb")

203

f = open(path, "rb")

204

except IOError as err:

204

except IOError as err:

205

if err.errno != errno.ENOENT:

205

if err.errno != errno.ENOENT:

206

raise

206

raise

207

if warn:

207

if warn:

208

print("warning: no such %s file: %s" % (listtype, filename))

208

print("warning: no such %s file: %s" % (listtype, filename))

209

continue

209

continue

210

211

for line in f.readlines():

211

for line in f.readlines():

212

line = line.split(b'#', 1)[0].strip()

212

line = line.split(b'#', 1)[0].strip()

213

if line:

213

if line:

214

entries[line] = filename

214

entries[line] = filename

215

216

f.close()

216

f.close()

217

return entries

217

return entries

218

219

def getparser():

219

def getparser():

220

"""Obtain the OptionParser used by the CLI."""

220

"""Obtain the OptionParser used by the CLI."""

221

parser = optparse.OptionParser("%prog [options] [tests]")

221

parser = optparse.OptionParser("%prog [options] [tests]")

222

223

# keep these sorted

223

# keep these sorted

224

parser.add_option("--blacklist", action="append",

224

parser.add_option("--blacklist", action="append",

225

help="skip tests listed in the specified blacklist file")

225

help="skip tests listed in the specified blacklist file")

226

parser.add_option("--whitelist", action="append",

226

parser.add_option("--whitelist", action="append",

227

help="always run tests listed in the specified whitelist file")

227

help="always run tests listed in the specified whitelist file")

228

parser.add_option("--changed", type="string",

228

parser.add_option("--changed", type="string",

229

help="run tests that are changed in parent rev or working directory")

229

help="run tests that are changed in parent rev or working directory")

230

parser.add_option("-C", "--annotate", action="store_true",

230

parser.add_option("-C", "--annotate", action="store_true",

231

help="output files annotated with coverage")

231

help="output files annotated with coverage")

232

parser.add_option("-c", "--cover", action="store_true",

232

parser.add_option("-c", "--cover", action="store_true",

233

help="print a test coverage report")

233

help="print a test coverage report")

234

parser.add_option("-d", "--debug", action="store_true",

234

parser.add_option("-d", "--debug", action="store_true",

235

help="debug mode: write output of test scripts to console"

235

help="debug mode: write output of test scripts to console"

236

" rather than capturing and diffing it (disables timeout)")

236

" rather than capturing and diffing it (disables timeout)")

237

parser.add_option("-f", "--first", action="store_true",

237

parser.add_option("-f", "--first", action="store_true",

238

help="exit on the first test failure")

238

help="exit on the first test failure")

239

parser.add_option("-H", "--htmlcov", action="store_true",

239

parser.add_option("-H", "--htmlcov", action="store_true",

240

help="create an HTML report of the coverage of the files")

240

help="create an HTML report of the coverage of the files")

241

parser.add_option("-i", "--interactive", action="store_true",

241

parser.add_option("-i", "--interactive", action="store_true",

242

help="prompt to accept changed output")

242

help="prompt to accept changed output")

243

parser.add_option("-j", "--jobs", type="int",

243

parser.add_option("-j", "--jobs", type="int",

244

help="number of jobs to run in parallel"

244

help="number of jobs to run in parallel"

245

" (default: $%s or %d)" % defaults['jobs'])

245

" (default: $%s or %d)" % defaults['jobs'])

246

parser.add_option("--keep-tmpdir", action="store_true",

246

parser.add_option("--keep-tmpdir", action="store_true",

247

help="keep temporary directory after running tests")

247

help="keep temporary directory after running tests")

248

parser.add_option("-k", "--keywords",

248

parser.add_option("-k", "--keywords",

249

help="run tests matching keywords")

249

help="run tests matching keywords")

250

parser.add_option("-l", "--local", action="store_true",

250

parser.add_option("-l", "--local", action="store_true",

251

help="shortcut for --with-hg=<testdir>/../hg, "

251

help="shortcut for --with-hg=<testdir>/../hg, "

252

"and --with-chg=<testdir>/../contrib/chg/chg if --chg is set")

252

"and --with-chg=<testdir>/../contrib/chg/chg if --chg is set")

253

parser.add_option("--loop", action="store_true",

253

parser.add_option("--loop", action="store_true",

254

help="loop tests repeatedly")

254

help="loop tests repeatedly")

255

parser.add_option("--runs-per-test", type="int", dest="runs_per_test",

255

parser.add_option("--runs-per-test", type="int", dest="runs_per_test",

256

help="run each test N times (default=1)", default=1)

256

help="run each test N times (default=1)", default=1)

257

parser.add_option("-n", "--nodiff", action="store_true",

257

parser.add_option("-n", "--nodiff", action="store_true",

258

help="skip showing test changes")

258

help="skip showing test changes")

259

parser.add_option("-p", "--port", type="int",

259

parser.add_option("-p", "--port", type="int",

260

help="port on which servers should listen"

260

help="port on which servers should listen"

261

" (default: $%s or %d)" % defaults['port'])

261

" (default: $%s or %d)" % defaults['port'])

262

parser.add_option("--compiler", type="string",

262

parser.add_option("--compiler", type="string",

263

help="compiler to build with")

263

help="compiler to build with")

264

parser.add_option("--pure", action="store_true",

264

parser.add_option("--pure", action="store_true",

265

help="use pure Python code instead of C extensions")

265

help="use pure Python code instead of C extensions")

266

parser.add_option("-R", "--restart", action="store_true",

266

parser.add_option("-R", "--restart", action="store_true",

267

help="restart at last error")

267

help="restart at last error")

268

parser.add_option("-r", "--retest", action="store_true",

268

parser.add_option("-r", "--retest", action="store_true",

269

help="retest failed tests")

269

help="retest failed tests")

270

parser.add_option("-S", "--noskips", action="store_true",

270

parser.add_option("-S", "--noskips", action="store_true",

271

help="don't report skip tests verbosely")

271

help="don't report skip tests verbosely")

272

parser.add_option("--shell", type="string",

272

parser.add_option("--shell", type="string",

273

help="shell to use (default: $%s or %s)" % defaults['shell'])

273

help="shell to use (default: $%s or %s)" % defaults['shell'])

274

parser.add_option("-t", "--timeout", type="int",

274

parser.add_option("-t", "--timeout", type="int",

275

help="kill errant tests after TIMEOUT seconds"

275

help="kill errant tests after TIMEOUT seconds"

276

" (default: $%s or %d)" % defaults['timeout'])

276

" (default: $%s or %d)" % defaults['timeout'])

277

parser.add_option("--slowtimeout", type="int",

277

parser.add_option("--slowtimeout", type="int",

278

help="kill errant slow tests after SLOWTIMEOUT seconds"

278

help="kill errant slow tests after SLOWTIMEOUT seconds"

279

" (default: $%s or %d)" % defaults['slowtimeout'])

279

" (default: $%s or %d)" % defaults['slowtimeout'])

280

parser.add_option("--time", action="store_true",

280

parser.add_option("--time", action="store_true",

281

help="time how long each test takes")

281

help="time how long each test takes")

282

parser.add_option("--json", action="store_true",

282

parser.add_option("--json", action="store_true",

283

help="store test result data in 'report.json' file")

283

help="store test result data in 'report.json' file")

284

parser.add_option("--tmpdir", type="string",

284

parser.add_option("--tmpdir", type="string",

285

help="run tests in the given temporary directory"

285

help="run tests in the given temporary directory"

286

" (implies --keep-tmpdir)")

286

" (implies --keep-tmpdir)")

287

parser.add_option("-v", "--verbose", action="store_true",

287

parser.add_option("-v", "--verbose", action="store_true",

288

help="output verbose messages")

288

help="output verbose messages")

289

parser.add_option("--xunit", type="string",

289

parser.add_option("--xunit", type="string",

290

help="record xunit results at specified path")

290

help="record xunit results at specified path")

291

parser.add_option("--view", type="string",

291

parser.add_option("--view", type="string",

292

help="external diff viewer")

292

help="external diff viewer")

293

parser.add_option("--with-hg", type="string",

293

parser.add_option("--with-hg", type="string",

294

metavar="HG",

294

metavar="HG",

295

help="test using specified hg script rather than a "

295

help="test using specified hg script rather than a "

296

"temporary installation")

296

"temporary installation")

297

parser.add_option("--chg", action="store_true",

297

parser.add_option("--chg", action="store_true",

298

help="install and use chg wrapper in place of hg")

298

help="install and use chg wrapper in place of hg")

299

parser.add_option("--with-chg", metavar="CHG",

299

parser.add_option("--with-chg", metavar="CHG",

300

help="use specified chg wrapper in place of hg")

300

help="use specified chg wrapper in place of hg")

301

parser.add_option("--ipv6", action="store_true",

301

parser.add_option("--ipv6", action="store_true",

302

help="prefer IPv6 to IPv4 for network related tests")

302

help="prefer IPv6 to IPv4 for network related tests")

303

parser.add_option("-3", "--py3k-warnings", action="store_true",

303

parser.add_option("-3", "--py3k-warnings", action="store_true",

304

help="enable Py3k warnings on Python 2.6+")

304

help="enable Py3k warnings on Python 2.6+")

305

# This option should be deleted once test-check-py3-compat.t and other

305

# This option should be deleted once test-check-py3-compat.t and other

306

# Python 3 tests run with Python 3.

306

# Python 3 tests run with Python 3.

307

parser.add_option("--with-python3", metavar="PYTHON3",

307

parser.add_option("--with-python3", metavar="PYTHON3",

308

help="Python 3 interpreter (if running under Python 2)"

308

help="Python 3 interpreter (if running under Python 2)"

309

" (TEMPORARY)")

309

" (TEMPORARY)")

310

parser.add_option('--extra-config-opt', action="append",

310

parser.add_option('--extra-config-opt', action="append",

311

help='set the given config opt in the test hgrc')

311

help='set the given config opt in the test hgrc')

312

parser.add_option('--random', action="store_true",

312

parser.add_option('--random', action="store_true",

313

help='run tests in random order')

313

help='run tests in random order')

314

parser.add_option('--profile-runner', action='store_true',

314

parser.add_option('--profile-runner', action='store_true',

315

help='run statprof on run-tests')

315

help='run statprof on run-tests')

316

parser.add_option('--allow-slow-tests', action='store_true',

316

parser.add_option('--allow-slow-tests', action='store_true',

317

help='allow extremely slow tests')

317

help='allow extremely slow tests')

318

parser.add_option('--showchannels', action='store_true',

318

parser.add_option('--showchannels', action='store_true',

319

help='show scheduling channels')

319

help='show scheduling channels')

320

parser.add_option('--known-good-rev', type="string",

320

parser.add_option('--known-good-rev', type="string",

321

metavar="known_good_rev",

321

metavar="known_good_rev",

322

help=("Automatically bisect any failures using this "

322

help=("Automatically bisect any failures using this "

323

"revision as a known-good revision."))

323

"revision as a known-good revision."))

324

325

for option, (envvar, default) in defaults.items():

325

for option, (envvar, default) in defaults.items():

326

defaults[option] = type(default)(os.environ.get(envvar, default))

326

defaults[option] = type(default)(os.environ.get(envvar, default))

327

parser.set_defaults(**defaults)

327

parser.set_defaults(**defaults)

328

329

return parser

329

return parser

330

331

def parseargs(args, parser):

331

def parseargs(args, parser):

332

"""Parse arguments with our OptionParser and validate results."""

332

"""Parse arguments with our OptionParser and validate results."""

333

(options, args) = parser.parse_args(args)

333

(options, args) = parser.parse_args(args)

334

335

# jython is always pure

335

# jython is always pure

336

if 'java' in sys.platform or '__pypy__' in sys.modules:

336

if 'java' in sys.platform or '__pypy__' in sys.modules:

337

options.pure = True

337

options.pure = True

338

339

if options.with_hg:

339

if options.with_hg:

340

options.with_hg = canonpath(_bytespath(options.with_hg))

340

options.with_hg = canonpath(_bytespath(options.with_hg))

341

if not (os.path.isfile(options.with_hg) and

341

if not (os.path.isfile(options.with_hg) and

342

os.access(options.with_hg, os.X_OK)):

342

os.access(options.with_hg, os.X_OK)):

343

parser.error('--with-hg must specify an executable hg script')

343

parser.error('--with-hg must specify an executable hg script')

344

if not os.path.basename(options.with_hg) == b'hg':

344

if not os.path.basename(options.with_hg) == b'hg':

345

sys.stderr.write('warning: --with-hg should specify an hg script\n')

345

sys.stderr.write('warning: --with-hg should specify an hg script\n')

346

if options.local:

346

if options.local:

347

testdir = os.path.dirname(_bytespath(canonpath(sys.argv[0])))

347

testdir = os.path.dirname(_bytespath(canonpath(sys.argv[0])))

348

reporootdir = os.path.dirname(testdir)

348

reporootdir = os.path.dirname(testdir)

349

pathandattrs = [(b'hg', 'with_hg')]

349

pathandattrs = [(b'hg', 'with_hg')]

350

if options.chg:

350

if options.chg:

351

pathandattrs.append((b'contrib/chg/chg', 'with_chg'))

351

pathandattrs.append((b'contrib/chg/chg', 'with_chg'))

352

for relpath, attr in pathandattrs:

352

for relpath, attr in pathandattrs:

353

binpath = os.path.join(reporootdir, relpath)

353

binpath = os.path.join(reporootdir, relpath)

354

if os.name != 'nt' and not os.access(binpath, os.X_OK):

354

if os.name != 'nt' and not os.access(binpath, os.X_OK):

355

parser.error('--local specified, but %r not found or '

355

parser.error('--local specified, but %r not found or '

356

'not executable' % binpath)

356

'not executable' % binpath)

357

setattr(options, attr, binpath)

357

setattr(options, attr, binpath)

358

359

if (options.chg or options.with_chg) and os.name == 'nt':

359

if (options.chg or options.with_chg) and os.name == 'nt':

360

parser.error('chg does not work on %s' % os.name)

360

parser.error('chg does not work on %s' % os.name)

361

if options.with_chg:

361

if options.with_chg:

362

options.chg = False # no installation to temporary location

362

options.chg = False # no installation to temporary location

363

options.with_chg = canonpath(_bytespath(options.with_chg))

363

options.with_chg = canonpath(_bytespath(options.with_chg))

364

if not (os.path.isfile(options.with_chg) and

364

if not (os.path.isfile(options.with_chg) and

365

os.access(options.with_chg, os.X_OK)):

365

os.access(options.with_chg, os.X_OK)):

366

parser.error('--with-chg must specify a chg executable')

366

parser.error('--with-chg must specify a chg executable')

367

if options.chg and options.with_hg:

367

if options.chg and options.with_hg:

368

# chg shares installation location with hg

368

# chg shares installation location with hg

369

parser.error('--chg does not work when --with-hg is specified '

369

parser.error('--chg does not work when --with-hg is specified '

370

'(use --with-chg instead)')

370

'(use --with-chg instead)')

371

372

global useipv6

372

global useipv6

373

if options.ipv6:

373

if options.ipv6:

374

useipv6 = checksocketfamily('AF_INET6')

374

useipv6 = checksocketfamily('AF_INET6')

375

else:

375

else:

376

# only use IPv6 if IPv4 is unavailable and IPv6 is available

376

# only use IPv6 if IPv4 is unavailable and IPv6 is available

377

useipv6 = ((not checksocketfamily('AF_INET'))

377

useipv6 = ((not checksocketfamily('AF_INET'))

378

and checksocketfamily('AF_INET6'))

378

and checksocketfamily('AF_INET6'))

379

380

options.anycoverage = options.cover or options.annotate or options.htmlcov

380

options.anycoverage = options.cover or options.annotate or options.htmlcov

381

if options.anycoverage:

381

if options.anycoverage:

382

try:

382

try:

383

import coverage

383

import coverage

384

covver = version.StrictVersion(coverage.__version__).version

384

covver = version.StrictVersion(coverage.__version__).version

385

if covver < (3, 3):

385

if covver < (3, 3):

386

parser.error('coverage options require coverage 3.3 or later')

386

parser.error('coverage options require coverage 3.3 or later')

387

except ImportError:

387

except ImportError:

388

parser.error('coverage options now require the coverage package')

388

parser.error('coverage options now require the coverage package')

389

390

if options.anycoverage and options.local:

390

if options.anycoverage and options.local:

391

# this needs some path mangling somewhere, I guess

391

# this needs some path mangling somewhere, I guess

392

parser.error("sorry, coverage options do not work when --local "

392

parser.error("sorry, coverage options do not work when --local "

393

"is specified")

393

"is specified")

394

395

if options.anycoverage and options.with_hg:

395

if options.anycoverage and options.with_hg:

396

parser.error("sorry, coverage options do not work when --with-hg "

396

parser.error("sorry, coverage options do not work when --with-hg "

397

"is specified")

397

"is specified")

398

399

global verbose

399

global verbose

400

if options.verbose:

400

if options.verbose:

401

verbose = ''

401

verbose = ''

402

403

if options.tmpdir:

403

if options.tmpdir:

404

options.tmpdir = canonpath(options.tmpdir)

404

options.tmpdir = canonpath(options.tmpdir)

405

406

if options.jobs < 1:

406

if options.jobs < 1:

407

parser.error('--jobs must be positive')

407

parser.error('--jobs must be positive')

408

if options.interactive and options.debug:

408

if options.interactive and options.debug:

409

parser.error("-i/--interactive and -d/--debug are incompatible")

409

parser.error("-i/--interactive and -d/--debug are incompatible")

410

if options.debug:

410

if options.debug:

411

if options.timeout != defaults['timeout']:

411

if options.timeout != defaults['timeout']:

412

sys.stderr.write(

412

sys.stderr.write(

413

'warning: --timeout option ignored with --debug\n')

413

'warning: --timeout option ignored with --debug\n')

414

if options.slowtimeout != defaults['slowtimeout']:

414

if options.slowtimeout != defaults['slowtimeout']:

415

sys.stderr.write(

415

sys.stderr.write(

416

'warning: --slowtimeout option ignored with --debug\n')

416

'warning: --slowtimeout option ignored with --debug\n')

417

options.timeout = 0

417

options.timeout = 0

418

options.slowtimeout = 0

418

options.slowtimeout = 0

419

if options.py3k_warnings:

419

if options.py3k_warnings:

420

if PYTHON3:

420

if PYTHON3:

421

parser.error(

421

parser.error(

422

'--py3k-warnings can only be used on Python 2.6 and 2.7')

422

'--py3k-warnings can only be used on Python 2.6 and 2.7')

423

if options.with_python3:

423

if options.with_python3:

424

if PYTHON3:

424

if PYTHON3:

425

parser.error('--with-python3 cannot be used when executing with '

425

parser.error('--with-python3 cannot be used when executing with '

426

'Python 3')

426

'Python 3')

427

428

options.with_python3 = canonpath(options.with_python3)

428

options.with_python3 = canonpath(options.with_python3)

429

# Verify Python3 executable is acceptable.

429

# Verify Python3 executable is acceptable.

430

proc = subprocess.Popen([options.with_python3, b'--version'],

430

proc = subprocess.Popen([options.with_python3, b'--version'],

431

stdout=subprocess.PIPE,

431

stdout=subprocess.PIPE,

432

stderr=subprocess.STDOUT)

432

stderr=subprocess.STDOUT)

433

out, _err = proc.communicate()

433

out, _err = proc.communicate()

434

ret = proc.wait()

434

ret = proc.wait()

435

if ret != 0:

435

if ret != 0:

436

parser.error('could not determine version of python 3')

436

parser.error('could not determine version of python 3')

437

if not out.startswith('Python '):

437

if not out.startswith('Python '):

438

parser.error('unexpected output from python3 --version: %s' %

438

parser.error('unexpected output from python3 --version: %s' %

439

out)

439

out)

440

vers = version.LooseVersion(out[len('Python '):])

440

vers = version.LooseVersion(out[len('Python '):])

441

if vers < version.LooseVersion('3.5.0'):

441

if vers < version.LooseVersion('3.5.0'):

442

parser.error('--with-python3 version must be 3.5.0 or greater; '

442

parser.error('--with-python3 version must be 3.5.0 or greater; '

443

'got %s' % out)

443

'got %s' % out)

444

445

if options.blacklist:

445

if options.blacklist:

446

options.blacklist = parselistfiles(options.blacklist, 'blacklist')

446

options.blacklist = parselistfiles(options.blacklist, 'blacklist')

447

if options.whitelist:

447

if options.whitelist:

448

options.whitelisted = parselistfiles(options.whitelist, 'whitelist')

448

options.whitelisted = parselistfiles(options.whitelist, 'whitelist')

449

else:

449

else:

450

options.whitelisted = {}

450

options.whitelisted = {}

451

452

if options.showchannels:

452

if options.showchannels:

453

options.nodiff = True

453

options.nodiff = True

454

455

return (options, args)

455

return (options, args)

456

457

def rename(src, dst):

457

def rename(src, dst):

458

"""Like os.rename(), trade atomicity and opened files friendliness

458

"""Like os.rename(), trade atomicity and opened files friendliness

459

for existing destination support.

459

for existing destination support.

460

"""

460

"""

461

shutil.copy(src, dst)

461

shutil.copy(src, dst)

462

os.remove(src)

462

os.remove(src)

463

464

_unified_diff = difflib.unified_diff

464

_unified_diff = difflib.unified_diff

465

if PYTHON3:

465

if PYTHON3:

466

import functools

466

import functools

467

_unified_diff = functools.partial(difflib.diff_bytes, difflib.unified_diff)

467

_unified_diff = functools.partial(difflib.diff_bytes, difflib.unified_diff)

468

469

def getdiff(expected, output, ref, err):

469

def getdiff(expected, output, ref, err):

470

servefail = False

470

servefail = False

471

lines = []

471

lines = []

472

for line in _unified_diff(expected, output, ref, err):

472

for line in _unified_diff(expected, output, ref, err):

473

if line.startswith(b'+++') or line.startswith(b'---'):

473

if line.startswith(b'+++') or line.startswith(b'---'):

474

line = line.replace(b'\\', b'/')

474

line = line.replace(b'\\', b'/')

475

if line.endswith(b' \n'):

475

if line.endswith(b' \n'):

476

line = line[:-2] + b'\n'

476

line = line[:-2] + b'\n'

477

lines.append(line)

477

lines.append(line)

478

if not servefail and line.startswith(

478

if not servefail and line.startswith(

479

b'+ abort: child process failed to start'):

479

b'+ abort: child process failed to start'):

480

servefail = True

480

servefail = True

481

482

return servefail, lines

482

return servefail, lines

483

484

verbose = False

484

verbose = False

485

def vlog(*msg):

485

def vlog(*msg):

486

"""Log only when in verbose mode."""

486

"""Log only when in verbose mode."""

487

if verbose is False:

487

if verbose is False:

488

return

488

return

489

490

return log(*msg)

490

return log(*msg)

491

492

# Bytes that break XML even in a CDATA block: control characters 0-31

492

# Bytes that break XML even in a CDATA block: control characters 0-31

493

# sans \t, \n and \r

493

# sans \t, \n and \r

494

CDATA_EVIL = re.compile(br"[\000-\010\013\014\016-\037]")

494

CDATA_EVIL = re.compile(br"[\000-\010\013\014\016-\037]")

495

496

# Match feature conditionalized output lines in the form, capturing the feature

496

# Match feature conditionalized output lines in the form, capturing the feature

497

# list in group 2, and the preceeding line output in group 1:

497

# list in group 2, and the preceeding line output in group 1:

498

#

498

#

499

# output..output (feature !)\n

499

# output..output (feature !)\n

500

optline = re.compile(b'(.+) $(.+?) !$\n$')

500

optline = re.compile(b'(.+) $(.+?) !$\n$')

501

502

def cdatasafe(data):

502

def cdatasafe(data):

503

"""Make a string safe to include in a CDATA block.

503

"""Make a string safe to include in a CDATA block.

504

505

Certain control characters are illegal in a CDATA block, and

505

Certain control characters are illegal in a CDATA block, and

506

there's no way to include a ]]> in a CDATA either. This function

506

there's no way to include a ]]> in a CDATA either. This function

507

replaces illegal bytes with ? and adds a space between the ]] so

507

replaces illegal bytes with ? and adds a space between the ]] so

508

that it won't break the CDATA block.

508

that it won't break the CDATA block.

509

"""

509

"""

510

return CDATA_EVIL.sub(b'?', data).replace(b']]>', b'] ]>')

510

return CDATA_EVIL.sub(b'?', data).replace(b']]>', b'] ]>')

511

512

def log(*msg):

512

def log(*msg):

513

"""Log something to stdout.

513

"""Log something to stdout.

514

515

Arguments are strings to print.

515

Arguments are strings to print.

516

"""

516

"""

517

with iolock:

517

with iolock:

518

if verbose:

518

if verbose:

519

print(verbose, end=' ')

519

print(verbose, end=' ')

520

for m in msg:

520

for m in msg:

521

print(m, end=' ')

521

print(m, end=' ')

522

print()

522

print()

523

sys.stdout.flush()

523

sys.stdout.flush()

524

525

def terminate(proc):

525

def terminate(proc):

526

"""Terminate subprocess (with fallback for Python versions < 2.6)"""

526

"""Terminate subprocess"""

527

vlog('# Terminating process %d' % proc.pid)

527

vlog('# Terminating process %d' % proc.pid)

528

try:

528

try:

529

getattr(proc, 'terminate', lambda : os.kill(proc.pid, signal.SIGTERM))()

529

proc.terminate()

530

except OSError:

530

except OSError:

531

pass

531

pass

532

533

def killdaemons(pidfile):

533

def killdaemons(pidfile):

534

import killdaemons as killmod

534

import killdaemons as killmod

535

return killmod.killdaemons(pidfile, tryhard=False, remove=True,

535

return killmod.killdaemons(pidfile, tryhard=False, remove=True,

536

logfn=vlog)

536

logfn=vlog)

537

538

class Test(unittest.TestCase):

538

class Test(unittest.TestCase):

539

"""Encapsulates a single, runnable test.

539

"""Encapsulates a single, runnable test.

540

541

While this class conforms to the unittest.TestCase API, it differs in that

541

While this class conforms to the unittest.TestCase API, it differs in that

542

instances need to be instantiated manually. (Typically, unittest.TestCase

542

instances need to be instantiated manually. (Typically, unittest.TestCase

543

classes are instantiated automatically by scanning modules.)

543

classes are instantiated automatically by scanning modules.)

544

"""

544

"""

545

546

# Status code reserved for skipped tests (used by hghave).

546

# Status code reserved for skipped tests (used by hghave).

547

SKIPPED_STATUS = 80

547

SKIPPED_STATUS = 80

548

549

def __init__(self, path, tmpdir, keeptmpdir=False,

549

def __init__(self, path, tmpdir, keeptmpdir=False,

550

debug=False,

550

debug=False,

551

timeout=defaults['timeout'],

551

timeout=defaults['timeout'],

552

startport=defaults['port'], extraconfigopts=None,

552

startport=defaults['port'], extraconfigopts=None,

553

py3kwarnings=False, shell=None, hgcommand=None,

553

py3kwarnings=False, shell=None, hgcommand=None,

554

slowtimeout=defaults['slowtimeout'], usechg=False,

554

slowtimeout=defaults['slowtimeout'], usechg=False,

555

useipv6=False):

555

useipv6=False):

556

"""Create a test from parameters.

556

"""Create a test from parameters.

557

558

path is the full path to the file defining the test.

558

path is the full path to the file defining the test.

559

560

tmpdir is the main temporary directory to use for this test.

560

tmpdir is the main temporary directory to use for this test.

561

562

keeptmpdir determines whether to keep the test's temporary directory

562

keeptmpdir determines whether to keep the test's temporary directory

563

after execution. It defaults to removal (False).

563

after execution. It defaults to removal (False).

564

565

debug mode will make the test execute verbosely, with unfiltered

565

debug mode will make the test execute verbosely, with unfiltered

566

output.

566

output.

567

568

timeout controls the maximum run time of the test. It is ignored when

568

timeout controls the maximum run time of the test. It is ignored when

569

debug is True. See slowtimeout for tests with #require slow.

569

debug is True. See slowtimeout for tests with #require slow.

570

571

slowtimeout overrides timeout if the test has #require slow.

571

slowtimeout overrides timeout if the test has #require slow.

572

573

startport controls the starting port number to use for this test. Each

573

startport controls the starting port number to use for this test. Each

574

test will reserve 3 port numbers for execution. It is the caller's

574

test will reserve 3 port numbers for execution. It is the caller's

575

responsibility to allocate a non-overlapping port range to Test

575

responsibility to allocate a non-overlapping port range to Test

576

instances.

576

instances.

577

578

extraconfigopts is an iterable of extra hgrc config options. Values

578

extraconfigopts is an iterable of extra hgrc config options. Values

579

must have the form "key=value" (something understood by hgrc). Values

579

must have the form "key=value" (something understood by hgrc). Values

580

of the form "foo.key=value" will result in "[foo] key=value".

580

of the form "foo.key=value" will result in "[foo] key=value".

581

582

py3kwarnings enables Py3k warnings.

582

py3kwarnings enables Py3k warnings.

583

584

shell is the shell to execute tests in.

584

shell is the shell to execute tests in.

585

"""

585

"""

586

self.path = path

586

self.path = path

587

self.bname = os.path.basename(path)

587

self.bname = os.path.basename(path)

588

self.name = _strpath(self.bname)

588

self.name = _strpath(self.bname)

589

self._testdir = os.path.dirname(path)

589

self._testdir = os.path.dirname(path)

590

self.errpath = os.path.join(self._testdir, b'%s.err' % self.bname)

590

self.errpath = os.path.join(self._testdir, b'%s.err' % self.bname)

591

592

self._threadtmp = tmpdir

592

self._threadtmp = tmpdir

593

self._keeptmpdir = keeptmpdir

593

self._keeptmpdir = keeptmpdir

594

self._debug = debug

594

self._debug = debug

595

self._timeout = timeout

595

self._timeout = timeout

596

self._slowtimeout = slowtimeout

596

self._slowtimeout = slowtimeout

597

self._startport = startport

597

self._startport = startport

598

self._extraconfigopts = extraconfigopts or []

598

self._extraconfigopts = extraconfigopts or []

599

self._py3kwarnings = py3kwarnings

599

self._py3kwarnings = py3kwarnings

600

self._shell = _bytespath(shell)

600

self._shell = _bytespath(shell)

601

self._hgcommand = hgcommand or b'hg'

601

self._hgcommand = hgcommand or b'hg'

602

self._usechg = usechg

602

self._usechg = usechg

603

self._useipv6 = useipv6

603

self._useipv6 = useipv6

604

605

self._aborted = False

605

self._aborted = False

606

self._daemonpids = []

606

self._daemonpids = []

607

self._finished = None

607

self._finished = None

608

self._ret = None

608

self._ret = None

609

self._out = None

609

self._out = None

610

self._skipped = None

610

self._skipped = None

611

self._testtmp = None

611

self._testtmp = None

612

self._chgsockdir = None

612

self._chgsockdir = None

613

614

# If we're not in --debug mode and reference output file exists,

614

# If we're not in --debug mode and reference output file exists,

615

# check test output against it.

615

# check test output against it.

616

if debug:

616

if debug:

617

self._refout = None # to match "out is None"

617

self._refout = None # to match "out is None"

618

elif os.path.exists(self.refpath):

618

elif os.path.exists(self.refpath):

619

f = open(self.refpath, 'rb')

619

f = open(self.refpath, 'rb')

620

self._refout = f.read().splitlines(True)

620

self._refout = f.read().splitlines(True)

621

f.close()

621

f.close()

622

else:

622

else:

623

self._refout = []

623

self._refout = []

624

625

# needed to get base class __repr__ running

625

# needed to get base class __repr__ running

626

@property

626

@property

627

def _testMethodName(self):

627

def _testMethodName(self):

628

return self.name

628

return self.name

629

630

def __str__(self):

630

def __str__(self):

631

return self.name

631

return self.name

632

633

def shortDescription(self):

633

def shortDescription(self):

634

return self.name

634

return self.name

635

636

def setUp(self):

636

def setUp(self):

637

"""Tasks to perform before run()."""

637

"""Tasks to perform before run()."""

638

self._finished = False

638

self._finished = False

639

self._ret = None

639

self._ret = None

640

self._out = None

640

self._out = None

641

self._skipped = None

641

self._skipped = None

642

643

try:

643

try:

644

os.mkdir(self._threadtmp)

644

os.mkdir(self._threadtmp)

645

except OSError as e:

645

except OSError as e:

646

if e.errno != errno.EEXIST:

646

if e.errno != errno.EEXIST:

647

raise

647

raise

648

649

name = os.path.basename(self.path)

649

name = os.path.basename(self.path)

650

self._testtmp = os.path.join(self._threadtmp, name)

650

self._testtmp = os.path.join(self._threadtmp, name)

651

os.mkdir(self._testtmp)

651

os.mkdir(self._testtmp)

652

653

# Remove any previous output files.

653

# Remove any previous output files.

654

if os.path.exists(self.errpath):

654

if os.path.exists(self.errpath):

655

try:

655

try:

656

os.remove(self.errpath)

656

os.remove(self.errpath)

657

except OSError as e:

657

except OSError as e:

658

# We might have raced another test to clean up a .err

658

# We might have raced another test to clean up a .err

659

# file, so ignore ENOENT when removing a previous .err

659

# file, so ignore ENOENT when removing a previous .err

660

# file.

660

# file.

661

if e.errno != errno.ENOENT:

661

if e.errno != errno.ENOENT:

662

raise

662

raise

663

664

if self._usechg:

664

if self._usechg:

665

self._chgsockdir = os.path.join(self._threadtmp,

665

self._chgsockdir = os.path.join(self._threadtmp,

666

b'%s.chgsock' % name)

666

b'%s.chgsock' % name)

667

os.mkdir(self._chgsockdir)

667

os.mkdir(self._chgsockdir)

668

669

def run(self, result):

669

def run(self, result):

670

"""Run this test and report results against a TestResult instance."""

670

"""Run this test and report results against a TestResult instance."""

671

# This function is extremely similar to unittest.TestCase.run(). Once

671

# This function is extremely similar to unittest.TestCase.run(). Once

672

# we require Python 2.7 (or at least its version of unittest), this

672

# we require Python 2.7 (or at least its version of unittest), this

673

# function can largely go away.

673

# function can largely go away.

674

self._result = result

674

self._result = result

675

result.startTest(self)

675

result.startTest(self)

676

try:

676

try:

677

try:

677

try:

678

self.setUp()

678

self.setUp()

679

except (KeyboardInterrupt, SystemExit):

679

except (KeyboardInterrupt, SystemExit):

680

self._aborted = True

680

self._aborted = True

681

raise

681

raise

682

except Exception:

682

except Exception:

683

result.addError(self, sys.exc_info())

683

result.addError(self, sys.exc_info())

684

return

684

return

685

686

success = False

686

success = False

687

try:

687

try:

688

self.runTest()

688

self.runTest()

689

except KeyboardInterrupt:

689

except KeyboardInterrupt:

690

self._aborted = True

690

self._aborted = True

691

raise

691

raise

692

except SkipTest as e:

692

except SkipTest as e:

693

result.addSkip(self, str(e))

693

result.addSkip(self, str(e))

694

# The base class will have already counted this as a

694

# The base class will have already counted this as a

695

# test we "ran", but we want to exclude skipped tests

695

# test we "ran", but we want to exclude skipped tests

696

# from those we count towards those run.

696

# from those we count towards those run.

697

result.testsRun -= 1

697

result.testsRun -= 1

698

except IgnoreTest as e:

698

except IgnoreTest as e:

699

result.addIgnore(self, str(e))

699

result.addIgnore(self, str(e))

700

# As with skips, ignores also should be excluded from

700

# As with skips, ignores also should be excluded from

701

# the number of tests executed.

701

# the number of tests executed.

702

result.testsRun -= 1

702

result.testsRun -= 1

703

except WarnTest as e:

703

except WarnTest as e:

704

result.addWarn(self, str(e))

704

result.addWarn(self, str(e))

705

except ReportedTest as e:

705

except ReportedTest as e:

706

pass

706

pass

707

except self.failureException as e:

707

except self.failureException as e:

708

# This differs from unittest in that we don't capture

708

# This differs from unittest in that we don't capture

709

# the stack trace. This is for historical reasons and

709

# the stack trace. This is for historical reasons and

710

# this decision could be revisited in the future,

710

# this decision could be revisited in the future,

711

# especially for PythonTest instances.

711

# especially for PythonTest instances.

712

if result.addFailure(self, str(e)):

712

if result.addFailure(self, str(e)):

713

success = True

713

success = True

714

except Exception:

714

except Exception:

715

result.addError(self, sys.exc_info())

715

result.addError(self, sys.exc_info())

716

else:

716

else:

717

success = True

717

success = True

718

719

try:

719

try:

720

self.tearDown()

720

self.tearDown()

721

except (KeyboardInterrupt, SystemExit):

721

except (KeyboardInterrupt, SystemExit):

722

self._aborted = True

722

self._aborted = True

723

raise

723

raise

724

except Exception:

724

except Exception:

725

result.addError(self, sys.exc_info())

725

result.addError(self, sys.exc_info())

726

success = False

726

success = False

727

728

if success:

728

if success:

729

result.addSuccess(self)

729

result.addSuccess(self)

730

finally:

730

finally:

731

result.stopTest(self, interrupted=self._aborted)

731

result.stopTest(self, interrupted=self._aborted)

732

733

def runTest(self):

733

def runTest(self):

734

"""Run this test instance.

734

"""Run this test instance.

735

736

This will return a tuple describing the result of the test.

736

This will return a tuple describing the result of the test.

737

"""

737

"""

738

env = self._getenv()

738

env = self._getenv()

739

self._daemonpids.append(env['DAEMON_PIDS'])

739

self._daemonpids.append(env['DAEMON_PIDS'])

740

self._createhgrc(env['HGRCPATH'])

740

self._createhgrc(env['HGRCPATH'])

741

742

vlog('# Test', self.name)

742

vlog('# Test', self.name)

743

744

ret, out = self._run(env)

744

ret, out = self._run(env)

745

self._finished = True

745

self._finished = True

746

self._ret = ret

746

self._ret = ret

747

self._out = out

747

self._out = out

748

749

def describe(ret):

749

def describe(ret):

750

if ret < 0:

750

if ret < 0:

751

return 'killed by signal: %d' % -ret

751

return 'killed by signal: %d' % -ret

752

return 'returned error code %d' % ret

752

return 'returned error code %d' % ret

753

754

self._skipped = False

754

self._skipped = False

755

756

if ret == self.SKIPPED_STATUS:

756

if ret == self.SKIPPED_STATUS:

757

if out is None: # Debug mode, nothing to parse.

757

if out is None: # Debug mode, nothing to parse.

758

missing = ['unknown']

758

missing = ['unknown']

759

failed = None

759

failed = None

760

else:

760

else:

761

missing, failed = TTest.parsehghaveoutput(out)

761

missing, failed = TTest.parsehghaveoutput(out)

762

763

if not missing:

763

if not missing:

764

missing = ['skipped']

764

missing = ['skipped']

765

766

if failed:

766

if failed:

767

self.fail('hg have failed checking for %s' % failed[-1])

767

self.fail('hg have failed checking for %s' % failed[-1])

768

else:

768

else:

769

self._skipped = True

769

self._skipped = True

770

raise SkipTest(missing[-1])

770

raise SkipTest(missing[-1])

771

elif ret == 'timeout':

771

elif ret == 'timeout':

772

self.fail('timed out')

772

self.fail('timed out')

773

elif ret is False:

773

elif ret is False:

774

raise WarnTest('no result code from test')

774

raise WarnTest('no result code from test')

775

elif out != self._refout:

775

elif out != self._refout:

776

# Diff generation may rely on written .err file.

776

# Diff generation may rely on written .err file.

777

if (ret != 0 or out != self._refout) and not self._skipped \

777

if (ret != 0 or out != self._refout) and not self._skipped \

778

and not self._debug:

778

and not self._debug:

779

f = open(self.errpath, 'wb')

779

f = open(self.errpath, 'wb')

780

for line in out:

780

for line in out:

781

f.write(line)

781

f.write(line)

782

f.close()

782

f.close()

783

784

# The result object handles diff calculation for us.

784

# The result object handles diff calculation for us.

785

if self._result.addOutputMismatch(self, ret, out, self._refout):

785

if self._result.addOutputMismatch(self, ret, out, self._refout):

786

# change was accepted, skip failing

786

# change was accepted, skip failing

787

return

787

return

788

789

if ret:

789

if ret:

790

msg = 'output changed and ' + describe(ret)

790

msg = 'output changed and ' + describe(ret)

791

else:

791

else:

792

msg = 'output changed'

792

msg = 'output changed'

793

794

self.fail(msg)

794

self.fail(msg)

795

elif ret:

795

elif ret:

796

self.fail(describe(ret))

796

self.fail(describe(ret))

797

798

def tearDown(self):

798

def tearDown(self):

799

"""Tasks to perform after run()."""

799

"""Tasks to perform after run()."""

800

for entry in self._daemonpids:

800

for entry in self._daemonpids:

801

killdaemons(entry)

801

killdaemons(entry)

802

self._daemonpids = []

802

self._daemonpids = []

803

804

if self._keeptmpdir:

804

if self._keeptmpdir:

805

log('\nKeeping testtmp dir: %s\nKeeping threadtmp dir: %s' %

805

log('\nKeeping testtmp dir: %s\nKeeping threadtmp dir: %s' %

806

(self._testtmp.decode('utf-8'),

806

(self._testtmp.decode('utf-8'),

807

self._threadtmp.decode('utf-8')))

807

self._threadtmp.decode('utf-8')))

808

else:

808

else:

809

shutil.rmtree(self._testtmp, True)

809

shutil.rmtree(self._testtmp, True)

810

shutil.rmtree(self._threadtmp, True)

810

shutil.rmtree(self._threadtmp, True)

811

812

if self._usechg:

812

if self._usechg:

813

# chgservers will stop automatically after they find the socket

813

# chgservers will stop automatically after they find the socket

814

# files are deleted

814

# files are deleted

815

shutil.rmtree(self._chgsockdir, True)

815

shutil.rmtree(self._chgsockdir, True)

816

817

if (self._ret != 0 or self._out != self._refout) and not self._skipped \

817

if (self._ret != 0 or self._out != self._refout) and not self._skipped \

818

and not self._debug and self._out:

818

and not self._debug and self._out:

819

f = open(self.errpath, 'wb')

819

f = open(self.errpath, 'wb')

820

for line in self._out:

820

for line in self._out:

821

f.write(line)

821

f.write(line)

822

f.close()

822

f.close()

823

824

vlog("# Ret was:", self._ret, '(%s)' % self.name)

824

vlog("# Ret was:", self._ret, '(%s)' % self.name)

825

826

def _run(self, env):

826

def _run(self, env):

827

# This should be implemented in child classes to run tests.

827

# This should be implemented in child classes to run tests.

828

raise SkipTest('unknown test type')

828

raise SkipTest('unknown test type')

829

830

def abort(self):

830

def abort(self):

831

"""Terminate execution of this test."""

831

"""Terminate execution of this test."""

832

self._aborted = True

832

self._aborted = True

833

834

def _portmap(self, i):

834

def _portmap(self, i):

835

offset = b'' if i == 0 else b'%d' % i

835

offset = b'' if i == 0 else b'%d' % i

836

return (br':%d\b' % (self._startport + i), b':$HGPORT%s' % offset)

836

return (br':%d\b' % (self._startport + i), b':$HGPORT%s' % offset)

837

838

def _getreplacements(self):

838

def _getreplacements(self):

839

"""Obtain a mapping of text replacements to apply to test output.

839

"""Obtain a mapping of text replacements to apply to test output.

840

841

Test output needs to be normalized so it can be compared to expected

841

Test output needs to be normalized so it can be compared to expected

842

output. This function defines how some of that normalization will

842

output. This function defines how some of that normalization will

843

occur.

843

occur.

844

"""

844

"""

845

r = [

845

r = [

846

# This list should be parallel to defineport in _getenv

846

# This list should be parallel to defineport in _getenv

847

self._portmap(0),

847

self._portmap(0),

848

self._portmap(1),

848

self._portmap(1),

849

self._portmap(2),

849

self._portmap(2),

850

(br'(?m)^(saved backup bundle to .*\.hg)( $glob$)?$',

850

(br'(?m)^(saved backup bundle to .*\.hg)( $glob$)?$',

851

br'\1 (glob)'),

851

br'\1 (glob)'),

852

(br'([^0-9])%s' % re.escape(self._localip()), br'\1$LOCALIP'),

852

(br'([^0-9])%s' % re.escape(self._localip()), br'\1$LOCALIP'),

853

(br'\bHG_TXNID=TXN:[a-f0-9]{40}\b', br'HG_TXNID=TXN:$ID$'),

853

(br'\bHG_TXNID=TXN:[a-f0-9]{40}\b', br'HG_TXNID=TXN:$ID$'),

854

]

854

]

855

r.append((self._escapepath(self._testtmp), b'$TESTTMP'))

855

r.append((self._escapepath(self._testtmp), b'$TESTTMP'))

856

857

return r

857

return r

858

859

def _escapepath(self, p):

859

def _escapepath(self, p):

860

if os.name == 'nt':

860

if os.name == 'nt':

861

return (

861

return (

862

(b''.join(c.isalpha() and b'[%s%s]' % (c.lower(), c.upper()) or

862

(b''.join(c.isalpha() and b'[%s%s]' % (c.lower(), c.upper()) or

863

c in b'/\\' and br'[/\\]' or c.isdigit() and c or b'\\' + c

863

c in b'/\\' and br'[/\\]' or c.isdigit() and c or b'\\' + c

864

for c in p))

864

for c in p))

865

)

865

)

866

else:

866

else:

867

return re.escape(p)

867

return re.escape(p)

868

869

def _localip(self):

869

def _localip(self):

870

if self._useipv6:

870

if self._useipv6:

871

return b'::1'

871

return b'::1'

872

else:

872

else:

873

return b'127.0.0.1'

873

return b'127.0.0.1'

874

875

def _getenv(self):

875

def _getenv(self):

876

"""Obtain environment variables to use during test execution."""

876

"""Obtain environment variables to use during test execution."""

877

def defineport(i):

877

def defineport(i):

878

offset = '' if i == 0 else '%s' % i

878

offset = '' if i == 0 else '%s' % i

879

env["HGPORT%s" % offset] = '%s' % (self._startport + i)

879

env["HGPORT%s" % offset] = '%s' % (self._startport + i)

880

env = os.environ.copy()

880

env = os.environ.copy()

881

env['PYTHONUSERBASE'] = sysconfig.get_config_var('userbase')

881

env['PYTHONUSERBASE'] = sysconfig.get_config_var('userbase')

882

env['HGEMITWARNINGS'] = '1'

882

env['HGEMITWARNINGS'] = '1'

883

env['TESTTMP'] = self._testtmp

883

env['TESTTMP'] = self._testtmp

884

env['HOME'] = self._testtmp

884

env['HOME'] = self._testtmp

885

# This number should match portneeded in _getport

885

# This number should match portneeded in _getport

886

for port in xrange(3):

886

for port in xrange(3):

887

# This list should be parallel to _portmap in _getreplacements

887

# This list should be parallel to _portmap in _getreplacements

888

defineport(port)

888

defineport(port)

889

env["HGRCPATH"] = os.path.join(self._threadtmp, b'.hgrc')

889

env["HGRCPATH"] = os.path.join(self._threadtmp, b'.hgrc')

890

env["DAEMON_PIDS"] = os.path.join(self._threadtmp, b'daemon.pids')

890

env["DAEMON_PIDS"] = os.path.join(self._threadtmp, b'daemon.pids')

891

env["HGEDITOR"] = ('"' + sys.executable + '"'

891

env["HGEDITOR"] = ('"' + sys.executable + '"'

892

+ ' -c "import sys; sys.exit(0)"')

892

+ ' -c "import sys; sys.exit(0)"')

893

env["HGMERGE"] = "internal:merge"

893

env["HGMERGE"] = "internal:merge"

894

env["HGUSER"] = "test"

894

env["HGUSER"] = "test"

895

env["HGENCODING"] = "ascii"

895

env["HGENCODING"] = "ascii"

896

env["HGENCODINGMODE"] = "strict"

896

env["HGENCODINGMODE"] = "strict"

897

env['HGIPV6'] = str(int(self._useipv6))

897

env['HGIPV6'] = str(int(self._useipv6))

898

899

# LOCALIP could be ::1 or 127.0.0.1. Useful for tests that require raw

899

# LOCALIP could be ::1 or 127.0.0.1. Useful for tests that require raw

900

# IP addresses.

900

# IP addresses.

901

env['LOCALIP'] = self._localip()

901

env['LOCALIP'] = self._localip()

902

903

# Reset some environment variables to well-known values so that

903

# Reset some environment variables to well-known values so that

904

# the tests produce repeatable output.

904

# the tests produce repeatable output.

905

env['LANG'] = env['LC_ALL'] = env['LANGUAGE'] = 'C'

905

env['LANG'] = env['LC_ALL'] = env['LANGUAGE'] = 'C'

906

env['TZ'] = 'GMT'

906

env['TZ'] = 'GMT'

907

env["EMAIL"] = "Foo Bar <foo.bar@example.com>"

907

env["EMAIL"] = "Foo Bar <foo.bar@example.com>"

908

env['COLUMNS'] = '80'

908

env['COLUMNS'] = '80'

909

env['TERM'] = 'xterm'

909

env['TERM'] = 'xterm'

910

911

for k in ('HG HGPROF CDPATH GREP_OPTIONS http_proxy no_proxy ' +

911

for k in ('HG HGPROF CDPATH GREP_OPTIONS http_proxy no_proxy ' +

912

'HGPLAIN HGPLAINEXCEPT EDITOR VISUAL PAGER ' +

912

'HGPLAIN HGPLAINEXCEPT EDITOR VISUAL PAGER ' +

913

'NO_PROXY CHGDEBUG').split():

913

'NO_PROXY CHGDEBUG').split():

914

if k in env:

914

if k in env:

915

del env[k]

915

del env[k]

916

917

# unset env related to hooks

917

# unset env related to hooks

918

for k in env.keys():

918

for k in env.keys():

919

if k.startswith('HG_'):

919

if k.startswith('HG_'):

920

del env[k]

920

del env[k]

921

922

if self._usechg:

922

if self._usechg:

923

env['CHGSOCKNAME'] = os.path.join(self._chgsockdir, b'server')

923

env['CHGSOCKNAME'] = os.path.join(self._chgsockdir, b'server')

924

925

return env

925

return env

926

927

def _createhgrc(self, path):

927

def _createhgrc(self, path):

928

"""Create an hgrc file for this test."""

928

"""Create an hgrc file for this test."""

929

hgrc = open(path, 'wb')

929

hgrc = open(path, 'wb')

930

hgrc.write(b'[ui]\n')

930

hgrc.write(b'[ui]\n')

931

hgrc.write(b'slash = True\n')

931

hgrc.write(b'slash = True\n')

932

hgrc.write(b'interactive = False\n')

932

hgrc.write(b'interactive = False\n')

933

hgrc.write(b'mergemarkers = detailed\n')

933

hgrc.write(b'mergemarkers = detailed\n')

934

hgrc.write(b'promptecho = True\n')

934

hgrc.write(b'promptecho = True\n')

935

hgrc.write(b'[defaults]\n')

935

hgrc.write(b'[defaults]\n')

936

hgrc.write(b'backout = -d "0 0"\n')

936

hgrc.write(b'backout = -d "0 0"\n')

937

hgrc.write(b'commit = -d "0 0"\n')

937

hgrc.write(b'commit = -d "0 0"\n')

938

hgrc.write(b'shelve = --date "0 0"\n')

938

hgrc.write(b'shelve = --date "0 0"\n')

939

hgrc.write(b'tag = -d "0 0"\n')

939

hgrc.write(b'tag = -d "0 0"\n')

940

hgrc.write(b'[devel]\n')

940

hgrc.write(b'[devel]\n')

941

hgrc.write(b'all-warnings = true\n')

941

hgrc.write(b'all-warnings = true\n')

942

hgrc.write(b'[largefiles]\n')

942

hgrc.write(b'[largefiles]\n')

943

hgrc.write(b'usercache = %s\n' %

943

hgrc.write(b'usercache = %s\n' %

944

(os.path.join(self._testtmp, b'.cache/largefiles')))

944

(os.path.join(self._testtmp, b'.cache/largefiles')))

945

hgrc.write(b'[web]\n')

945

hgrc.write(b'[web]\n')

946

hgrc.write(b'address = localhost\n')

946

hgrc.write(b'address = localhost\n')

947

hgrc.write(b'ipv6 = %s\n' % str(self._useipv6).encode('ascii'))

947

hgrc.write(b'ipv6 = %s\n' % str(self._useipv6).encode('ascii'))

948

949

for opt in self._extraconfigopts:

949

for opt in self._extraconfigopts:

950

section, key = opt.split('.', 1)

950

section, key = opt.split('.', 1)

951

assert '=' in key, ('extra config opt %s must '

951

assert '=' in key, ('extra config opt %s must '

952

'have an = for assignment' % opt)

952

'have an = for assignment' % opt)

953

hgrc.write(b'[%s]\n%s\n' % (section, key))

953

hgrc.write(b'[%s]\n%s\n' % (section, key))

954

hgrc.close()

954

hgrc.close()

955

956

def fail(self, msg):

956

def fail(self, msg):

957

# unittest differentiates between errored and failed.

957

# unittest differentiates between errored and failed.

958

# Failed is denoted by AssertionError (by default at least).

958

# Failed is denoted by AssertionError (by default at least).

959

raise AssertionError(msg)

959

raise AssertionError(msg)

960

961

def _runcommand(self, cmd, env, normalizenewlines=False):

961

def _runcommand(self, cmd, env, normalizenewlines=False):

962

"""Run command in a sub-process, capturing the output (stdout and

962

"""Run command in a sub-process, capturing the output (stdout and

963

stderr).

963

stderr).

964

965

Return a tuple (exitcode, output). output is None in debug mode.

965

Return a tuple (exitcode, output). output is None in debug mode.

966

"""

966

"""

967

if self._debug:

967

if self._debug:

968

proc = subprocess.Popen(cmd, shell=True, cwd=self._testtmp,

968

proc = subprocess.Popen(cmd, shell=True, cwd=self._testtmp,

969

env=env)

969

env=env)

970

ret = proc.wait()

970

ret = proc.wait()

971

return (ret, None)

971

return (ret, None)

972

973

proc = Popen4(cmd, self._testtmp, self._timeout, env)

973

proc = Popen4(cmd, self._testtmp, self._timeout, env)

974

def cleanup():

974

def cleanup():

975

terminate(proc)

975

terminate(proc)

976

ret = proc.wait()

976

ret = proc.wait()

977

if ret == 0:

977

if ret == 0:

978

ret = signal.SIGTERM << 8

978

ret = signal.SIGTERM << 8

979

killdaemons(env['DAEMON_PIDS'])

979

killdaemons(env['DAEMON_PIDS'])

980

return ret

980

return ret

981

982

output = ''

982

output = ''

983

proc.tochild.close()

983

proc.tochild.close()

984

985

try:

985

try:

986

output = proc.fromchild.read()

986

output = proc.fromchild.read()

987

except KeyboardInterrupt:

987

except KeyboardInterrupt:

988

vlog('# Handling keyboard interrupt')

988

vlog('# Handling keyboard interrupt')

989

cleanup()

989

cleanup()

990

raise

990

raise

991

992

ret = proc.wait()

992

ret = proc.wait()

993

if wifexited(ret):

993

if wifexited(ret):

994

ret = os.WEXITSTATUS(ret)

994

ret = os.WEXITSTATUS(ret)

995

996

if proc.timeout:

996

if proc.timeout:

997

ret = 'timeout'

997

ret = 'timeout'

998

999

if ret:

999

if ret:

1000

killdaemons(env['DAEMON_PIDS'])

1000

killdaemons(env['DAEMON_PIDS'])

1001

1002

for s, r in self._getreplacements():

1002

for s, r in self._getreplacements():

1003

output = re.sub(s, r, output)

1003

output = re.sub(s, r, output)

1004

1005

if normalizenewlines:

1005

if normalizenewlines:

1006

output = output.replace('\r\n', '\n')

1006

output = output.replace('\r\n', '\n')

1007

1008

return ret, output.splitlines(True)

1008

return ret, output.splitlines(True)

1009

1010

class PythonTest(Test):

1010

class PythonTest(Test):

1011

"""A Python-based test."""

1011

"""A Python-based test."""

1012

1013

@property

1013

@property

1014

def refpath(self):

1014

def refpath(self):

1015

return os.path.join(self._testdir, b'%s.out' % self.bname)

1015

return os.path.join(self._testdir, b'%s.out' % self.bname)

1016

1017

def _run(self, env):

1017

def _run(self, env):

1018

py3kswitch = self._py3kwarnings and b' -3' or b''

1018

py3kswitch = self._py3kwarnings and b' -3' or b''

1019

cmd = b'%s%s "%s"' % (PYTHON, py3kswitch, self.path)

1019

cmd = b'%s%s "%s"' % (PYTHON, py3kswitch, self.path)

1020

vlog("# Running", cmd)

1020

vlog("# Running", cmd)

1021

normalizenewlines = os.name == 'nt'

1021

normalizenewlines = os.name == 'nt'

1022

result = self._runcommand(cmd, env,

1022

result = self._runcommand(cmd, env,

1023

normalizenewlines=normalizenewlines)

1023

normalizenewlines=normalizenewlines)

1024

if self._aborted:

1024

if self._aborted:

1025

raise KeyboardInterrupt()

1025

raise KeyboardInterrupt()

1026

1027

return result

1027

return result

1028

1029

# Some glob patterns apply only in some circumstances, so the script

1029

# Some glob patterns apply only in some circumstances, so the script

1030

# might want to remove (glob) annotations that otherwise should be

1030

# might want to remove (glob) annotations that otherwise should be

1031

# retained.

1031

# retained.

1032

checkcodeglobpats = [

1032

checkcodeglobpats = [

1033

# On Windows it looks like \ doesn't require a (glob), but we know

1033

# On Windows it looks like \ doesn't require a (glob), but we know

1034

# better.

1034

# better.

1035

re.compile(br'^pushing to \$TESTTMP/.*[^)]$'),

1035

re.compile(br'^pushing to \$TESTTMP/.*[^)]$'),

1036

re.compile(br'^moving \S+/.*[^)]$'),

1036

re.compile(br'^moving \S+/.*[^)]$'),

1037

re.compile(br'^pulling from \$TESTTMP/.*[^)]$'),

1037

re.compile(br'^pulling from \$TESTTMP/.*[^)]$'),

1038

# Not all platforms have 127.0.0.1 as loopback (though most do),

1038

# Not all platforms have 127.0.0.1 as loopback (though most do),

1039

# so we always glob that too.

1039

# so we always glob that too.

1040

re.compile(br'.*\$LOCALIP.*$'),

1040

re.compile(br'.*\$LOCALIP.*$'),

1041

]

1041

]

1042

1043

bchr = chr

1043

bchr = chr

1044

if PYTHON3:

1044

if PYTHON3:

1045

bchr = lambda x: bytes([x])

1045

bchr = lambda x: bytes([x])

1046

1047

class TTest(Test):

1047

class TTest(Test):

1048

"""A "t test" is a test backed by a .t file."""

1048

"""A "t test" is a test backed by a .t file."""

1049

1050

SKIPPED_PREFIX = b'skipped: '

1050

SKIPPED_PREFIX = b'skipped: '

1051

FAILED_PREFIX = b'hghave check failed: '

1051

FAILED_PREFIX = b'hghave check failed: '

1052

NEEDESCAPE = re.compile(br'[\x00-\x08\x0b-\x1f\x7f-\xff]').search

1052

NEEDESCAPE = re.compile(br'[\x00-\x08\x0b-\x1f\x7f-\xff]').search

1053

1054

ESCAPESUB = re.compile(br'[\x00-\x08\x0b-\x1f\\\x7f-\xff]').sub

1054

ESCAPESUB = re.compile(br'[\x00-\x08\x0b-\x1f\\\x7f-\xff]').sub

1055

ESCAPEMAP = dict((bchr(i), br'\x%02x' % i) for i in range(256))

1055

ESCAPEMAP = dict((bchr(i), br'\x%02x' % i) for i in range(256))

1056

ESCAPEMAP.update({b'\\': b'\\\\', b'\r': br'\r'})

1056

ESCAPEMAP.update({b'\\': b'\\\\', b'\r': br'\r'})

1057

1058

@property

1058

@property

1059

def refpath(self):

1059

def refpath(self):

1060

return os.path.join(self._testdir, self.bname)

1060

return os.path.join(self._testdir, self.bname)

1061

1062

def _run(self, env):

1062

def _run(self, env):

1063

f = open(self.path, 'rb')

1063

f = open(self.path, 'rb')

1064

lines = f.readlines()

1064

lines = f.readlines()

1065

f.close()

1065

f.close()

1066

1067

salt, script, after, expected = self._parsetest(lines)

1067

salt, script, after, expected = self._parsetest(lines)

1068

1069

# Write out the generated script.

1069

# Write out the generated script.

1070

fname = b'%s.sh' % self._testtmp

1070

fname = b'%s.sh' % self._testtmp

1071

f = open(fname, 'wb')

1071

f = open(fname, 'wb')

1072

for l in script:

1072

for l in script:

1073

f.write(l)

1073

f.write(l)

1074

f.close()

1074

f.close()

1075

1076

cmd = b'%s "%s"' % (self._shell, fname)

1076

cmd = b'%s "%s"' % (self._shell, fname)

1077

vlog("# Running", cmd)

1077

vlog("# Running", cmd)

1078

1079

exitcode, output = self._runcommand(cmd, env)

1079

exitcode, output = self._runcommand(cmd, env)

1080

1081

if self._aborted:

1081

if self._aborted:

1082

raise KeyboardInterrupt()

1082

raise KeyboardInterrupt()

1083

1084

# Do not merge output if skipped. Return hghave message instead.

1084

# Do not merge output if skipped. Return hghave message instead.

1085

# Similarly, with --debug, output is None.

1085

# Similarly, with --debug, output is None.

1086

if exitcode == self.SKIPPED_STATUS or output is None:

1086

if exitcode == self.SKIPPED_STATUS or output is None:

1087

return exitcode, output

1087

return exitcode, output

1088

1089

return self._processoutput(exitcode, output, salt, after, expected)

1089

return self._processoutput(exitcode, output, salt, after, expected)

1090

1091

def _hghave(self, reqs):

1091

def _hghave(self, reqs):

1092

# TODO do something smarter when all other uses of hghave are gone.

1092

# TODO do something smarter when all other uses of hghave are gone.

1093

runtestdir = os.path.abspath(os.path.dirname(_bytespath(__file__)))

1093

runtestdir = os.path.abspath(os.path.dirname(_bytespath(__file__)))

1094

tdir = runtestdir.replace(b'\\', b'/')

1094

tdir = runtestdir.replace(b'\\', b'/')

1095

proc = Popen4(b'%s -c "%s/hghave %s"' %

1095

proc = Popen4(b'%s -c "%s/hghave %s"' %

1096

(self._shell, tdir, b' '.join(reqs)),

1096

(self._shell, tdir, b' '.join(reqs)),

1097

self._testtmp, 0, self._getenv())

1097

self._testtmp, 0, self._getenv())

1098

stdout, stderr = proc.communicate()

1098

stdout, stderr = proc.communicate()

1099

ret = proc.wait()

1099

ret = proc.wait()

1100

if wifexited(ret):

1100

if wifexited(ret):

1101

ret = os.WEXITSTATUS(ret)

1101

ret = os.WEXITSTATUS(ret)

1102

if ret == 2:

1102

if ret == 2:

1103

print(stdout.decode('utf-8'))

1103

print(stdout.decode('utf-8'))

1104

sys.exit(1)

1104

sys.exit(1)

1105

1106

if ret != 0:

1106

if ret != 0:

1107

return False, stdout

1107

return False, stdout

1108

1109

if 'slow' in reqs:

1109

if 'slow' in reqs:

1110

self._timeout = self._slowtimeout

1110

self._timeout = self._slowtimeout

1111

return True, None

1111

return True, None

1112

1113

def _parsetest(self, lines):

1113

def _parsetest(self, lines):

1114

# We generate a shell script which outputs unique markers to line

1114

# We generate a shell script which outputs unique markers to line

1115

# up script results with our source. These markers include input

1115

# up script results with our source. These markers include input

1116

# line number and the last return code.

1116

# line number and the last return code.

1117

salt = b"SALT%d" % time.time()

1117

salt = b"SALT%d" % time.time()

1118

def addsalt(line, inpython):

1118

def addsalt(line, inpython):

1119

if inpython:

1119

if inpython:

1120

script.append(b'%s %d 0\n' % (salt, line))

1120

script.append(b'%s %d 0\n' % (salt, line))

1121

else:

1121

else:

1122

script.append(b'echo %s %d $?\n' % (salt, line))

1122

script.append(b'echo %s %d $?\n' % (salt, line))

1123

1124

script = []

1124

script = []

1125

1126

# After we run the shell script, we re-unify the script output

1126

# After we run the shell script, we re-unify the script output

1127

# with non-active parts of the source, with synchronization by our

1127

# with non-active parts of the source, with synchronization by our

1128

# SALT line number markers. The after table contains the non-active

1128

# SALT line number markers. The after table contains the non-active

1129

# components, ordered by line number.

1129

# components, ordered by line number.

1130

after = {}

1130

after = {}

1131

1132

# Expected shell script output.

1132

# Expected shell script output.

1133

expected = {}

1133

expected = {}

1134

1135

pos = prepos = -1

1135

pos = prepos = -1

1136

1137

# True or False when in a true or false conditional section

1137

# True or False when in a true or false conditional section

1138

skipping = None

1138

skipping = None

1139

1140

# We keep track of whether or not we're in a Python block so we

1140

# We keep track of whether or not we're in a Python block so we

1141

# can generate the surrounding doctest magic.

1141

# can generate the surrounding doctest magic.

1142

inpython = False

1142

inpython = False

1143

1144

if self._debug:

1144

if self._debug:

1145

script.append(b'set -x\n')

1145

script.append(b'set -x\n')

1146

if self._hgcommand != b'hg':

1146

if self._hgcommand != b'hg':

1147

script.append(b'alias hg="%s"\n' % self._hgcommand)

1147

script.append(b'alias hg="%s"\n' % self._hgcommand)

1148

if os.getenv('MSYSTEM'):

1148

if os.getenv('MSYSTEM'):

1149

script.append(b'alias pwd="pwd -W"\n')

1149

script.append(b'alias pwd="pwd -W"\n')

1150

1151

n = 0

1151

n = 0

1152

for n, l in enumerate(lines):

1152

for n, l in enumerate(lines):

1153

if not l.endswith(b'\n'):

1153

if not l.endswith(b'\n'):

1154

l += b'\n'

1154

l += b'\n'

1155

if l.startswith(b'#require'):

1155

if l.startswith(b'#require'):

1156

lsplit = l.split()

1156

lsplit = l.split()

1157

if len(lsplit) < 2 or lsplit[0] != b'#require':

1157

if len(lsplit) < 2 or lsplit[0] != b'#require':

1158

after.setdefault(pos, []).append(' !!! invalid #require\n')

1158

after.setdefault(pos, []).append(' !!! invalid #require\n')

1159

haveresult, message = self._hghave(lsplit[1:])

1159

haveresult, message = self._hghave(lsplit[1:])

1160

if not haveresult:

1160

if not haveresult:

1161

script = [b'echo "%s"\nexit 80\n' % message]

1161

script = [b'echo "%s"\nexit 80\n' % message]

1162

break

1162

break

1163

after.setdefault(pos, []).append(l)

1163

after.setdefault(pos, []).append(l)

1164

elif l.startswith(b'#if'):

1164

elif l.startswith(b'#if'):

1165

lsplit = l.split()

1165

lsplit = l.split()

1166

if len(lsplit) < 2 or lsplit[0] != b'#if':

1166

if len(lsplit) < 2 or lsplit[0] != b'#if':

1167

after.setdefault(pos, []).append(' !!! invalid #if\n')

1167

after.setdefault(pos, []).append(' !!! invalid #if\n')

1168

if skipping is not None:

1168

if skipping is not None:

1169

after.setdefault(pos, []).append(' !!! nested #if\n')

1169

after.setdefault(pos, []).append(' !!! nested #if\n')

1170

skipping = not self._hghave(lsplit[1:])[0]

1170

skipping = not self._hghave(lsplit[1:])[0]

1171

after.setdefault(pos, []).append(l)

1171

after.setdefault(pos, []).append(l)

1172

elif l.startswith(b'#else'):

1172

elif l.startswith(b'#else'):

1173

if skipping is None:

1173

if skipping is None:

1174

after.setdefault(pos, []).append(' !!! missing #if\n')

1174

after.setdefault(pos, []).append(' !!! missing #if\n')

1175

skipping = not skipping

1175

skipping = not skipping

1176

after.setdefault(pos, []).append(l)

1176

after.setdefault(pos, []).append(l)

1177

elif l.startswith(b'#endif'):

1177

elif l.startswith(b'#endif'):

1178

if skipping is None:

1178

if skipping is None:

1179

after.setdefault(pos, []).append(' !!! missing #if\n')

1179

after.setdefault(pos, []).append(' !!! missing #if\n')

1180

skipping = None

1180

skipping = None

1181

after.setdefault(pos, []).append(l)

1181

after.setdefault(pos, []).append(l)

1182

elif skipping:

1182

elif skipping:

1183

after.setdefault(pos, []).append(l)

1183

after.setdefault(pos, []).append(l)

1184

elif l.startswith(b' >>> '): # python inlines

1184

elif l.startswith(b' >>> '): # python inlines

1185

after.setdefault(pos, []).append(l)

1185

after.setdefault(pos, []).append(l)

1186

prepos = pos

1186

prepos = pos

1187

pos = n

1187

pos = n

1188

if not inpython:

1188

if not inpython:

1189

# We've just entered a Python block. Add the header.

1189

# We've just entered a Python block. Add the header.

1190

inpython = True

1190

inpython = True

1191

addsalt(prepos, False) # Make sure we report the exit code.

1191

addsalt(prepos, False) # Make sure we report the exit code.

1192

script.append(b'%s -m heredoctest <<EOF\n' % PYTHON)

1192

script.append(b'%s -m heredoctest <<EOF\n' % PYTHON)

1193

addsalt(n, True)

1193

addsalt(n, True)

1194

script.append(l[2:])

1194

script.append(l[2:])

1195

elif l.startswith(b' ... '): # python inlines

1195

elif l.startswith(b' ... '): # python inlines

1196

after.setdefault(prepos, []).append(l)

1196

after.setdefault(prepos, []).append(l)

1197

script.append(l[2:])

1197

script.append(l[2:])

1198

elif l.startswith(b' $ '): # commands

1198

elif l.startswith(b' $ '): # commands

1199

if inpython:

1199

if inpython:

1200

script.append(b'EOF\n')

1200

script.append(b'EOF\n')

1201

inpython = False

1201

inpython = False

1202

after.setdefault(pos, []).append(l)

1202

after.setdefault(pos, []).append(l)

1203

prepos = pos

1203

prepos = pos

1204

pos = n

1204

pos = n

1205

addsalt(n, False)

1205

addsalt(n, False)

1206

cmd = l[4:].split()

1206

cmd = l[4:].split()

1207

if len(cmd) == 2 and cmd[0] == b'cd':

1207

if len(cmd) == 2 and cmd[0] == b'cd':

1208

l = b' $ cd %s || exit 1\n' % cmd[1]

1208

l = b' $ cd %s || exit 1\n' % cmd[1]

1209

script.append(l[4:])

1209

script.append(l[4:])

1210

elif l.startswith(b' > '): # continuations

1210

elif l.startswith(b' > '): # continuations

1211

after.setdefault(prepos, []).append(l)

1211

after.setdefault(prepos, []).append(l)

1212

script.append(l[4:])

1212

script.append(l[4:])

1213

elif l.startswith(b' '): # results

1213

elif l.startswith(b' '): # results

1214

# Queue up a list of expected results.

1214

# Queue up a list of expected results.

1215

expected.setdefault(pos, []).append(l[2:])

1215

expected.setdefault(pos, []).append(l[2:])

1216

else:

1216

else:

1217

if inpython:

1217

if inpython:

1218

script.append(b'EOF\n')

1218

script.append(b'EOF\n')

1219

inpython = False

1219

inpython = False

1220

# Non-command/result. Queue up for merged output.

1220

# Non-command/result. Queue up for merged output.

1221

after.setdefault(pos, []).append(l)

1221

after.setdefault(pos, []).append(l)

1222

1223

if inpython:

1223

if inpython:

1224

script.append(b'EOF\n')

1224

script.append(b'EOF\n')

1225

if skipping is not None:

1225

if skipping is not None:

1226

after.setdefault(pos, []).append(' !!! missing #endif\n')

1226

after.setdefault(pos, []).append(' !!! missing #endif\n')

1227

addsalt(n + 1, False)

1227

addsalt(n + 1, False)

1228

1229

return salt, script, after, expected

1229

return salt, script, after, expected

1230

1231

def _processoutput(self, exitcode, output, salt, after, expected):

1231

def _processoutput(self, exitcode, output, salt, after, expected):

1232

# Merge the script output back into a unified test.

1232

# Merge the script output back into a unified test.

1233

warnonly = 1 # 1: not yet; 2: yes; 3: for sure not

1233

warnonly = 1 # 1: not yet; 2: yes; 3: for sure not

1234

if exitcode != 0:

1234

if exitcode != 0:

1235

warnonly = 3

1235

warnonly = 3

1236

1237

pos = -1

1237

pos = -1

1238

postout = []

1238

postout = []

1239

for l in output:

1239

for l in output:

1240

lout, lcmd = l, None

1240

lout, lcmd = l, None

1241

if salt in l:

1241

if salt in l:

1242

lout, lcmd = l.split(salt, 1)

1242

lout, lcmd = l.split(salt, 1)

1243

1244

while lout:

1244

while lout:

1245

if not lout.endswith(b'\n'):

1245

if not lout.endswith(b'\n'):

1246

lout += b' (no-eol)\n'

1246

lout += b' (no-eol)\n'

1247

1248

# Find the expected output at the current position.

1248

# Find the expected output at the current position.

1249

els = [None]

1249

els = [None]

1250

if expected.get(pos, None):

1250

if expected.get(pos, None):

1251

els = expected[pos]

1251

els = expected[pos]

1252

1253

i = 0

1253

i = 0

1254

optional = []

1254

optional = []

1255

while i < len(els):

1255

while i < len(els):

1256

el = els[i]

1256

el = els[i]

1257

1258

r = TTest.linematch(el, lout)

1258

r = TTest.linematch(el, lout)

1259

if isinstance(r, str):

1259

if isinstance(r, str):

1260

if r == '+glob':

1260

if r == '+glob':

1261

lout = el[:-1] + ' (glob)\n'

1261

lout = el[:-1] + ' (glob)\n'

1262

r = '' # Warn only this line.

1262

r = '' # Warn only this line.

1263

elif r == '-glob':

1263

elif r == '-glob':

1264

lout = ''.join(el.rsplit(' (glob)', 1))

1264

lout = ''.join(el.rsplit(' (glob)', 1))

1265

r = '' # Warn only this line.

1265

r = '' # Warn only this line.

1266

elif r == "retry":

1266

elif r == "retry":

1267

postout.append(b' ' + el)

1267

postout.append(b' ' + el)

1268

els.pop(i)

1268

els.pop(i)

1269

break

1269

break

1270

else:

1270

else:

1271

log('\ninfo, unknown linematch result: %r\n' % r)

1271

log('\ninfo, unknown linematch result: %r\n' % r)

1272

r = False

1272

r = False

1273

if r:

1273

if r:

1274

els.pop(i)

1274

els.pop(i)

1275

break

1275

break

1276

if el:

1276

if el:

1277

if el.endswith(b" (?)\n"):

1277

if el.endswith(b" (?)\n"):

1278

optional.append(i)

1278

optional.append(i)

1279

else:

1279

else:

1280

m = optline.match(el)

1280

m = optline.match(el)

1281

if m:

1281

if m:

1282

conditions = [c for c in m.group(2).split(' ')]

1282

conditions = [c for c in m.group(2).split(' ')]

1283

1284

if self._hghave(conditions)[0]:

1284

if self._hghave(conditions)[0]:

1285

lout = el

1285

lout = el

1286

else:

1286

else:

1287

optional.append(i)

1287

optional.append(i)

1288

1289

i += 1

1289

i += 1

1290

1291

if r:

1291

if r:

1292

if r == "retry":

1292

if r == "retry":

1293

continue

1293

continue

1294

# clean up any optional leftovers

1294

# clean up any optional leftovers

1295

for i in optional:

1295

for i in optional:

1296

postout.append(b' ' + els[i])

1296

postout.append(b' ' + els[i])

1297

for i in reversed(optional):

1297

for i in reversed(optional):

1298

del els[i]

1298

del els[i]

1299

postout.append(b' ' + el)

1299

postout.append(b' ' + el)

1300

else:

1300

else:

1301

if self.NEEDESCAPE(lout):

1301

if self.NEEDESCAPE(lout):

1302

lout = TTest._stringescape(b'%s (esc)\n' %

1302

lout = TTest._stringescape(b'%s (esc)\n' %

1303

lout.rstrip(b'\n'))

1303

lout.rstrip(b'\n'))

1304

postout.append(b' ' + lout) # Let diff deal with it.

1304

postout.append(b' ' + lout) # Let diff deal with it.

1305

if r != '': # If line failed.

1305

if r != '': # If line failed.

1306

warnonly = 3 # for sure not

1306

warnonly = 3 # for sure not

1307

elif warnonly == 1: # Is "not yet" and line is warn only.

1307

elif warnonly == 1: # Is "not yet" and line is warn only.

1308

warnonly = 2 # Yes do warn.

1308

warnonly = 2 # Yes do warn.

1309

break

1309

break

1310

else:

1310

else:

1311

# clean up any optional leftovers

1311

# clean up any optional leftovers

1312

while expected.get(pos, None):

1312

while expected.get(pos, None):

1313

el = expected[pos].pop(0)

1313

el = expected[pos].pop(0)

1314

if el:

1314

if el:

1315

if (not optline.match(el)

1315

if (not optline.match(el)

1316

and not el.endswith(b" (?)\n")):

1316

and not el.endswith(b" (?)\n")):

1317

break

1317

break

1318

postout.append(b' ' + el)

1318

postout.append(b' ' + el)

1319

1320

if lcmd:

1320

if lcmd:

1321

# Add on last return code.

1321

# Add on last return code.

1322

ret = int(lcmd.split()[1])

1322

ret = int(lcmd.split()[1])

1323

if ret != 0:

1323

if ret != 0:

1324

postout.append(b' [%d]\n' % ret)

1324

postout.append(b' [%d]\n' % ret)

1325

if pos in after:

1325

if pos in after:

1326

# Merge in non-active test bits.

1326

# Merge in non-active test bits.

1327

postout += after.pop(pos)

1327

postout += after.pop(pos)

1328

pos = int(lcmd.split()[0])

1328

pos = int(lcmd.split()[0])

1329

1330

if pos in after:

1330

if pos in after:

1331

postout += after.pop(pos)

1331

postout += after.pop(pos)

1332

1333

if warnonly == 2:

1333

if warnonly == 2:

1334

exitcode = False # Set exitcode to warned.

1334

exitcode = False # Set exitcode to warned.

1335

1336

return exitcode, postout

1336

return exitcode, postout

1337

1338

@staticmethod

1338

@staticmethod

1339

def rematch(el, l):

1339

def rematch(el, l):

1340

try:

1340

try:

1341

# use \Z to ensure that the regex matches to the end of the string

1341

# use \Z to ensure that the regex matches to the end of the string

1342

if os.name == 'nt':

1342

if os.name == 'nt':

1343

return re.match(el + br'\r?\n\Z', l)

1343

return re.match(el + br'\r?\n\Z', l)

1344

return re.match(el + br'\n\Z', l)

1344

return re.match(el + br'\n\Z', l)

1345

except re.error:

1345

except re.error:

1346

# el is an invalid regex

1346

# el is an invalid regex

1347

return False

1347

return False

1348

1349

@staticmethod

1349

@staticmethod

1350

def globmatch(el, l):

1350

def globmatch(el, l):

1351

# The only supported special characters are * and ? plus / which also

1351

# The only supported special characters are * and ? plus / which also

1352

# matches \ on windows. Escaping of these characters is supported.

1352

# matches \ on windows. Escaping of these characters is supported.

1353

if el + b'\n' == l:

1353

if el + b'\n' == l:

1354

if os.altsep:

1354

if os.altsep:

1355

# matching on "/" is not needed for this line

1355

# matching on "/" is not needed for this line

1356

for pat in checkcodeglobpats:

1356

for pat in checkcodeglobpats:

1357

if pat.match(el):

1357

if pat.match(el):

1358

return True

1358

return True

1359

return b'-glob'

1359

return b'-glob'

1360

return True

1360

return True

1361

el = el.replace(b'$LOCALIP', b'*')

1361

el = el.replace(b'$LOCALIP', b'*')

1362

i, n = 0, len(el)

1362

i, n = 0, len(el)

1363

res = b''

1363

res = b''

1364

while i < n:

1364

while i < n:

1365

c = el[i:i + 1]

1365

c = el[i:i + 1]

1366

i += 1

1366

i += 1

1367

if c == b'\\' and i < n and el[i:i + 1] in b'*?\\/':

1367

if c == b'\\' and i < n and el[i:i + 1] in b'*?\\/':

1368

res += el[i - 1:i + 1]

1368

res += el[i - 1:i + 1]

1369

i += 1

1369

i += 1

1370

elif c == b'*':

1370

elif c == b'*':

1371

res += b'.*'

1371

res += b'.*'

1372

elif c == b'?':

1372

elif c == b'?':

1373

res += b'.'

1373

res += b'.'

1374

elif c == b'/' and os.altsep:

1374

elif c == b'/' and os.altsep:

1375

res += b'[/\\\\]'

1375

res += b'[/\\\\]'

1376

else:

1376

else:

1377

res += re.escape(c)

1377

res += re.escape(c)

1378

return TTest.rematch(res, l)

1378

return TTest.rematch(res, l)

1379

1380

@staticmethod

1380

@staticmethod

1381

def linematch(el, l):

1381

def linematch(el, l):

1382

retry = False

1382

retry = False

1383

if el == l: # perfect match (fast)

1383

if el == l: # perfect match (fast)

1384

return True

1384

return True

1385

if el:

1385

if el:

1386

if el.endswith(b" (?)\n"):

1386

if el.endswith(b" (?)\n"):

1387

retry = "retry"

1387

retry = "retry"

1388

el = el[:-5] + b"\n"

1388

el = el[:-5] + b"\n"

1389

else:

1389

else:

1390

m = optline.match(el)

1390

m = optline.match(el)

1391

if m:

1391

if m:

1392

el = m.group(1) + b"\n"

1392

el = m.group(1) + b"\n"

1393

retry = "retry"

1393

retry = "retry"

1394

1395

if el.endswith(b" (esc)\n"):

1395

if el.endswith(b" (esc)\n"):

1396

if PYTHON3:

1396

if PYTHON3:

1397

el = el[:-7].decode('unicode_escape') + '\n'

1397

el = el[:-7].decode('unicode_escape') + '\n'

1398

el = el.encode('utf-8')

1398

el = el.encode('utf-8')

1399

else:

1399

else:

1400

el = el[:-7].decode('string-escape') + '\n'

1400

el = el[:-7].decode('string-escape') + '\n'

1401

if el == l or os.name == 'nt' and el[:-1] + b'\r\n' == l:

1401

if el == l or os.name == 'nt' and el[:-1] + b'\r\n' == l:

1402

return True

1402

return True

1403

if el.endswith(b" (re)\n"):

1403

if el.endswith(b" (re)\n"):

1404

return TTest.rematch(el[:-6], l) or retry

1404

return TTest.rematch(el[:-6], l) or retry

1405

if el.endswith(b" (glob)\n"):

1405

if el.endswith(b" (glob)\n"):

1406

# ignore '(glob)' added to l by 'replacements'

1406

# ignore '(glob)' added to l by 'replacements'

1407

if l.endswith(b" (glob)\n"):

1407

if l.endswith(b" (glob)\n"):

1408

l = l[:-8] + b"\n"

1408

l = l[:-8] + b"\n"

1409

return TTest.globmatch(el[:-8], l) or retry

1409

return TTest.globmatch(el[:-8], l) or retry

1410

if os.altsep and l.replace(b'\\', b'/') == el:

1410

if os.altsep and l.replace(b'\\', b'/') == el:

1411

return b'+glob'

1411

return b'+glob'

1412

return retry

1412

return retry

1413

1414

@staticmethod

1414

@staticmethod

1415

def parsehghaveoutput(lines):

1415

def parsehghaveoutput(lines):

1416

'''Parse hghave log lines.

1416

'''Parse hghave log lines.

1417

1418

Return tuple of lists (missing, failed):

1418

Return tuple of lists (missing, failed):

1419

* the missing/unknown features

1419

* the missing/unknown features

1420

* the features for which existence check failed'''

1420

* the features for which existence check failed'''

1421

missing = []

1421

missing = []

1422

failed = []

1422

failed = []

1423

for line in lines:

1423

for line in lines:

1424

if line.startswith(TTest.SKIPPED_PREFIX):

1424

if line.startswith(TTest.SKIPPED_PREFIX):

1425

line = line.splitlines()[0]

1425

line = line.splitlines()[0]

1426

missing.append(line[len(TTest.SKIPPED_PREFIX):].decode('utf-8'))

1426

missing.append(line[len(TTest.SKIPPED_PREFIX):].decode('utf-8'))

1427

elif line.startswith(TTest.FAILED_PREFIX):

1427

elif line.startswith(TTest.FAILED_PREFIX):

1428

line = line.splitlines()[0]

1428

line = line.splitlines()[0]

1429

failed.append(line[len(TTest.FAILED_PREFIX):].decode('utf-8'))

1429

failed.append(line[len(TTest.FAILED_PREFIX):].decode('utf-8'))

1430

1431

return missing, failed

1431

return missing, failed

1432

1433

@staticmethod

1433

@staticmethod

1434

def _escapef(m):

1434

def _escapef(m):

1435

return TTest.ESCAPEMAP[m.group(0)]

1435

return TTest.ESCAPEMAP[m.group(0)]

1436

1437

@staticmethod

1437

@staticmethod

1438

def _stringescape(s):

1438

def _stringescape(s):

1439

return TTest.ESCAPESUB(TTest._escapef, s)

1439

return TTest.ESCAPESUB(TTest._escapef, s)

1440

1441

iolock = threading.RLock()

1441

iolock = threading.RLock()

1442

1443

class SkipTest(Exception):

1443

class SkipTest(Exception):

1444

"""Raised to indicate that a test is to be skipped."""

1444

"""Raised to indicate that a test is to be skipped."""

1445

1446

class IgnoreTest(Exception):

1446

class IgnoreTest(Exception):

1447

"""Raised to indicate that a test is to be ignored."""

1447

"""Raised to indicate that a test is to be ignored."""

1448

1449

class WarnTest(Exception):

1449

class WarnTest(Exception):

1450

"""Raised to indicate that a test warned."""

1450

"""Raised to indicate that a test warned."""

1451

1452

class ReportedTest(Exception):

1452

class ReportedTest(Exception):

1453

"""Raised to indicate that a test already reported."""

1453

"""Raised to indicate that a test already reported."""

1454

1455

class TestResult(unittest._TextTestResult):

1455

class TestResult(unittest._TextTestResult):

1456

"""Holds results when executing via unittest."""

1456

"""Holds results when executing via unittest."""

1457

# Don't worry too much about accessing the non-public _TextTestResult.

1457

# Don't worry too much about accessing the non-public _TextTestResult.

1458

# It is relatively common in Python testing tools.

1458

# It is relatively common in Python testing tools.

1459

def __init__(self, options, *args, **kwargs):

1459

def __init__(self, options, *args, **kwargs):

1460

super(TestResult, self).__init__(*args, **kwargs)

1460

super(TestResult, self).__init__(*args, **kwargs)

1461

1462

self._options = options

1462

self._options = options

1463

1464

# unittest.TestResult didn't have skipped until 2.7. We need to

1464

# unittest.TestResult didn't have skipped until 2.7. We need to

1465

# polyfill it.

1465

# polyfill it.

1466

self.skipped = []

1466

self.skipped = []

1467

1468

# We have a custom "ignored" result that isn't present in any Python

1468

# We have a custom "ignored" result that isn't present in any Python

1469

# unittest implementation. It is very similar to skipped. It may make

1469

# unittest implementation. It is very similar to skipped. It may make

1470

# sense to map it into skip some day.

1470

# sense to map it into skip some day.

1471

self.ignored = []

1471

self.ignored = []

1472

1473

# We have a custom "warned" result that isn't present in any Python

1473

# We have a custom "warned" result that isn't present in any Python

1474

# unittest implementation. It is very similar to failed. It may make

1474

# unittest implementation. It is very similar to failed. It may make

1475

# sense to map it into fail some day.

1475

# sense to map it into fail some day.

1476

self.warned = []

1476

self.warned = []

1477

1478

self.times = []

1478

self.times = []

1479

self._firststarttime = None

1479

self._firststarttime = None

1480

# Data stored for the benefit of generating xunit reports.

1480

# Data stored for the benefit of generating xunit reports.

1481

self.successes = []

1481

self.successes = []

1482

self.faildata = {}

1482

self.faildata = {}

1483

1484

def addFailure(self, test, reason):

1484

def addFailure(self, test, reason):

1485

self.failures.append((test, reason))

1485

self.failures.append((test, reason))

1486

1487

if self._options.first:

1487

if self._options.first:

1488

self.stop()

1488

self.stop()

1489

else:

1489

else:

1490

with iolock:

1490

with iolock:

1491

if reason == "timed out":

1491

if reason == "timed out":

1492

self.stream.write('t')

1492

self.stream.write('t')

1493

else:

1493

else:

1494

if not self._options.nodiff:

1494

if not self._options.nodiff:

1495

self.stream.write('\nERROR: %s output changed\n' % test)

1495

self.stream.write('\nERROR: %s output changed\n' % test)

1496

self.stream.write('!')

1496

self.stream.write('!')

1497

1498

self.stream.flush()

1498

self.stream.flush()

1499

1500

def addSuccess(self, test):

1500

def addSuccess(self, test):

1501

with iolock:

1501

with iolock:

1502

super(TestResult, self).addSuccess(test)

1502

super(TestResult, self).addSuccess(test)

1503

self.successes.append(test)

1503

self.successes.append(test)

1504

1505

def addError(self, test, err):

1505

def addError(self, test, err):

1506

super(TestResult, self).addError(test, err)

1506

super(TestResult, self).addError(test, err)

1507

if self._options.first:

1507

if self._options.first:

1508

self.stop()

1508

self.stop()

1509

1510

# Polyfill.

1510

# Polyfill.

1511

def addSkip(self, test, reason):

1511

def addSkip(self, test, reason):

1512

self.skipped.append((test, reason))

1512

self.skipped.append((test, reason))

1513

with iolock:

1513

with iolock:

1514

if self.showAll:

1514

if self.showAll:

1515

self.stream.writeln('skipped %s' % reason)

1515

self.stream.writeln('skipped %s' % reason)

1516

else:

1516

else:

1517

self.stream.write('s')

1517

self.stream.write('s')

1518

self.stream.flush()

1518

self.stream.flush()

1519

1520

def addIgnore(self, test, reason):

1520

def addIgnore(self, test, reason):

1521

self.ignored.append((test, reason))

1521

self.ignored.append((test, reason))

1522

with iolock:

1522

with iolock:

1523

if self.showAll:

1523

if self.showAll:

1524

self.stream.writeln('ignored %s' % reason)

1524

self.stream.writeln('ignored %s' % reason)

1525

else:

1525

else:

1526

if reason not in ('not retesting', "doesn't match keyword"):

1526

if reason not in ('not retesting', "doesn't match keyword"):

1527

self.stream.write('i')

1527

self.stream.write('i')

1528

else:

1528

else:

1529

self.testsRun += 1

1529

self.testsRun += 1

1530

self.stream.flush()

1530

self.stream.flush()

1531

1532

def addWarn(self, test, reason):

1532

def addWarn(self, test, reason):

1533

self.warned.append((test, reason))

1533

self.warned.append((test, reason))

1534

1535

if self._options.first:

1535

if self._options.first:

1536

self.stop()

1536

self.stop()

1537

1538

with iolock:

1538

with iolock:

1539

if self.showAll:

1539

if self.showAll:

1540

self.stream.writeln('warned %s' % reason)

1540

self.stream.writeln('warned %s' % reason)

1541

else:

1541

else:

1542

self.stream.write('~')

1542

self.stream.write('~')

1543

self.stream.flush()

1543

self.stream.flush()

1544

1545

def addOutputMismatch(self, test, ret, got, expected):

1545

def addOutputMismatch(self, test, ret, got, expected):

1546

"""Record a mismatch in test output for a particular test."""

1546

"""Record a mismatch in test output for a particular test."""

1547

if self.shouldStop:

1547

if self.shouldStop:

1548

# don't print, some other test case already failed and

1548

# don't print, some other test case already failed and

1549

# printed, we're just stale and probably failed due to our

1549

# printed, we're just stale and probably failed due to our

1550

# temp dir getting cleaned up.

1550

# temp dir getting cleaned up.

1551

return

1551

return

1552

1553

accepted = False

1553

accepted = False

1554

lines = []

1554

lines = []

1555

1556

with iolock:

1556

with iolock:

1557

if self._options.nodiff:

1557

if self._options.nodiff:

1558

pass

1558

pass

1559

elif self._options.view:

1559

elif self._options.view:

1560

v = self._options.view

1560

v = self._options.view

1561

if PYTHON3:

1561

if PYTHON3:

1562

v = _bytespath(v)

1562

v = _bytespath(v)

1563

os.system(b"%s %s %s" %

1563

os.system(b"%s %s %s" %

1564

(v, test.refpath, test.errpath))

1564

(v, test.refpath, test.errpath))

1565

else:

1565

else:

1566

servefail, lines = getdiff(expected, got,

1566

servefail, lines = getdiff(expected, got,

1567

test.refpath, test.errpath)

1567

test.refpath, test.errpath)

1568

if servefail:

1568

if servefail:

1569

self.addFailure(

1569

self.addFailure(

1570

test,

1570

test,

1571

'server failed to start (HGPORT=%s)' % test._startport)

1571

'server failed to start (HGPORT=%s)' % test._startport)

1572

raise ReportedTest('server failed to start')

1572

raise ReportedTest('server failed to start')

1573

else:

1573

else:

1574

self.stream.write('\n')

1574

self.stream.write('\n')

1575

for line in lines:

1575

for line in lines:

1576

if PYTHON3:

1576

if PYTHON3:

1577

self.stream.flush()

1577

self.stream.flush()

1578

self.stream.buffer.write(line)

1578

self.stream.buffer.write(line)

1579

self.stream.buffer.flush()

1579

self.stream.buffer.flush()

1580

else:

1580

else:

1581

self.stream.write(line)

1581

self.stream.write(line)

1582

self.stream.flush()

1582

self.stream.flush()

1583

1584

# handle interactive prompt without releasing iolock

1584

# handle interactive prompt without releasing iolock

1585

if self._options.interactive:

1585

if self._options.interactive:

1586

self.stream.write('Accept this change? [n] ')

1586

self.stream.write('Accept this change? [n] ')

1587

answer = sys.stdin.readline().strip()

1587

answer = sys.stdin.readline().strip()

1588

if answer.lower() in ('y', 'yes'):

1588

if answer.lower() in ('y', 'yes'):

1589

if test.name.endswith('.t'):

1589

if test.name.endswith('.t'):

1590

rename(test.errpath, test.path)

1590

rename(test.errpath, test.path)

1591

else:

1591

else:

1592

rename(test.errpath, '%s.out' % test.path)

1592

rename(test.errpath, '%s.out' % test.path)

1593

accepted = True

1593

accepted = True

1594

if not accepted:

1594

if not accepted:

1595

self.faildata[test.name] = b''.join(lines)

1595

self.faildata[test.name] = b''.join(lines)

1596

1597

return accepted

1597

return accepted

1598

1599

def startTest(self, test):

1599

def startTest(self, test):

1600

super(TestResult, self).startTest(test)

1600

super(TestResult, self).startTest(test)

1601

1602

# os.times module computes the user time and system time spent by

1602

# os.times module computes the user time and system time spent by

1603

# child's processes along with real elapsed time taken by a process.

1603

# child's processes along with real elapsed time taken by a process.

1604

# This module has one limitation. It can only work for Linux user

1604

# This module has one limitation. It can only work for Linux user

1605

# and not for Windows.

1605

# and not for Windows.

1606

test.started = os.times()

1606

test.started = os.times()

1607

if self._firststarttime is None: # thread racy but irrelevant

1607

if self._firststarttime is None: # thread racy but irrelevant

1608

self._firststarttime = test.started[4]

1608

self._firststarttime = test.started[4]

1609

1610

def stopTest(self, test, interrupted=False):

1610

def stopTest(self, test, interrupted=False):

1611

super(TestResult, self).stopTest(test)

1611

super(TestResult, self).stopTest(test)

1612

1613

test.stopped = os.times()

1613

test.stopped = os.times()

1614

1615

starttime = test.started

1615

starttime = test.started

1616

endtime = test.stopped

1616

endtime = test.stopped

1617

origin = self._firststarttime

1617

origin = self._firststarttime

1618

self.times.append((test.name,

1618

self.times.append((test.name,

1619

endtime[2] - starttime[2], # user space CPU time

1619

endtime[2] - starttime[2], # user space CPU time

1620

endtime[3] - starttime[3], # sys space CPU time

1620

endtime[3] - starttime[3], # sys space CPU time

1621

endtime[4] - starttime[4], # real time

1621

endtime[4] - starttime[4], # real time

1622

starttime[4] - origin, # start date in run context

1622

starttime[4] - origin, # start date in run context

1623

endtime[4] - origin, # end date in run context

1623

endtime[4] - origin, # end date in run context

1624

))

1624

))

1625

1626

if interrupted:

1626

if interrupted:

1627

with iolock:

1627

with iolock:

1628

self.stream.writeln('INTERRUPTED: %s (after %d seconds)' % (

1628

self.stream.writeln('INTERRUPTED: %s (after %d seconds)' % (

1629

test.name, self.times[-1][3]))

1629

test.name, self.times[-1][3]))

1630

1631

class TestSuite(unittest.TestSuite):

1631

class TestSuite(unittest.TestSuite):

1632

"""Custom unittest TestSuite that knows how to execute Mercurial tests."""

1632

"""Custom unittest TestSuite that knows how to execute Mercurial tests."""

1633

1634

def __init__(self, testdir, jobs=1, whitelist=None, blacklist=None,

1634

def __init__(self, testdir, jobs=1, whitelist=None, blacklist=None,

1635

retest=False, keywords=None, loop=False, runs_per_test=1,

1635

retest=False, keywords=None, loop=False, runs_per_test=1,

1636

loadtest=None, showchannels=False,

1636

loadtest=None, showchannels=False,

1637

*args, **kwargs):

1637

*args, **kwargs):

1638

"""Create a new instance that can run tests with a configuration.

1638

"""Create a new instance that can run tests with a configuration.

1639

1640

testdir specifies the directory where tests are executed from. This

1640

testdir specifies the directory where tests are executed from. This

1641

is typically the ``tests`` directory from Mercurial's source

1641

is typically the ``tests`` directory from Mercurial's source

1642

repository.

1642

repository.

1643

1644

jobs specifies the number of jobs to run concurrently. Each test

1644

jobs specifies the number of jobs to run concurrently. Each test

1645

executes on its own thread. Tests actually spawn new processes, so

1645

executes on its own thread. Tests actually spawn new processes, so

1646

state mutation should not be an issue.

1646

state mutation should not be an issue.

1647

1648

If there is only one job, it will use the main thread.

1648

If there is only one job, it will use the main thread.

1649

1650

whitelist and blacklist denote tests that have been whitelisted and

1650

whitelist and blacklist denote tests that have been whitelisted and

1651

blacklisted, respectively. These arguments don't belong in TestSuite.

1651

blacklisted, respectively. These arguments don't belong in TestSuite.

1652

Instead, whitelist and blacklist should be handled by the thing that

1652

Instead, whitelist and blacklist should be handled by the thing that

1653

populates the TestSuite with tests. They are present to preserve

1653

populates the TestSuite with tests. They are present to preserve

1654

backwards compatible behavior which reports skipped tests as part

1654

backwards compatible behavior which reports skipped tests as part

1655

of the results.

1655

of the results.

1656

1657

retest denotes whether to retest failed tests. This arguably belongs

1657

retest denotes whether to retest failed tests. This arguably belongs

1658

outside of TestSuite.

1658

outside of TestSuite.

1659

1660

keywords denotes key words that will be used to filter which tests

1660

keywords denotes key words that will be used to filter which tests

1661

to execute. This arguably belongs outside of TestSuite.

1661

to execute. This arguably belongs outside of TestSuite.

1662

1663

loop denotes whether to loop over tests forever.

1663

loop denotes whether to loop over tests forever.

1664

"""

1664

"""

1665

super(TestSuite, self).__init__(*args, **kwargs)

1665

super(TestSuite, self).__init__(*args, **kwargs)

1666

1667

self._jobs = jobs

1667

self._jobs = jobs

1668

self._whitelist = whitelist

1668

self._whitelist = whitelist

1669

self._blacklist = blacklist

1669

self._blacklist = blacklist

1670

self._retest = retest

1670

self._retest = retest

1671

self._keywords = keywords

1671

self._keywords = keywords

1672

self._loop = loop

1672

self._loop = loop

1673

self._runs_per_test = runs_per_test

1673

self._runs_per_test = runs_per_test

1674

self._loadtest = loadtest

1674

self._loadtest = loadtest

1675

self._showchannels = showchannels

1675

self._showchannels = showchannels

1676

1677

def run(self, result):

1677

def run(self, result):

1678

# We have a number of filters that need to be applied. We do this

1678

# We have a number of filters that need to be applied. We do this

1679

# here instead of inside Test because it makes the running logic for

1679

# here instead of inside Test because it makes the running logic for

1680

# Test simpler.

1680

# Test simpler.

1681

tests = []

1681

tests = []

1682

num_tests = [0]

1682

num_tests = [0]

1683

for test in self._tests:

1683

for test in self._tests:

1684

def get():

1684

def get():

1685

num_tests[0] += 1

1685

num_tests[0] += 1

1686

if getattr(test, 'should_reload', False):

1686

if getattr(test, 'should_reload', False):

1687

return self._loadtest(test.path, num_tests[0])

1687

return self._loadtest(test.path, num_tests[0])

1688

return test

1688

return test

1689

if not os.path.exists(test.path):

1689

if not os.path.exists(test.path):

1690

result.addSkip(test, "Doesn't exist")

1690

result.addSkip(test, "Doesn't exist")

1691

continue

1691

continue

1692

1693

if not (self._whitelist and test.name in self._whitelist):

1693

if not (self._whitelist and test.name in self._whitelist):

1694

if self._blacklist and test.bname in self._blacklist:

1694

if self._blacklist and test.bname in self._blacklist:

1695

result.addSkip(test, 'blacklisted')

1695

result.addSkip(test, 'blacklisted')

1696

continue

1696

continue

1697

1698

if self._retest and not os.path.exists(test.errpath):

1698

if self._retest and not os.path.exists(test.errpath):

1699

result.addIgnore(test, 'not retesting')

1699

result.addIgnore(test, 'not retesting')

1700

continue

1700

continue

1701

1702

if self._keywords:

1702

if self._keywords:

1703

f = open(test.path, 'rb')

1703

f = open(test.path, 'rb')

1704

t = f.read().lower() + test.bname.lower()

1704

t = f.read().lower() + test.bname.lower()

1705

f.close()

1705

f.close()

1706

ignored = False

1706

ignored = False

1707

for k in self._keywords.lower().split():

1707

for k in self._keywords.lower().split():

1708

if k not in t:

1708

if k not in t:

1709

result.addIgnore(test, "doesn't match keyword")

1709

result.addIgnore(test, "doesn't match keyword")

1710

ignored = True

1710

ignored = True

1711

break

1711

break

1712

1713

if ignored:

1713

if ignored:

1714

continue

1714

continue

1715

for _ in xrange(self._runs_per_test):

1715

for _ in xrange(self._runs_per_test):

1716

tests.append(get())

1716

tests.append(get())

1717

1718

runtests = list(tests)

1718

runtests = list(tests)

1719

done = queue.Queue()

1719

done = queue.Queue()

1720

running = 0

1720

running = 0

1721

1722

channels = [""] * self._jobs

1722

channels = [""] * self._jobs

1723

1724

def job(test, result):

1724

def job(test, result):

1725

for n, v in enumerate(channels):

1725

for n, v in enumerate(channels):

1726

if not v:

1726

if not v:

1727

channel = n

1727

channel = n

1728

break

1728

break

1729

channels[channel] = "=" + test.name[5:].split(".")[0]

1729

channels[channel] = "=" + test.name[5:].split(".")[0]

1730

try:

1730

try:

1731

test(result)

1731

test(result)

1732

done.put(None)

1732

done.put(None)

1733

except KeyboardInterrupt:

1733

except KeyboardInterrupt:

1734

pass

1734

pass

1735

except: # re-raises

1735

except: # re-raises

1736

done.put(('!', test, 'run-test raised an error, see traceback'))

1736

done.put(('!', test, 'run-test raised an error, see traceback'))

1737

raise

1737

raise

1738

try:

1738

try:

1739

channels[channel] = ''

1739

channels[channel] = ''

1740

except IndexError:

1740

except IndexError:

1741

pass

1741

pass

1742

1743

def stat():

1743

def stat():

1744

count = 0

1744

count = 0

1745

while channels:

1745

while channels:

1746

d = '\n%03s ' % count

1746

d = '\n%03s ' % count

1747

for n, v in enumerate(channels):

1747

for n, v in enumerate(channels):

1748

if v:

1748

if v:

1749

d += v[0]

1749

d += v[0]

1750

channels[n] = v[1:] or '.'

1750

channels[n] = v[1:] or '.'

1751

else:

1751

else:

1752

d += ' '

1752

d += ' '

1753

d += ' '

1753

d += ' '

1754

with iolock:

1754

with iolock:

1755

sys.stdout.write(d + ' ')

1755

sys.stdout.write(d + ' ')

1756

sys.stdout.flush()

1756

sys.stdout.flush()

1757

for x in xrange(10):

1757

for x in xrange(10):

1758

if channels:

1758

if channels:

1759

time.sleep(.1)

1759

time.sleep(.1)

1760

count += 1

1760

count += 1

1761

1762

stoppedearly = False

1762

stoppedearly = False

1763

1764

if self._showchannels:

1764

if self._showchannels:

1765

statthread = threading.Thread(target=stat, name="stat")

1765

statthread = threading.Thread(target=stat, name="stat")

1766

statthread.start()

1766

statthread.start()

1767

1768

try:

1768

try:

1769

while tests or running:

1769

while tests or running:

1770

if not done.empty() or running == self._jobs or not tests:

1770

if not done.empty() or running == self._jobs or not tests:

1771

try:

1771

try:

1772

done.get(True, 1)

1772

done.get(True, 1)

1773

running -= 1

1773

running -= 1

1774

if result and result.shouldStop:

1774

if result and result.shouldStop:

1775

stoppedearly = True

1775

stoppedearly = True

1776

break

1776

break

1777

except queue.Empty:

1777

except queue.Empty:

1778

continue

1778

continue

1779

if tests and not running == self._jobs:

1779

if tests and not running == self._jobs:

1780

test = tests.pop(0)

1780

test = tests.pop(0)

1781

if self._loop:

1781

if self._loop:

1782

if getattr(test, 'should_reload', False):

1782

if getattr(test, 'should_reload', False):

1783

num_tests[0] += 1

1783

num_tests[0] += 1

1784

tests.append(

1784

tests.append(

1785

self._loadtest(test.name, num_tests[0]))

1785

self._loadtest(test.name, num_tests[0]))

1786

else:

1786

else:

1787

tests.append(test)

1787

tests.append(test)

1788

if self._jobs == 1:

1788

if self._jobs == 1:

1789

job(test, result)

1789

job(test, result)

1790

else:

1790

else:

1791

t = threading.Thread(target=job, name=test.name,

1791

t = threading.Thread(target=job, name=test.name,

1792

args=(test, result))

1792

args=(test, result))

1793

t.start()

1793

t.start()

1794

running += 1

1794

running += 1

1795

1796

# If we stop early we still need to wait on started tests to

1796

# If we stop early we still need to wait on started tests to

1797

# finish. Otherwise, there is a race between the test completing

1797

# finish. Otherwise, there is a race between the test completing

1798

# and the test's cleanup code running. This could result in the

1798

# and the test's cleanup code running. This could result in the

1799

# test reporting incorrect.

1799

# test reporting incorrect.

1800

if stoppedearly:

1800

if stoppedearly:

1801

while running:

1801

while running:

1802

try:

1802

try:

1803

done.get(True, 1)

1803

done.get(True, 1)

1804

running -= 1

1804

running -= 1

1805

except queue.Empty:

1805

except queue.Empty:

1806

continue

1806

continue

1807

except KeyboardInterrupt:

1807

except KeyboardInterrupt:

1808

for test in runtests:

1808

for test in runtests:

1809

test.abort()

1809

test.abort()

1810

1811

channels = []

1811

channels = []

1812

1813

return result

1813

return result

1814

1815

# Save the most recent 5 wall-clock runtimes of each test to a

1815

# Save the most recent 5 wall-clock runtimes of each test to a

1816

# human-readable text file named .testtimes. Tests are sorted

1816

# human-readable text file named .testtimes. Tests are sorted

1817

# alphabetically, while times for each test are listed from oldest to

1817

# alphabetically, while times for each test are listed from oldest to

1818

# newest.

1818

# newest.

1819

1820

def loadtimes(testdir):

1820

def loadtimes(testdir):

1821

times = []

1821

times = []

1822

try:

1822

try:

1823

with open(os.path.join(testdir, b'.testtimes-')) as fp:

1823

with open(os.path.join(testdir, b'.testtimes-')) as fp:

1824

for line in fp:

1824

for line in fp:

1825

ts = line.split()

1825

ts = line.split()

1826

times.append((ts[0], [float(t) for t in ts[1:]]))

1826

times.append((ts[0], [float(t) for t in ts[1:]]))

1827

except IOError as err:

1827

except IOError as err:

1828

if err.errno != errno.ENOENT:

1828

if err.errno != errno.ENOENT:

1829

raise

1829

raise

1830

return times

1830

return times

1831

1832

def savetimes(testdir, result):

1832

def savetimes(testdir, result):

1833

saved = dict(loadtimes(testdir))

1833

saved = dict(loadtimes(testdir))

1834

maxruns = 5

1834

maxruns = 5

1835

skipped = set([str(t[0]) for t in result.skipped])

1835

skipped = set([str(t[0]) for t in result.skipped])

1836

for tdata in result.times:

1836

for tdata in result.times:

1837

test, real = tdata[0], tdata[3]

1837

test, real = tdata[0], tdata[3]

1838

if test not in skipped:

1838

if test not in skipped:

1839

ts = saved.setdefault(test, [])

1839

ts = saved.setdefault(test, [])

1840

ts.append(real)

1840

ts.append(real)

1841

ts[:] = ts[-maxruns:]

1841

ts[:] = ts[-maxruns:]

1842

1843

fd, tmpname = tempfile.mkstemp(prefix=b'.testtimes',

1843

fd, tmpname = tempfile.mkstemp(prefix=b'.testtimes',

1844

dir=testdir, text=True)

1844

dir=testdir, text=True)

1845

with os.fdopen(fd, 'w') as fp:

1845

with os.fdopen(fd, 'w') as fp:

1846

for name, ts in sorted(saved.items()):

1846

for name, ts in sorted(saved.items()):

1847

fp.write('%s %s\n' % (name, ' '.join(['%.3f' % (t,) for t in ts])))

1847

fp.write('%s %s\n' % (name, ' '.join(['%.3f' % (t,) for t in ts])))

1848

timepath = os.path.join(testdir, b'.testtimes')

1848

timepath = os.path.join(testdir, b'.testtimes')

1849

try:

1849

try:

1850

os.unlink(timepath)

1850

os.unlink(timepath)

1851

except OSError:

1851

except OSError:

1852

pass

1852

pass

1853

try:

1853

try:

1854

os.rename(tmpname, timepath)

1854

os.rename(tmpname, timepath)

1855

except OSError:

1855

except OSError:

1856

pass

1856

pass

1857

1858

class TextTestRunner(unittest.TextTestRunner):

1858

class TextTestRunner(unittest.TextTestRunner):

1859

"""Custom unittest test runner that uses appropriate settings."""

1859

"""Custom unittest test runner that uses appropriate settings."""

1860

1861

def __init__(self, runner, *args, **kwargs):

1861

def __init__(self, runner, *args, **kwargs):

1862

super(TextTestRunner, self).__init__(*args, **kwargs)

1862

super(TextTestRunner, self).__init__(*args, **kwargs)

1863

1864

self._runner = runner

1864

self._runner = runner

1865

1866

def run(self, test):

1866

def run(self, test):

1867

result = TestResult(self._runner.options, self.stream,

1867

result = TestResult(self._runner.options, self.stream,

1868

self.descriptions, self.verbosity)

1868

self.descriptions, self.verbosity)

1869

1870

test(result)

1870

test(result)

1871

1872

failed = len(result.failures)

1872

failed = len(result.failures)

1873

warned = len(result.warned)

1873

warned = len(result.warned)

1874

skipped = len(result.skipped)

1874

skipped = len(result.skipped)

1875

ignored = len(result.ignored)

1875

ignored = len(result.ignored)

1876

1877

with iolock:

1877

with iolock:

1878

self.stream.writeln('')

1878

self.stream.writeln('')

1879

1880

if not self._runner.options.noskips:

1880

if not self._runner.options.noskips:

1881

for test, msg in result.skipped:

1881

for test, msg in result.skipped:

1882

self.stream.writeln('Skipped %s: %s' % (test.name, msg))

1882

self.stream.writeln('Skipped %s: %s' % (test.name, msg))

1883

for test, msg in result.warned:

1883

for test, msg in result.warned:

1884

self.stream.writeln('Warned %s: %s' % (test.name, msg))

1884

self.stream.writeln('Warned %s: %s' % (test.name, msg))

1885

for test, msg in result.failures:

1885

for test, msg in result.failures:

1886

self.stream.writeln('Failed %s: %s' % (test.name, msg))

1886

self.stream.writeln('Failed %s: %s' % (test.name, msg))

1887

for test, msg in result.errors:

1887

for test, msg in result.errors:

1888

self.stream.writeln('Errored %s: %s' % (test.name, msg))

1888

self.stream.writeln('Errored %s: %s' % (test.name, msg))

1889

1890

if self._runner.options.xunit:

1890

if self._runner.options.xunit:

1891

with open(self._runner.options.xunit, 'wb') as xuf:

1891

with open(self._runner.options.xunit, 'wb') as xuf:

1892

timesd = dict((t[0], t[3]) for t in result.times)

1892

timesd = dict((t[0], t[3]) for t in result.times)

1893

doc = minidom.Document()

1893

doc = minidom.Document()

1894

s = doc.createElement('testsuite')

1894

s = doc.createElement('testsuite')

1895

s.setAttribute('name', 'run-tests')

1895

s.setAttribute('name', 'run-tests')

1896

s.setAttribute('tests', str(result.testsRun))

1896

s.setAttribute('tests', str(result.testsRun))

1897

s.setAttribute('errors', "0") # TODO

1897

s.setAttribute('errors', "0") # TODO

1898

s.setAttribute('failures', str(failed))

1898

s.setAttribute('failures', str(failed))

1899

s.setAttribute('skipped', str(skipped + ignored))

1899

s.setAttribute('skipped', str(skipped + ignored))

1900

doc.appendChild(s)

1900

doc.appendChild(s)

1901

for tc in result.successes:

1901

for tc in result.successes:

1902

t = doc.createElement('testcase')

1902

t = doc.createElement('testcase')

1903

t.setAttribute('name', tc.name)

1903

t.setAttribute('name', tc.name)

1904

t.setAttribute('time', '%.3f' % timesd[tc.name])

1904

t.setAttribute('time', '%.3f' % timesd[tc.name])

1905

s.appendChild(t)

1905

s.appendChild(t)

1906

for tc, err in sorted(result.faildata.items()):

1906

for tc, err in sorted(result.faildata.items()):

1907

t = doc.createElement('testcase')

1907

t = doc.createElement('testcase')

1908

t.setAttribute('name', tc)

1908

t.setAttribute('name', tc)

1909

t.setAttribute('time', '%.3f' % timesd[tc])

1909

t.setAttribute('time', '%.3f' % timesd[tc])

1910

# createCDATASection expects a unicode or it will

1910

# createCDATASection expects a unicode or it will

1911

# convert using default conversion rules, which will

1911

# convert using default conversion rules, which will

1912

# fail if string isn't ASCII.

1912

# fail if string isn't ASCII.

1913

err = cdatasafe(err).decode('utf-8', 'replace')

1913

err = cdatasafe(err).decode('utf-8', 'replace')

1914

cd = doc.createCDATASection(err)

1914

cd = doc.createCDATASection(err)

1915

t.appendChild(cd)

1915

t.appendChild(cd)

1916

s.appendChild(t)

1916

s.appendChild(t)

1917

xuf.write(doc.toprettyxml(indent=' ', encoding='utf-8'))

1917

xuf.write(doc.toprettyxml(indent=' ', encoding='utf-8'))

1918

1919

if self._runner.options.json:

1919

if self._runner.options.json:

1920

jsonpath = os.path.join(self._runner._testdir, b'report.json')

1920

jsonpath = os.path.join(self._runner._testdir, b'report.json')

1921

with open(jsonpath, 'w') as fp:

1921

with open(jsonpath, 'w') as fp:

1922

timesd = {}

1922

timesd = {}

1923

for tdata in result.times:

1923

for tdata in result.times:

1924

test = tdata[0]

1924

test = tdata[0]

1925

timesd[test] = tdata[1:]

1925

timesd[test] = tdata[1:]

1926

1927

outcome = {}

1927

outcome = {}

1928

groups = [('success', ((tc, None)

1928

groups = [('success', ((tc, None)

1929

for tc in result.successes)),

1929

for tc in result.successes)),

1930

('failure', result.failures),

1930

('failure', result.failures),

1931

('skip', result.skipped)]

1931

('skip', result.skipped)]

1932

for res, testcases in groups:

1932

for res, testcases in groups:

1933

for tc, __ in testcases:

1933

for tc, __ in testcases:

1934

if tc.name in timesd:

1934

if tc.name in timesd:

1935

diff = result.faildata.get(tc.name, b'')

1935

diff = result.faildata.get(tc.name, b'')

1936

tres = {'result': res,

1936

tres = {'result': res,

1937

'time': ('%0.3f' % timesd[tc.name][2]),

1937

'time': ('%0.3f' % timesd[tc.name][2]),

1938

'cuser': ('%0.3f' % timesd[tc.name][0]),

1938

'cuser': ('%0.3f' % timesd[tc.name][0]),

1939

'csys': ('%0.3f' % timesd[tc.name][1]),

1939

'csys': ('%0.3f' % timesd[tc.name][1]),

1940

'start': ('%0.3f' % timesd[tc.name][3]),

1940

'start': ('%0.3f' % timesd[tc.name][3]),

1941

'end': ('%0.3f' % timesd[tc.name][4]),

1941

'end': ('%0.3f' % timesd[tc.name][4]),

1942

'diff': diff.decode('unicode_escape'),

1942

'diff': diff.decode('unicode_escape'),

1943

}

1943

}

1944

else:

1944

else:

1945

# blacklisted test

1945

# blacklisted test

1946

tres = {'result': res}

1946

tres = {'result': res}

1947

1948

outcome[tc.name] = tres

1948

outcome[tc.name] = tres

1949

jsonout = json.dumps(outcome, sort_keys=True, indent=4,

1949

jsonout = json.dumps(outcome, sort_keys=True, indent=4,

1950

separators=(',', ': '))

1950

separators=(',', ': '))

1951

fp.writelines(("testreport =", jsonout))

1951

fp.writelines(("testreport =", jsonout))

1952

1953

self._runner._checkhglib('Tested')

1953

self._runner._checkhglib('Tested')

1954

1955

savetimes(self._runner._testdir, result)

1955

savetimes(self._runner._testdir, result)

1956

1957

if failed and self._runner.options.known_good_rev:

1957

if failed and self._runner.options.known_good_rev:

1958

def nooutput(args):

1958

def nooutput(args):

1959

p = subprocess.Popen(args, stderr=subprocess.STDOUT,

1959

p = subprocess.Popen(args, stderr=subprocess.STDOUT,

1960

stdout=subprocess.PIPE)

1960

stdout=subprocess.PIPE)

1961

p.stdout.read()

1961

p.stdout.read()

1962

p.wait()

1962

p.wait()

1963

for test, msg in result.failures:

1963

for test, msg in result.failures:

1964

nooutput(['hg', 'bisect', '--reset']),

1964

nooutput(['hg', 'bisect', '--reset']),

1965

nooutput(['hg', 'bisect', '--bad', '.'])

1965

nooutput(['hg', 'bisect', '--bad', '.'])

1966

nooutput(['hg', 'bisect', '--good',

1966

nooutput(['hg', 'bisect', '--good',

1967

self._runner.options.known_good_rev])

1967

self._runner.options.known_good_rev])

1968

# TODO: we probably need to forward some options

1968

# TODO: we probably need to forward some options

1969

# that alter hg's behavior inside the tests.

1969

# that alter hg's behavior inside the tests.

1970

rtc = '%s %s %s' % (sys.executable, sys.argv[0], test)

1970

rtc = '%s %s %s' % (sys.executable, sys.argv[0], test)

1971

sub = subprocess.Popen(['hg', 'bisect', '--command', rtc],

1971

sub = subprocess.Popen(['hg', 'bisect', '--command', rtc],

1972

stderr=subprocess.STDOUT,

1972

stderr=subprocess.STDOUT,

1973

stdout=subprocess.PIPE)

1973

stdout=subprocess.PIPE)

1974

data = sub.stdout.read()

1974

data = sub.stdout.read()

1975

sub.wait()

1975

sub.wait()

1976

m = re.search(

1976

m = re.search(

1977

(r'\nThe first (?P<goodbad>bad|good) revision '

1977

(r'\nThe first (?P<goodbad>bad|good) revision '

1978

r'is:\nchangeset: +\d+:(?P<node>[a-f0-9]+)\n.*\n'

1978

r'is:\nchangeset: +\d+:(?P<node>[a-f0-9]+)\n.*\n'

1979

r'summary: +(?P<summary>[^\n]+)\n'),

1979

r'summary: +(?P<summary>[^\n]+)\n'),

1980

data, (re.MULTILINE | re.DOTALL))

1980

data, (re.MULTILINE | re.DOTALL))

1981

if m is None:

1981

if m is None:

1982

self.stream.writeln(

1982

self.stream.writeln(

1983

'Failed to identify failure point for %s' % test)

1983

'Failed to identify failure point for %s' % test)

1984

continue

1984

continue

1985

dat = m.groupdict()

1985

dat = m.groupdict()

1986

verb = 'broken' if dat['goodbad'] == 'bad' else 'fixed'

1986

verb = 'broken' if dat['goodbad'] == 'bad' else 'fixed'

1987

self.stream.writeln(

1987

self.stream.writeln(

1988

'%s %s by %s (%s)' % (

1988

'%s %s by %s (%s)' % (

1989

test, verb, dat['node'], dat['summary']))

1989

test, verb, dat['node'], dat['summary']))

1990

self.stream.writeln(

1990

self.stream.writeln(

1991

'# Ran %d tests, %d skipped, %d warned, %d failed.'

1991

'# Ran %d tests, %d skipped, %d warned, %d failed.'

1992

% (result.testsRun,

1992

% (result.testsRun,

1993

skipped + ignored, warned, failed))

1993

skipped + ignored, warned, failed))

1994

if failed:

1994

if failed:

1995

self.stream.writeln('python hash seed: %s' %

1995

self.stream.writeln('python hash seed: %s' %

1996

os.environ['PYTHONHASHSEED'])

1996

os.environ['PYTHONHASHSEED'])

1997

if self._runner.options.time:

1997

if self._runner.options.time:

1998

self.printtimes(result.times)

1998

self.printtimes(result.times)

1999

2000

return result

2000

return result

2001

2002

def printtimes(self, times):

2002

def printtimes(self, times):

2003

# iolock held by run

2003

# iolock held by run

2004

self.stream.writeln('# Producing time report')

2004

self.stream.writeln('# Producing time report')

2005

times.sort(key=lambda t: (t[3]))

2005

times.sort(key=lambda t: (t[3]))

2006

cols = '%7.3f %7.3f %7.3f %7.3f %7.3f %s'

2006

cols = '%7.3f %7.3f %7.3f %7.3f %7.3f %s'

2007

self.stream.writeln('%-7s %-7s %-7s %-7s %-7s %s' %

2007

self.stream.writeln('%-7s %-7s %-7s %-7s %-7s %s' %

2008

('start', 'end', 'cuser', 'csys', 'real', 'Test'))

2008

('start', 'end', 'cuser', 'csys', 'real', 'Test'))

2009

for tdata in times:

2009

for tdata in times:

2010

test = tdata[0]

2010

test = tdata[0]

2011

cuser, csys, real, start, end = tdata[1:6]

2011

cuser, csys, real, start, end = tdata[1:6]

2012

self.stream.writeln(cols % (start, end, cuser, csys, real, test))

2012

self.stream.writeln(cols % (start, end, cuser, csys, real, test))

2013

2014

class TestRunner(object):

2014

class TestRunner(object):

2015

"""Holds context for executing tests.

2015

"""Holds context for executing tests.

2016

2017

Tests rely on a lot of state. This object holds it for them.

2017

Tests rely on a lot of state. This object holds it for them.

2018

"""

2018

"""

2019

2020

# Programs required to run tests.

2020

# Programs required to run tests.

2021

REQUIREDTOOLS = [

2021

REQUIREDTOOLS = [

2022

os.path.basename(_bytespath(sys.executable)),

2022

os.path.basename(_bytespath(sys.executable)),

2023

b'diff',

2023

b'diff',

2024

b'grep',

2024

b'grep',

2025

b'unzip',

2025

b'unzip',

2026

b'gunzip',

2026

b'gunzip',

2027

b'bunzip2',

2027

b'bunzip2',

2028

b'sed',

2028

b'sed',

2029

]

2029

]

2030

2031

# Maps file extensions to test class.

2031

# Maps file extensions to test class.

2032

TESTTYPES = [

2032

TESTTYPES = [

2033

(b'.py', PythonTest),

2033

(b'.py', PythonTest),

2034

(b'.t', TTest),

2034

(b'.t', TTest),

2035

]

2035

]

2036

2037

def __init__(self):

2037

def __init__(self):

2038

self.options = None

2038

self.options = None

2039

self._hgroot = None

2039

self._hgroot = None

2040

self._testdir = None

2040

self._testdir = None

2041

self._hgtmp = None

2041

self._hgtmp = None

2042

self._installdir = None

2042

self._installdir = None

2043

self._bindir = None

2043

self._bindir = None

2044

self._tmpbinddir = None

2044

self._tmpbinddir = None

2045

self._pythondir = None

2045

self._pythondir = None

2046

self._coveragefile = None

2046

self._coveragefile = None

2047

self._createdfiles = []

2047

self._createdfiles = []

2048

self._hgcommand = None

2048

self._hgcommand = None

2049

self._hgpath = None

2049

self._hgpath = None

2050

self._portoffset = 0

2050

self._portoffset = 0

2051

self._ports = {}

2051

self._ports = {}

2052

2053

def run(self, args, parser=None):

2053

def run(self, args, parser=None):

2054

"""Run the test suite."""

2054

"""Run the test suite."""

2055

oldmask = os.umask(0o22)

2055

oldmask = os.umask(0o22)

2056

try:

2056

try:

2057

parser = parser or getparser()

2057

parser = parser or getparser()

2058

options, args = parseargs(args, parser)

2058

options, args = parseargs(args, parser)

2059

# positional arguments are paths to test files to run, so

2059

# positional arguments are paths to test files to run, so

2060

# we make sure they're all bytestrings

2060

# we make sure they're all bytestrings

2061

args = [_bytespath(a) for a in args]

2061

args = [_bytespath(a) for a in args]

2062

self.options = options

2062

self.options = options

2063

2064

self._checktools()

2064

self._checktools()

2065

tests = self.findtests(args)

2065

tests = self.findtests(args)

2066

if options.profile_runner:

2066

if options.profile_runner:

2067

import statprof

2067

import statprof

2068

statprof.start()

2068

statprof.start()

2069

result = self._run(tests)

2069

result = self._run(tests)

2070

if options.profile_runner:

2070

if options.profile_runner:

2071

statprof.stop()

2071

statprof.stop()

2072

statprof.display()

2072

statprof.display()

2073

return result

2073

return result

2074

2075

finally:

2075

finally:

2076

os.umask(oldmask)

2076

os.umask(oldmask)

2077

2078

def _run(self, tests):

2078

def _run(self, tests):

2079

if self.options.random:

2079

if self.options.random:

2080

random.shuffle(tests)

2080

random.shuffle(tests)

2081

else:

2081

else:

2082

# keywords for slow tests

2082

# keywords for slow tests

2083

slow = {b'svn': 10,

2083

slow = {b'svn': 10,

2084

b'cvs': 10,

2084

b'cvs': 10,

2085

b'hghave': 10,

2085

b'hghave': 10,

2086

b'largefiles-update': 10,

2086

b'largefiles-update': 10,

2087

b'run-tests': 10,

2087

b'run-tests': 10,

2088

b'corruption': 10,

2088

b'corruption': 10,

2089

b'race': 10,

2089

b'race': 10,

2090

b'i18n': 10,

2090

b'i18n': 10,

2091

b'check': 100,

2091

b'check': 100,

2092

b'gendoc': 100,

2092

b'gendoc': 100,

2093

b'contrib-perf': 200,

2093

b'contrib-perf': 200,

2094

}

2094

}

2095

perf = {}

2095

perf = {}

2096

def sortkey(f):

2096

def sortkey(f):

2097

# run largest tests first, as they tend to take the longest

2097

# run largest tests first, as they tend to take the longest

2098

try:

2098

try:

2099

return perf[f]

2099

return perf[f]

2100

except KeyError:

2100

except KeyError:

2101

try:

2101

try:

2102

val = -os.stat(f).st_size

2102

val = -os.stat(f).st_size

2103

except OSError as e:

2103

except OSError as e:

2104

if e.errno != errno.ENOENT:

2104

if e.errno != errno.ENOENT:

2105

raise

2105

raise

2106

perf[f] = -1e9 # file does not exist, tell early

2106

perf[f] = -1e9 # file does not exist, tell early

2107

return -1e9

2107

return -1e9

2108

for kw, mul in slow.items():

2108

for kw, mul in slow.items():

2109

if kw in f:

2109

if kw in f:

2110

val *= mul

2110

val *= mul

2111

if f.endswith(b'.py'):

2111

if f.endswith(b'.py'):

2112

val /= 10.0

2112

val /= 10.0

2113

perf[f] = val / 1000.0

2113

perf[f] = val / 1000.0

2114

return perf[f]

2114

return perf[f]

2115

tests.sort(key=sortkey)

2115

tests.sort(key=sortkey)

2116

2117

self._testdir = osenvironb[b'TESTDIR'] = getattr(

2117

self._testdir = osenvironb[b'TESTDIR'] = getattr(

2118

os, 'getcwdb', os.getcwd)()

2118

os, 'getcwdb', os.getcwd)()

2119

2120

if 'PYTHONHASHSEED' not in os.environ:

2120

if 'PYTHONHASHSEED' not in os.environ:

2121

# use a random python hash seed all the time

2121

# use a random python hash seed all the time

2122

# we do the randomness ourself to know what seed is used

2122

# we do the randomness ourself to know what seed is used

2123

os.environ['PYTHONHASHSEED'] = str(random.getrandbits(32))

2123

os.environ['PYTHONHASHSEED'] = str(random.getrandbits(32))

2124

2125

if self.options.tmpdir:

2125

if self.options.tmpdir:

2126

self.options.keep_tmpdir = True

2126

self.options.keep_tmpdir = True

2127

tmpdir = _bytespath(self.options.tmpdir)

2127

tmpdir = _bytespath(self.options.tmpdir)

2128

if os.path.exists(tmpdir):

2128

if os.path.exists(tmpdir):

2129

# Meaning of tmpdir has changed since 1.3: we used to create

2129

# Meaning of tmpdir has changed since 1.3: we used to create

2130

# HGTMP inside tmpdir; now HGTMP is tmpdir. So fail if

2130

# HGTMP inside tmpdir; now HGTMP is tmpdir. So fail if

2131

# tmpdir already exists.

2131

# tmpdir already exists.

2132

print("error: temp dir %r already exists" % tmpdir)

2132

print("error: temp dir %r already exists" % tmpdir)

2133

return 1

2133

return 1

2134

2135

# Automatically removing tmpdir sounds convenient, but could

2135

# Automatically removing tmpdir sounds convenient, but could

2136

# really annoy anyone in the habit of using "--tmpdir=/tmp"

2136

# really annoy anyone in the habit of using "--tmpdir=/tmp"

2137

# or "--tmpdir=$HOME".

2137

# or "--tmpdir=$HOME".

2138

#vlog("# Removing temp dir", tmpdir)

2138

#vlog("# Removing temp dir", tmpdir)

2139

#shutil.rmtree(tmpdir)

2139

#shutil.rmtree(tmpdir)

2140

os.makedirs(tmpdir)

2140

os.makedirs(tmpdir)

2141

else:

2141

else:

2142

d = None

2142

d = None

2143

if os.name == 'nt':

2143

if os.name == 'nt':

2144

# without this, we get the default temp dir location, but

2144

# without this, we get the default temp dir location, but

2145

# in all lowercase, which causes troubles with paths (issue3490)

2145

# in all lowercase, which causes troubles with paths (issue3490)

2146

d = osenvironb.get(b'TMP', None)

2146

d = osenvironb.get(b'TMP', None)

2147

tmpdir = tempfile.mkdtemp(b'', b'hgtests.', d)

2147

tmpdir = tempfile.mkdtemp(b'', b'hgtests.', d)

2148

2149

self._hgtmp = osenvironb[b'HGTMP'] = (

2149

self._hgtmp = osenvironb[b'HGTMP'] = (

2150

os.path.realpath(tmpdir))

2150

os.path.realpath(tmpdir))

2151

2152

if self.options.with_hg:

2152

if self.options.with_hg:

2153

self._installdir = None

2153

self._installdir = None

2154

whg = self.options.with_hg

2154

whg = self.options.with_hg

2155

self._bindir = os.path.dirname(os.path.realpath(whg))

2155

self._bindir = os.path.dirname(os.path.realpath(whg))

2156

assert isinstance(self._bindir, bytes)

2156

assert isinstance(self._bindir, bytes)

2157

self._hgcommand = os.path.basename(whg)

2157

self._hgcommand = os.path.basename(whg)

2158

self._tmpbindir = os.path.join(self._hgtmp, b'install', b'bin')

2158

self._tmpbindir = os.path.join(self._hgtmp, b'install', b'bin')

2159

os.makedirs(self._tmpbindir)

2159

os.makedirs(self._tmpbindir)

2160

2161

# This looks redundant with how Python initializes sys.path from

2161

# This looks redundant with how Python initializes sys.path from

2162

# the location of the script being executed. Needed because the

2162

# the location of the script being executed. Needed because the

2163

# "hg" specified by --with-hg is not the only Python script

2163

# "hg" specified by --with-hg is not the only Python script

2164

# executed in the test suite that needs to import 'mercurial'

2164

# executed in the test suite that needs to import 'mercurial'

2165

# ... which means it's not really redundant at all.

2165

# ... which means it's not really redundant at all.

2166

self._pythondir = self._bindir

2166

self._pythondir = self._bindir

2167

else:

2167

else:

2168

self._installdir = os.path.join(self._hgtmp, b"install")

2168

self._installdir = os.path.join(self._hgtmp, b"install")

2169

self._bindir = os.path.join(self._installdir, b"bin")

2169

self._bindir = os.path.join(self._installdir, b"bin")

2170

self._hgcommand = b'hg'

2170

self._hgcommand = b'hg'

2171

self._tmpbindir = self._bindir

2171

self._tmpbindir = self._bindir

2172

self._pythondir = os.path.join(self._installdir, b"lib", b"python")

2172

self._pythondir = os.path.join(self._installdir, b"lib", b"python")

2173

2174

# set CHGHG, then replace "hg" command by "chg"

2174

# set CHGHG, then replace "hg" command by "chg"

2175

chgbindir = self._bindir

2175

chgbindir = self._bindir

2176

if self.options.chg or self.options.with_chg:

2176

if self.options.chg or self.options.with_chg:

2177

osenvironb[b'CHGHG'] = os.path.join(self._bindir, self._hgcommand)

2177

osenvironb[b'CHGHG'] = os.path.join(self._bindir, self._hgcommand)

2178

else:

2178

else:

2179

osenvironb.pop(b'CHGHG', None) # drop flag for hghave

2179

osenvironb.pop(b'CHGHG', None) # drop flag for hghave

2180

if self.options.chg:

2180

if self.options.chg:

2181

self._hgcommand = b'chg'

2181

self._hgcommand = b'chg'

2182

elif self.options.with_chg:

2182

elif self.options.with_chg:

2183

chgbindir = os.path.dirname(os.path.realpath(self.options.with_chg))

2183

chgbindir = os.path.dirname(os.path.realpath(self.options.with_chg))

2184

self._hgcommand = os.path.basename(self.options.with_chg)

2184

self._hgcommand = os.path.basename(self.options.with_chg)

2185

2186

osenvironb[b"BINDIR"] = self._bindir

2186

osenvironb[b"BINDIR"] = self._bindir

2187

osenvironb[b"PYTHON"] = PYTHON

2187

osenvironb[b"PYTHON"] = PYTHON

2188

2189

if self.options.with_python3:

2189

if self.options.with_python3:

2190

osenvironb[b'PYTHON3'] = self.options.with_python3

2190

osenvironb[b'PYTHON3'] = self.options.with_python3

2191

2192

fileb = _bytespath(__file__)

2192

fileb = _bytespath(__file__)

2193

runtestdir = os.path.abspath(os.path.dirname(fileb))

2193

runtestdir = os.path.abspath(os.path.dirname(fileb))

2194

osenvironb[b'RUNTESTDIR'] = runtestdir

2194

osenvironb[b'RUNTESTDIR'] = runtestdir

2195

if PYTHON3:

2195

if PYTHON3:

2196

sepb = _bytespath(os.pathsep)

2196

sepb = _bytespath(os.pathsep)

2197

else:

2197

else:

2198

sepb = os.pathsep

2198

sepb = os.pathsep

2199

path = [self._bindir, runtestdir] + osenvironb[b"PATH"].split(sepb)

2199

path = [self._bindir, runtestdir] + osenvironb[b"PATH"].split(sepb)

2200

if os.path.islink(__file__):

2200

if os.path.islink(__file__):

2201

# test helper will likely be at the end of the symlink

2201

# test helper will likely be at the end of the symlink

2202

realfile = os.path.realpath(fileb)

2202

realfile = os.path.realpath(fileb)

2203

realdir = os.path.abspath(os.path.dirname(realfile))

2203

realdir = os.path.abspath(os.path.dirname(realfile))

2204

path.insert(2, realdir)

2204

path.insert(2, realdir)

2205

if chgbindir != self._bindir:

2205

if chgbindir != self._bindir:

2206

path.insert(1, chgbindir)

2206

path.insert(1, chgbindir)

2207

if self._testdir != runtestdir:

2207

if self._testdir != runtestdir:

2208

path = [self._testdir] + path

2208

path = [self._testdir] + path

2209

if self._tmpbindir != self._bindir:

2209

if self._tmpbindir != self._bindir:

2210

path = [self._tmpbindir] + path

2210

path = [self._tmpbindir] + path

2211

osenvironb[b"PATH"] = sepb.join(path)

2211

osenvironb[b"PATH"] = sepb.join(path)

2212

2213

# Include TESTDIR in PYTHONPATH so that out-of-tree extensions

2213

# Include TESTDIR in PYTHONPATH so that out-of-tree extensions

2214

# can run .../tests/run-tests.py test-foo where test-foo

2214

# can run .../tests/run-tests.py test-foo where test-foo

2215

# adds an extension to HGRC. Also include run-test.py directory to

2215

# adds an extension to HGRC. Also include run-test.py directory to

2216

# import modules like heredoctest.

2216

# import modules like heredoctest.

2217

pypath = [self._pythondir, self._testdir, runtestdir]

2217

pypath = [self._pythondir, self._testdir, runtestdir]

2218

# We have to augment PYTHONPATH, rather than simply replacing

2218

# We have to augment PYTHONPATH, rather than simply replacing

2219

# it, in case external libraries are only available via current

2219

# it, in case external libraries are only available via current

2220

# PYTHONPATH. (In particular, the Subversion bindings on OS X

2220

# PYTHONPATH. (In particular, the Subversion bindings on OS X

2221

# are in /opt/subversion.)

2221

# are in /opt/subversion.)

2222

oldpypath = osenvironb.get(IMPL_PATH)

2222

oldpypath = osenvironb.get(IMPL_PATH)

2223

if oldpypath:

2223

if oldpypath:

2224

pypath.append(oldpypath)

2224

pypath.append(oldpypath)

2225

osenvironb[IMPL_PATH] = sepb.join(pypath)

2225

osenvironb[IMPL_PATH] = sepb.join(pypath)

2226

2227

if self.options.pure:

2227

if self.options.pure:

2228

os.environ["HGTEST_RUN_TESTS_PURE"] = "--pure"

2228

os.environ["HGTEST_RUN_TESTS_PURE"] = "--pure"

2229

os.environ["HGMODULEPOLICY"] = "py"

2229

os.environ["HGMODULEPOLICY"] = "py"

2230

2231

if self.options.allow_slow_tests:

2231

if self.options.allow_slow_tests:

2232

os.environ["HGTEST_SLOW"] = "slow"

2232

os.environ["HGTEST_SLOW"] = "slow"

2233

elif 'HGTEST_SLOW' in os.environ:

2233

elif 'HGTEST_SLOW' in os.environ:

2234

del os.environ['HGTEST_SLOW']

2234

del os.environ['HGTEST_SLOW']

2235

2236

self._coveragefile = os.path.join(self._testdir, b'.coverage')

2236

self._coveragefile = os.path.join(self._testdir, b'.coverage')

2237

2238

vlog("# Using TESTDIR", self._testdir)

2238

vlog("# Using TESTDIR", self._testdir)

2239

vlog("# Using RUNTESTDIR", osenvironb[b'RUNTESTDIR'])

2239

vlog("# Using RUNTESTDIR", osenvironb[b'RUNTESTDIR'])

2240

vlog("# Using HGTMP", self._hgtmp)

2240

vlog("# Using HGTMP", self._hgtmp)

2241

vlog("# Using PATH", os.environ["PATH"])

2241

vlog("# Using PATH", os.environ["PATH"])

2242

vlog("# Using", IMPL_PATH, osenvironb[IMPL_PATH])

2242

vlog("# Using", IMPL_PATH, osenvironb[IMPL_PATH])

2243

2244

try:

2244

try:

2245

return self._runtests(tests) or 0

2245

return self._runtests(tests) or 0

2246

finally:

2246

finally:

2247

time.sleep(.1)

2247

time.sleep(.1)

2248

self._cleanup()

2248

self._cleanup()

2249

2250

def findtests(self, args):

2250

def findtests(self, args):

2251

"""Finds possible test files from arguments.

2251

"""Finds possible test files from arguments.

2252

2253

If you wish to inject custom tests into the test harness, this would

2253

If you wish to inject custom tests into the test harness, this would

2254

be a good function to monkeypatch or override in a derived class.

2254

be a good function to monkeypatch or override in a derived class.

2255

"""

2255

"""

2256

if not args:

2256

if not args:

2257

if self.options.changed:

2257

if self.options.changed:

2258

proc = Popen4('hg st --rev "%s" -man0 .' %

2258

proc = Popen4('hg st --rev "%s" -man0 .' %

2259

self.options.changed, None, 0)

2259

self.options.changed, None, 0)

2260

stdout, stderr = proc.communicate()

2260

stdout, stderr = proc.communicate()

2261

args = stdout.strip(b'\0').split(b'\0')

2261

args = stdout.strip(b'\0').split(b'\0')

2262

else:

2262

else:

2263

args = os.listdir(b'.')

2263

args = os.listdir(b'.')

2264

2265

return [t for t in args

2265

return [t for t in args

2266

if os.path.basename(t).startswith(b'test-')

2266

if os.path.basename(t).startswith(b'test-')

2267

and (t.endswith(b'.py') or t.endswith(b'.t'))]

2267

and (t.endswith(b'.py') or t.endswith(b'.t'))]

2268

2269

def _runtests(self, tests):

2269

def _runtests(self, tests):

2270

try:

2270

try:

2271

if self._installdir:

2271

if self._installdir:

2272

self._installhg()

2272

self._installhg()

2273

self._checkhglib("Testing")

2273

self._checkhglib("Testing")

2274

else:

2274

else:

2275

self._usecorrectpython()

2275

self._usecorrectpython()

2276

if self.options.chg:

2276

if self.options.chg:

2277

assert self._installdir

2277

assert self._installdir

2278

self._installchg()

2278

self._installchg()

2279

2280

if self.options.restart:

2280

if self.options.restart:

2281

orig = list(tests)

2281

orig = list(tests)

2282

while tests:

2282

while tests:

2283

if os.path.exists(tests[0] + ".err"):

2283

if os.path.exists(tests[0] + ".err"):

2284

break

2284

break

2285

tests.pop(0)

2285

tests.pop(0)

2286

if not tests:

2286

if not tests:

2287

print("running all tests")

2287

print("running all tests")

2288

tests = orig

2288

tests = orig

2289

2290

tests = [self._gettest(t, i) for i, t in enumerate(tests)]

2290

tests = [self._gettest(t, i) for i, t in enumerate(tests)]

2291

2292

failed = False

2292

failed = False

2293

warned = False

2293

warned = False

2294

kws = self.options.keywords

2294

kws = self.options.keywords

2295

if kws is not None and PYTHON3:

2295

if kws is not None and PYTHON3:

2296

kws = kws.encode('utf-8')

2296

kws = kws.encode('utf-8')

2297

2298

suite = TestSuite(self._testdir,

2298

suite = TestSuite(self._testdir,

2299

jobs=self.options.jobs,

2299

jobs=self.options.jobs,

2300

whitelist=self.options.whitelisted,

2300

whitelist=self.options.whitelisted,

2301

blacklist=self.options.blacklist,

2301

blacklist=self.options.blacklist,

2302

retest=self.options.retest,

2302

retest=self.options.retest,

2303

keywords=kws,

2303

keywords=kws,

2304

loop=self.options.loop,

2304

loop=self.options.loop,

2305

runs_per_test=self.options.runs_per_test,

2305

runs_per_test=self.options.runs_per_test,

2306

showchannels=self.options.showchannels,

2306

showchannels=self.options.showchannels,

2307

tests=tests, loadtest=self._gettest)

2307

tests=tests, loadtest=self._gettest)

2308

verbosity = 1

2308

verbosity = 1

2309

if self.options.verbose:

2309

if self.options.verbose:

2310

verbosity = 2

2310

verbosity = 2

2311

runner = TextTestRunner(self, verbosity=verbosity)

2311

runner = TextTestRunner(self, verbosity=verbosity)

2312

result = runner.run(suite)

2312

result = runner.run(suite)

2313

2314

if result.failures:

2314

if result.failures:

2315

failed = True

2315

failed = True

2316

if result.warned:

2316

if result.warned:

2317

warned = True

2317

warned = True

2318

2319

if self.options.anycoverage:

2319

if self.options.anycoverage:

2320

self._outputcoverage()

2320

self._outputcoverage()

2321

except KeyboardInterrupt:

2321

except KeyboardInterrupt:

2322

failed = True

2322

failed = True

2323

print("\ninterrupted!")

2323

print("\ninterrupted!")

2324

2325

if failed:

2325

if failed:

2326

return 1

2326

return 1

2327

if warned:

2327

if warned:

2328

return 80

2328

return 80

2329

2330

def _getport(self, count):

2330

def _getport(self, count):

2331

port = self._ports.get(count) # do we have a cached entry?

2331

port = self._ports.get(count) # do we have a cached entry?

2332

if port is None:

2332

if port is None:

2333

portneeded = 3

2333

portneeded = 3

2334

# above 100 tries we just give up and let test reports failure

2334

# above 100 tries we just give up and let test reports failure

2335

for tries in xrange(100):

2335

for tries in xrange(100):

2336

allfree = True

2336

allfree = True

2337

port = self.options.port + self._portoffset

2337

port = self.options.port + self._portoffset

2338

for idx in xrange(portneeded):

2338

for idx in xrange(portneeded):

2339

if not checkportisavailable(port + idx):

2339

if not checkportisavailable(port + idx):

2340

allfree = False

2340

allfree = False

2341

break

2341

break

2342

self._portoffset += portneeded

2342

self._portoffset += portneeded

2343

if allfree:

2343

if allfree:

2344

break

2344

break

2345

self._ports[count] = port

2345

self._ports[count] = port

2346

return port

2346

return port

2347

2348

def _gettest(self, test, count):

2348

def _gettest(self, test, count):

2349

"""Obtain a Test by looking at its filename.

2349

"""Obtain a Test by looking at its filename.

2350

2351

Returns a Test instance. The Test may not be runnable if it doesn't

2351

Returns a Test instance. The Test may not be runnable if it doesn't

2352

map to a known type.

2352

map to a known type.

2353

"""

2353

"""

2354

lctest = test.lower()

2354

lctest = test.lower()

2355

testcls = Test

2355

testcls = Test

2356

2357

for ext, cls in self.TESTTYPES:

2357

for ext, cls in self.TESTTYPES:

2358

if lctest.endswith(ext):

2358

if lctest.endswith(ext):

2359

testcls = cls

2359

testcls = cls

2360

break

2360

break

2361

2362

refpath = os.path.join(self._testdir, test)

2362

refpath = os.path.join(self._testdir, test)

2363

tmpdir = os.path.join(self._hgtmp, b'child%d' % count)

2363

tmpdir = os.path.join(self._hgtmp, b'child%d' % count)

2364

2365

t = testcls(refpath, tmpdir,

2365

t = testcls(refpath, tmpdir,

2366

keeptmpdir=self.options.keep_tmpdir,

2366

keeptmpdir=self.options.keep_tmpdir,

2367

debug=self.options.debug,

2367

debug=self.options.debug,

2368

timeout=self.options.timeout,

2368

timeout=self.options.timeout,

2369

startport=self._getport(count),

2369

startport=self._getport(count),

2370

extraconfigopts=self.options.extra_config_opt,

2370

extraconfigopts=self.options.extra_config_opt,

2371

py3kwarnings=self.options.py3k_warnings,

2371

py3kwarnings=self.options.py3k_warnings,

2372

shell=self.options.shell,

2372

shell=self.options.shell,

2373

hgcommand=self._hgcommand,

2373

hgcommand=self._hgcommand,

2374

usechg=bool(self.options.with_chg or self.options.chg),

2374

usechg=bool(self.options.with_chg or self.options.chg),

2375

useipv6=useipv6)

2375

useipv6=useipv6)

2376

t.should_reload = True

2376

t.should_reload = True

2377

return t

2377

return t

2378

2379

def _cleanup(self):

2379

def _cleanup(self):

2380

"""Clean up state from this test invocation."""

2380

"""Clean up state from this test invocation."""

2381

if self.options.keep_tmpdir:

2381

if self.options.keep_tmpdir:

2382

return

2382

return

2383

2384

vlog("# Cleaning up HGTMP", self._hgtmp)

2384

vlog("# Cleaning up HGTMP", self._hgtmp)

2385

shutil.rmtree(self._hgtmp, True)

2385

shutil.rmtree(self._hgtmp, True)

2386

for f in self._createdfiles:

2386

for f in self._createdfiles:

2387

try:

2387

try:

2388

os.remove(f)

2388

os.remove(f)

2389

except OSError:

2389

except OSError:

2390

pass

2390

pass

2391

2392

def _usecorrectpython(self):

2392

def _usecorrectpython(self):

2393

"""Configure the environment to use the appropriate Python in tests."""

2393

"""Configure the environment to use the appropriate Python in tests."""

2394

# Tests must use the same interpreter as us or bad things will happen.

2394

# Tests must use the same interpreter as us or bad things will happen.

2395

pyexename = sys.platform == 'win32' and b'python.exe' or b'python'

2395

pyexename = sys.platform == 'win32' and b'python.exe' or b'python'

2396

if getattr(os, 'symlink', None):

2396

if getattr(os, 'symlink', None):

2397

vlog("# Making python executable in test path a symlink to '%s'" %

2397

vlog("# Making python executable in test path a symlink to '%s'" %

2398

sys.executable)

2398

sys.executable)

2399

mypython = os.path.join(self._tmpbindir, pyexename)

2399

mypython = os.path.join(self._tmpbindir, pyexename)

2400

try:

2400

try:

2401

if os.readlink(mypython) == sys.executable:

2401

if os.readlink(mypython) == sys.executable:

2402

return

2402

return

2403

os.unlink(mypython)

2403

os.unlink(mypython)

2404

except OSError as err:

2404

except OSError as err:

2405

if err.errno != errno.ENOENT:

2405

if err.errno != errno.ENOENT:

2406

raise

2406

raise

2407

if self._findprogram(pyexename) != sys.executable:

2407

if self._findprogram(pyexename) != sys.executable:

2408

try:

2408

try:

2409

os.symlink(sys.executable, mypython)

2409

os.symlink(sys.executable, mypython)

2410

self._createdfiles.append(mypython)

2410

self._createdfiles.append(mypython)

2411

except OSError as err:

2411

except OSError as err:

2412

# child processes may race, which is harmless

2412

# child processes may race, which is harmless

2413

if err.errno != errno.EEXIST:

2413

if err.errno != errno.EEXIST:

2414

raise

2414

raise

2415

else:

2415

else:

2416

exedir, exename = os.path.split(sys.executable)

2416

exedir, exename = os.path.split(sys.executable)

2417

vlog("# Modifying search path to find %s as %s in '%s'" %

2417

vlog("# Modifying search path to find %s as %s in '%s'" %

2418

(exename, pyexename, exedir))

2418

(exename, pyexename, exedir))

2419

path = os.environ['PATH'].split(os.pathsep)

2419

path = os.environ['PATH'].split(os.pathsep)

2420

while exedir in path:

2420

while exedir in path:

2421

path.remove(exedir)

2421

path.remove(exedir)

2422

os.environ['PATH'] = os.pathsep.join([exedir] + path)

2422

os.environ['PATH'] = os.pathsep.join([exedir] + path)

2423

if not self._findprogram(pyexename):

2423

if not self._findprogram(pyexename):

2424

print("WARNING: Cannot find %s in search path" % pyexename)

2424

print("WARNING: Cannot find %s in search path" % pyexename)

2425

2426

def _installhg(self):

2426

def _installhg(self):

2427

"""Install hg into the test environment.

2427

"""Install hg into the test environment.

2428

2429

This will also configure hg with the appropriate testing settings.

2429

This will also configure hg with the appropriate testing settings.

2430

"""

2430

"""

2431

vlog("# Performing temporary installation of HG")

2431

vlog("# Performing temporary installation of HG")

2432

installerrs = os.path.join(self._hgtmp, b"install.err")

2432

installerrs = os.path.join(self._hgtmp, b"install.err")

2433

compiler = ''

2433

compiler = ''

2434

if self.options.compiler:

2434

if self.options.compiler:

2435

compiler = '--compiler ' + self.options.compiler

2435

compiler = '--compiler ' + self.options.compiler

2436

if self.options.pure:

2436

if self.options.pure:

2437

pure = b"--pure"

2437

pure = b"--pure"

2438

else:

2438

else:

2439

pure = b""

2439

pure = b""

2440

2441

# Run installer in hg root

2441

# Run installer in hg root

2442

script = os.path.realpath(sys.argv[0])

2442

script = os.path.realpath(sys.argv[0])

2443

exe = sys.executable

2443

exe = sys.executable

2444

if PYTHON3:

2444

if PYTHON3:

2445

compiler = _bytespath(compiler)

2445

compiler = _bytespath(compiler)

2446

script = _bytespath(script)

2446

script = _bytespath(script)

2447

exe = _bytespath(exe)

2447

exe = _bytespath(exe)

2448

hgroot = os.path.dirname(os.path.dirname(script))

2448

hgroot = os.path.dirname(os.path.dirname(script))

2449

self._hgroot = hgroot

2449

self._hgroot = hgroot

2450

os.chdir(hgroot)

2450

os.chdir(hgroot)

2451

nohome = b'--home=""'

2451

nohome = b'--home=""'

2452

if os.name == 'nt':

2452

if os.name == 'nt':

2453

# The --home="" trick works only on OS where os.sep == '/'

2453

# The --home="" trick works only on OS where os.sep == '/'

2454

# because of a distutils convert_path() fast-path. Avoid it at

2454

# because of a distutils convert_path() fast-path. Avoid it at

2455

# least on Windows for now, deal with .pydistutils.cfg bugs

2455

# least on Windows for now, deal with .pydistutils.cfg bugs

2456

# when they happen.

2456

# when they happen.

2457

nohome = b''

2457

nohome = b''

2458

cmd = (b'%(exe)s setup.py %(pure)s clean --all'

2458

cmd = (b'%(exe)s setup.py %(pure)s clean --all'

2459

b' build %(compiler)s --build-base="%(base)s"'

2459

b' build %(compiler)s --build-base="%(base)s"'

2460

b' install --force --prefix="%(prefix)s"'

2460

b' install --force --prefix="%(prefix)s"'

2461

b' --install-lib="%(libdir)s"'

2461

b' --install-lib="%(libdir)s"'

2462

b' --install-scripts="%(bindir)s" %(nohome)s >%(logfile)s 2>&1'

2462

b' --install-scripts="%(bindir)s" %(nohome)s >%(logfile)s 2>&1'

2463

% {b'exe': exe, b'pure': pure,

2463

% {b'exe': exe, b'pure': pure,

2464

b'compiler': compiler,

2464

b'compiler': compiler,

2465

b'base': os.path.join(self._hgtmp, b"build"),

2465

b'base': os.path.join(self._hgtmp, b"build"),

2466

b'prefix': self._installdir, b'libdir': self._pythondir,

2466

b'prefix': self._installdir, b'libdir': self._pythondir,

2467

b'bindir': self._bindir,

2467

b'bindir': self._bindir,

2468

b'nohome': nohome, b'logfile': installerrs})

2468

b'nohome': nohome, b'logfile': installerrs})

2469

2470

# setuptools requires install directories to exist.

2470

# setuptools requires install directories to exist.

2471

def makedirs(p):

2471

def makedirs(p):

2472

try:

2472

try:

2473

os.makedirs(p)

2473

os.makedirs(p)

2474

except OSError as e:

2474

except OSError as e:

2475

if e.errno != errno.EEXIST:

2475

if e.errno != errno.EEXIST:

2476

raise

2476

raise

2477

makedirs(self._pythondir)

2477

makedirs(self._pythondir)

2478

makedirs(self._bindir)

2478

makedirs(self._bindir)

2479

2480

vlog("# Running", cmd)

2480

vlog("# Running", cmd)

2481

if os.system(cmd) == 0:

2481

if os.system(cmd) == 0:

2482

if not self.options.verbose:

2482

if not self.options.verbose:

2483

try:

2483

try:

2484

os.remove(installerrs)

2484

os.remove(installerrs)

2485

except OSError as e:

2485

except OSError as e:

2486

if e.errno != errno.ENOENT:

2486

if e.errno != errno.ENOENT:

2487

raise

2487

raise

2488

else:

2488

else:

2489

f = open(installerrs, 'rb')

2489

f = open(installerrs, 'rb')

2490

for line in f:

2490

for line in f:

2491

if PYTHON3:

2491

if PYTHON3:

2492

sys.stdout.buffer.write(line)

2492

sys.stdout.buffer.write(line)

2493

else:

2493

else:

2494

sys.stdout.write(line)

2494

sys.stdout.write(line)

2495

f.close()

2495

f.close()

2496

sys.exit(1)

2496

sys.exit(1)

2497

os.chdir(self._testdir)

2497

os.chdir(self._testdir)

2498

2499

self._usecorrectpython()

2499

self._usecorrectpython()

2500

2501

if self.options.py3k_warnings and not self.options.anycoverage:

2501

if self.options.py3k_warnings and not self.options.anycoverage:

2502

vlog("# Updating hg command to enable Py3k Warnings switch")

2502

vlog("# Updating hg command to enable Py3k Warnings switch")

2503

f = open(os.path.join(self._bindir, 'hg'), 'rb')

2503

f = open(os.path.join(self._bindir, 'hg'), 'rb')

2504

lines = [line.rstrip() for line in f]

2504

lines = [line.rstrip() for line in f]

2505

lines[0] += ' -3'

2505

lines[0] += ' -3'

2506

f.close()

2506

f.close()

2507

f = open(os.path.join(self._bindir, 'hg'), 'wb')

2507

f = open(os.path.join(self._bindir, 'hg'), 'wb')

2508

for line in lines:

2508

for line in lines:

2509

f.write(line + '\n')

2509

f.write(line + '\n')

2510

f.close()

2510

f.close()

2511

2512

hgbat = os.path.join(self._bindir, b'hg.bat')

2512

hgbat = os.path.join(self._bindir, b'hg.bat')

2513

if os.path.isfile(hgbat):

2513

if os.path.isfile(hgbat):

2514

# hg.bat expects to be put in bin/scripts while run-tests.py

2514

# hg.bat expects to be put in bin/scripts while run-tests.py

2515

# installation layout put it in bin/ directly. Fix it

2515

# installation layout put it in bin/ directly. Fix it

2516

f = open(hgbat, 'rb')

2516

f = open(hgbat, 'rb')

2517

data = f.read()

2517

data = f.read()

2518

f.close()

2518

f.close()

2519

if b'"%~dp0..\python" "%~dp0hg" %*' in data:

2519

if b'"%~dp0..\python" "%~dp0hg" %*' in data:

2520

data = data.replace(b'"%~dp0..\python" "%~dp0hg" %*',

2520

data = data.replace(b'"%~dp0..\python" "%~dp0hg" %*',

2521

b'"%~dp0python" "%~dp0hg" %*')

2521

b'"%~dp0python" "%~dp0hg" %*')

2522

f = open(hgbat, 'wb')

2522

f = open(hgbat, 'wb')

2523

f.write(data)

2523

f.write(data)

2524

f.close()

2524

f.close()

2525

else:

2525

else:

2526

print('WARNING: cannot fix hg.bat reference to python.exe')

2526

print('WARNING: cannot fix hg.bat reference to python.exe')

2527

2528

if self.options.anycoverage:

2528

if self.options.anycoverage:

2529

custom = os.path.join(self._testdir, 'sitecustomize.py')

2529

custom = os.path.join(self._testdir, 'sitecustomize.py')

2530

target = os.path.join(self._pythondir, 'sitecustomize.py')

2530

target = os.path.join(self._pythondir, 'sitecustomize.py')

2531

vlog('# Installing coverage trigger to %s' % target)

2531

vlog('# Installing coverage trigger to %s' % target)

2532

shutil.copyfile(custom, target)

2532

shutil.copyfile(custom, target)

2533

rc = os.path.join(self._testdir, '.coveragerc')

2533

rc = os.path.join(self._testdir, '.coveragerc')

2534

vlog('# Installing coverage rc to %s' % rc)

2534

vlog('# Installing coverage rc to %s' % rc)

2535

os.environ['COVERAGE_PROCESS_START'] = rc

2535

os.environ['COVERAGE_PROCESS_START'] = rc

2536

covdir = os.path.join(self._installdir, '..', 'coverage')

2536

covdir = os.path.join(self._installdir, '..', 'coverage')

2537

try:

2537

try:

2538

os.mkdir(covdir)

2538

os.mkdir(covdir)

2539

except OSError as e:

2539

except OSError as e:

2540

if e.errno != errno.EEXIST:

2540

if e.errno != errno.EEXIST:

2541

raise

2541

raise

2542

2543

os.environ['COVERAGE_DIR'] = covdir

2543

os.environ['COVERAGE_DIR'] = covdir

2544

2545

def _checkhglib(self, verb):

2545

def _checkhglib(self, verb):

2546

"""Ensure that the 'mercurial' package imported by python is

2546

"""Ensure that the 'mercurial' package imported by python is

2547

the one we expect it to be. If not, print a warning to stderr."""

2547

the one we expect it to be. If not, print a warning to stderr."""

2548

if ((self._bindir == self._pythondir) and

2548

if ((self._bindir == self._pythondir) and

2549

(self._bindir != self._tmpbindir)):

2549

(self._bindir != self._tmpbindir)):

2550

# The pythondir has been inferred from --with-hg flag.

2550

# The pythondir has been inferred from --with-hg flag.

2551

# We cannot expect anything sensible here.

2551

# We cannot expect anything sensible here.

2552

return

2552

return

2553

expecthg = os.path.join(self._pythondir, b'mercurial')

2553

expecthg = os.path.join(self._pythondir, b'mercurial')

2554

actualhg = self._gethgpath()

2554

actualhg = self._gethgpath()

2555

if os.path.abspath(actualhg) != os.path.abspath(expecthg):

2555

if os.path.abspath(actualhg) != os.path.abspath(expecthg):

2556

sys.stderr.write('warning: %s with unexpected mercurial lib: %s\n'

2556

sys.stderr.write('warning: %s with unexpected mercurial lib: %s\n'

2557

' (expected %s)\n'

2557

' (expected %s)\n'

2558

% (verb, actualhg, expecthg))

2558

% (verb, actualhg, expecthg))

2559

def _gethgpath(self):

2559

def _gethgpath(self):

2560

"""Return the path to the mercurial package that is actually found by

2560

"""Return the path to the mercurial package that is actually found by

2561

the current Python interpreter."""

2561

the current Python interpreter."""

2562

if self._hgpath is not None:

2562

if self._hgpath is not None:

2563

return self._hgpath

2563

return self._hgpath

2564

2565

cmd = b'%s -c "import mercurial; print (mercurial.__path__[0])"'

2565

cmd = b'%s -c "import mercurial; print (mercurial.__path__[0])"'

2566

cmd = cmd % PYTHON

2566

cmd = cmd % PYTHON

2567

if PYTHON3:

2567

if PYTHON3:

2568

cmd = _strpath(cmd)

2568

cmd = _strpath(cmd)

2569

pipe = os.popen(cmd)

2569

pipe = os.popen(cmd)

2570

try:

2570

try:

2571

self._hgpath = _bytespath(pipe.read().strip())

2571

self._hgpath = _bytespath(pipe.read().strip())

2572

finally:

2572

finally:

2573

pipe.close()

2573

pipe.close()

2574

2575

return self._hgpath

2575

return self._hgpath

2576

2577

def _installchg(self):

2577

def _installchg(self):

2578

"""Install chg into the test environment"""

2578

"""Install chg into the test environment"""

2579

vlog('# Performing temporary installation of CHG')

2579

vlog('# Performing temporary installation of CHG')

2580

assert os.path.dirname(self._bindir) == self._installdir

2580

assert os.path.dirname(self._bindir) == self._installdir

2581

assert self._hgroot, 'must be called after _installhg()'

2581

assert self._hgroot, 'must be called after _installhg()'

2582

cmd = (b'"%(make)s" clean install PREFIX="%(prefix)s"'

2582

cmd = (b'"%(make)s" clean install PREFIX="%(prefix)s"'

2583

% {b'make': 'make', # TODO: switch by option or environment?

2583

% {b'make': 'make', # TODO: switch by option or environment?

2584

b'prefix': self._installdir})

2584

b'prefix': self._installdir})

2585

cwd = os.path.join(self._hgroot, b'contrib', b'chg')

2585

cwd = os.path.join(self._hgroot, b'contrib', b'chg')

2586

vlog("# Running", cmd)

2586

vlog("# Running", cmd)

2587

proc = subprocess.Popen(cmd, shell=True, cwd=cwd,

2587

proc = subprocess.Popen(cmd, shell=True, cwd=cwd,

2588

stdin=subprocess.PIPE, stdout=subprocess.PIPE,

2588

stdin=subprocess.PIPE, stdout=subprocess.PIPE,

2589

stderr=subprocess.STDOUT)

2589

stderr=subprocess.STDOUT)

2590

out, _err = proc.communicate()

2590

out, _err = proc.communicate()

2591

if proc.returncode != 0:

2591

if proc.returncode != 0:

2592

if PYTHON3:

2592

if PYTHON3:

2593

sys.stdout.buffer.write(out)

2593

sys.stdout.buffer.write(out)

2594

else:

2594

else:

2595

sys.stdout.write(out)

2595

sys.stdout.write(out)

2596

sys.exit(1)

2596

sys.exit(1)

2597

2598

def _outputcoverage(self):

2598

def _outputcoverage(self):

2599

"""Produce code coverage output."""

2599

"""Produce code coverage output."""

2600

import coverage

2600

import coverage

2601

coverage = coverage.coverage

2601

coverage = coverage.coverage

2602

2603

vlog('# Producing coverage report')

2603

vlog('# Producing coverage report')

2604

# chdir is the easiest way to get short, relative paths in the

2604

# chdir is the easiest way to get short, relative paths in the

2605

# output.

2605

# output.

2606

os.chdir(self._hgroot)

2606

os.chdir(self._hgroot)

2607

covdir = os.path.join(self._installdir, '..', 'coverage')

2607

covdir = os.path.join(self._installdir, '..', 'coverage')

2608

cov = coverage(data_file=os.path.join(covdir, 'cov'))

2608

cov = coverage(data_file=os.path.join(covdir, 'cov'))

2609

2610

# Map install directory paths back to source directory.

2610

# Map install directory paths back to source directory.

2611

cov.config.paths['srcdir'] = ['.', self._pythondir]

2611

cov.config.paths['srcdir'] = ['.', self._pythondir]

2612

2613

cov.combine()

2613

cov.combine()

2614

2615

omit = [os.path.join(x, '*') for x in [self._bindir, self._testdir]]

2615

omit = [os.path.join(x, '*') for x in [self._bindir, self._testdir]]

2616

cov.report(ignore_errors=True, omit=omit)

2616

cov.report(ignore_errors=True, omit=omit)

2617

2618

if self.options.htmlcov:

2618

if self.options.htmlcov:

2619

htmldir = os.path.join(self._testdir, 'htmlcov')

2619

htmldir = os.path.join(self._testdir, 'htmlcov')

2620

cov.html_report(directory=htmldir, omit=omit)

2620

cov.html_report(directory=htmldir, omit=omit)

2621

if self.options.annotate:

2621

if self.options.annotate:

2622

adir = os.path.join(self._testdir, 'annotated')

2622

adir = os.path.join(self._testdir, 'annotated')

2623

if not os.path.isdir(adir):

2623

if not os.path.isdir(adir):

2624

os.mkdir(adir)

2624

os.mkdir(adir)

2625

cov.annotate(directory=adir, omit=omit)

2625

cov.annotate(directory=adir, omit=omit)

2626

2627

def _findprogram(self, program):

2627

def _findprogram(self, program):

2628

"""Search PATH for a executable program"""

2628

"""Search PATH for a executable program"""

2629

dpb = _bytespath(os.defpath)

2629

dpb = _bytespath(os.defpath)

2630

sepb = _bytespath(os.pathsep)

2630

sepb = _bytespath(os.pathsep)

2631

for p in osenvironb.get(b'PATH', dpb).split(sepb):

2631

for p in osenvironb.get(b'PATH', dpb).split(sepb):

2632

name = os.path.join(p, program)

2632

name = os.path.join(p, program)

2633

if os.name == 'nt' or os.access(name, os.X_OK):

2633

if os.name == 'nt' or os.access(name, os.X_OK):

2634

return name

2634

return name

2635

return None

2635

return None

2636

2637

def _checktools(self):

2637

def _checktools(self):

2638

"""Ensure tools required to run tests are present."""

2638

"""Ensure tools required to run tests are present."""

2639

for p in self.REQUIREDTOOLS:

2639

for p in self.REQUIREDTOOLS:

2640

if os.name == 'nt' and not p.endswith('.exe'):

2640

if os.name == 'nt' and not p.endswith('.exe'):

2641

p += '.exe'

2641

p += '.exe'

2642

found = self._findprogram(p)

2642

found = self._findprogram(p)

2643

if found:

2643

if found:

2644

vlog("# Found prerequisite", p, "at", found)

2644

vlog("# Found prerequisite", p, "at", found)

2645

else:

2645

else:

2646

print("WARNING: Did not find prerequisite tool: %s " %

2646

print("WARNING: Did not find prerequisite tool: %s " %

2647

p.decode("utf-8"))

2647

p.decode("utf-8"))

2648

2649

if __name__ == '__main__':

2649

if __name__ == '__main__':

2650

runner = TestRunner()

2650

runner = TestRunner()

2651

2652

try:

2652

try:

2653

import msvcrt

2653

import msvcrt

2654

msvcrt.setmode(sys.stdin.fileno(), os.O_BINARY)

2654

msvcrt.setmode(sys.stdin.fileno(), os.O_BINARY)

2655

msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY)

2655

msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY)

2656

msvcrt.setmode(sys.stderr.fileno(), os.O_BINARY)

2656

msvcrt.setmode(sys.stderr.fileno(), os.O_BINARY)

2657

except ImportError:

2657

except ImportError:

2658

pass

2658

pass

2659

2660

sys.exit(runner.run(sys.argv[1:]))

2660

sys.exit(runner.run(sys.argv[1:]))

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages

             #!/usr/bin/env python
             #
             # run-tests.py - Run a set of tests on Mercurial
             #
             # Copyright 2006 Matt Mackall <mpm@selenic.com>
             #
             # This software may be used and distributed according to the terms of the
             # GNU General Public License version 2 or any later version.
             # Modifying this script is tricky because it has many modes:
             #   - serial (default) vs parallel (-jN, N > 1)
             #   - no coverage (default) vs coverage (-c, -C, -s)
             #   - temp install (default) vs specific hg script (--with-hg, --local)
             #   - tests are a mix of shell scripts and Python scripts
             #
             # If you change this script, it is recommended that you ensure you
             # haven't broken it by running it in various modes with a representative
             # sample of test scripts.  For example:
             #
             #  1) serial, no coverage, temp install:
             #      ./run-tests.py test-s*
             #  2) serial, no coverage, local hg:
             #      ./run-tests.py --local test-s*
             #  3) serial, coverage, temp install:
             #      ./run-tests.py -c test-s*
             #  4) serial, coverage, local hg:
             #      ./run-tests.py -c --local test-s*      # unsupported
             #  5) parallel, no coverage, temp install:
             #      ./run-tests.py -j2 test-s*
             #  6) parallel, no coverage, local hg:
             #      ./run-tests.py -j2 --local test-s*
             #  7) parallel, coverage, temp install:
             #      ./run-tests.py -j2 -c test-s*          # currently broken
             #  8) parallel, coverage, local install:
             #      ./run-tests.py -j2 -c --local test-s*  # unsupported (and broken)
             #  9) parallel, custom tmp dir:
             #      ./run-tests.py -j2 --tmpdir /tmp/myhgtests
             #  10) parallel, pure, tests that call run-tests:
             #      ./run-tests.py --pure `grep -l run-tests.py *.t`
             #
             # (You could use any subset of the tests: test-s* happens to match
             # enough that it's worth doing parallel runs, few enough that it
             # completes fairly quickly, includes both shell and Python scripts, and
             # includes some scripts that run daemon processes.)
             from __future__ import absolute_import, print_function
             import difflib
             import distutils.version as version
             import errno
             import json
             import optparse
             import os
             import random
             import re
             import shutil
             import signal
             import socket
             import subprocess
             import sys
             import sysconfig
             import tempfile
             import threading
             import time
             import unittest
             import xml.dom.minidom as minidom
             try:
                 import Queue as queue
             except ImportError:
                 import queue
             if os.environ.get('RTUNICODEPEDANTRY', False):
                 try:
                     reload(sys)
                     sys.setdefaultencoding("undefined")
                 except NameError:
                     pass
             osenvironb = getattr(os, 'environb', os.environ)
             processlock = threading.Lock()
             if sys.version_info > (3, 5, 0):
                 PYTHON3 = True
                 xrange = range # we use xrange in one place, and we'd rather not use range
                 def _bytespath(p):
                     return p.encode('utf-8')
                 def _strpath(p):
                     return p.decode('utf-8')
             elif sys.version_info >= (3, 0, 0):
                 print('%s is only supported on Python 3.5+ and 2.6-2.7, not %s' %
                       (sys.argv[0], '.'.join(str(v) for v in sys.version_info[:3])))
                 sys.exit(70) # EX_SOFTWARE from `man 3 sysexit`
             else:
                 PYTHON3 = False
                 # In python 2.x, path operations are generally done using
                 # bytestrings by default, so we don't have to do any extra
                 # fiddling there. We define the wrapper functions anyway just to
                 # help keep code consistent between platforms.
                 def _bytespath(p):
                     return p
                 _strpath = _bytespath
             # For Windows support
             wifexited = getattr(os, "WIFEXITED", lambda x: False)
             # Whether to use IPv6
             def checksocketfamily(name, port=20058):
                 """return true if we can listen on localhost using family=name
                 name should be either 'AF_INET', or 'AF_INET6'.
                 port being used is okay - EADDRINUSE is considered as successful.
                 """
                 family = getattr(socket, name, None)
                 if family is None:
                     return False
                 try:
                     s = socket.socket(family, socket.SOCK_STREAM)
                     s.bind(('localhost', port))
                     s.close()
                     return True
                 except socket.error as exc:
                     if exc.errno == errno.EADDRINUSE:
                         return True
                     elif exc.errno in (errno.EADDRNOTAVAIL, errno.EPROTONOSUPPORT):
                         return False
                     else:
                         raise
                 else:
                     return False
             # useipv6 will be set by parseargs
             useipv6 = None
             def checkportisavailable(port):
                 """return true if a port seems free to bind on localhost"""
                 if useipv6:
                     family = socket.AF_INET6
                 else:
                     family = socket.AF_INET
                 try:
                     s = socket.socket(family, socket.SOCK_STREAM)
                     s.bind(('localhost', port))
                     s.close()
                     return True
                 except socket.error as exc:
                     if exc.errno not in (errno.EADDRINUSE, errno.EADDRNOTAVAIL,
                                          errno.EPROTONOSUPPORT):
                         raise
                 return False
             closefds = os.name == 'posix'
             def Popen4(cmd, wd, timeout, env=None):
                 processlock.acquire()
                 p = subprocess.Popen(cmd, shell=True, bufsize=-1, cwd=wd, env=env,
                                      close_fds=closefds,
                                      stdin=subprocess.PIPE, stdout=subprocess.PIPE,
                                      stderr=subprocess.STDOUT)
                 processlock.release()
                 p.fromchild = p.stdout
                 p.tochild = p.stdin
                 p.childerr = p.stderr
                 p.timeout = False
                 if timeout:
                     def t():
                         start = time.time()
                         while time.time() - start < timeout and p.returncode is None:
                             time.sleep(.1)
                         p.timeout = True
                         if p.returncode is None:
                             terminate(p)
                     threading.Thread(target=t).start()
                 return p
             PYTHON = _bytespath(sys.executable.replace('\\', '/'))
             IMPL_PATH = b'PYTHONPATH'
             if 'java' in sys.platform:
                 IMPL_PATH = b'JYTHONPATH'
             defaults = {
                 'jobs': ('HGTEST_JOBS', 1),
                 'timeout': ('HGTEST_TIMEOUT', 180),
                 'slowtimeout': ('HGTEST_SLOWTIMEOUT', 500),
                 'port': ('HGTEST_PORT', 20059),
                 'shell': ('HGTEST_SHELL', 'sh'),
             }
             def canonpath(path):
                 return os.path.realpath(os.path.expanduser(path))
             def parselistfiles(files, listtype, warn=True):
                 entries = dict()
                 for filename in files:
                     try:
                         path = os.path.expanduser(os.path.expandvars(filename))
                         f = open(path, "rb")
                     except IOError as err:
                         if err.errno != errno.ENOENT:
                             raise
                         if warn:
                             print("warning: no such %s file: %s" % (listtype, filename))
                         continue
                     for line in f.readlines():
                         line = line.split(b'#', 1)[0].strip()
                         if line:
                             entries[line] = filename
                     f.close()
                 return entries
             def getparser():
                 """Obtain the OptionParser used by the CLI."""
                 parser = optparse.OptionParser("%prog [options] [tests]")
                 # keep these sorted
                 parser.add_option("--blacklist", action="append",
                     help="skip tests listed in the specified blacklist file")
                 parser.add_option("--whitelist", action="append",
                     help="always run tests listed in the specified whitelist file")
                 parser.add_option("--changed", type="string",
                     help="run tests that are changed in parent rev or working directory")
                 parser.add_option("-C", "--annotate", action="store_true",
                     help="output files annotated with coverage")
                 parser.add_option("-c", "--cover", action="store_true",
                     help="print a test coverage report")
                 parser.add_option("-d", "--debug", action="store_true",
                     help="debug mode: write output of test scripts to console"
                          " rather than capturing and diffing it (disables timeout)")
                 parser.add_option("-f", "--first", action="store_true",
                     help="exit on the first test failure")
                 parser.add_option("-H", "--htmlcov", action="store_true",
                     help="create an HTML report of the coverage of the files")
                 parser.add_option("-i", "--interactive", action="store_true",
                     help="prompt to accept changed output")
                 parser.add_option("-j", "--jobs", type="int",
                     help="number of jobs to run in parallel"
                          " (default: $%s or %d)" % defaults['jobs'])
                 parser.add_option("--keep-tmpdir", action="store_true",
                     help="keep temporary directory after running tests")
                 parser.add_option("-k", "--keywords",
                     help="run tests matching keywords")
                 parser.add_option("-l", "--local", action="store_true",
                     help="shortcut for --with-hg=<testdir>/../hg, "
                          "and --with-chg=<testdir>/../contrib/chg/chg if --chg is set")
                 parser.add_option("--loop", action="store_true",
                     help="loop tests repeatedly")
                 parser.add_option("--runs-per-test", type="int", dest="runs_per_test",
                     help="run each test N times (default=1)", default=1)
                 parser.add_option("-n", "--nodiff", action="store_true",
                     help="skip showing test changes")
                 parser.add_option("-p", "--port", type="int",
                     help="port on which servers should listen"
                          " (default: $%s or %d)" % defaults['port'])
                 parser.add_option("--compiler", type="string",
                     help="compiler to build with")
                 parser.add_option("--pure", action="store_true",
                     help="use pure Python code instead of C extensions")
                 parser.add_option("-R", "--restart", action="store_true",
                     help="restart at last error")
                 parser.add_option("-r", "--retest", action="store_true",
                     help="retest failed tests")
                 parser.add_option("-S", "--noskips", action="store_true",
                     help="don't report skip tests verbosely")
                 parser.add_option("--shell", type="string",
                     help="shell to use (default: $%s or %s)" % defaults['shell'])
                 parser.add_option("-t", "--timeout", type="int",
                     help="kill errant tests after TIMEOUT seconds"
                          " (default: $%s or %d)" % defaults['timeout'])
                 parser.add_option("--slowtimeout", type="int",
                     help="kill errant slow tests after SLOWTIMEOUT seconds"
                          " (default: $%s or %d)" % defaults['slowtimeout'])
                 parser.add_option("--time", action="store_true",
                     help="time how long each test takes")
                 parser.add_option("--json", action="store_true",
                                   help="store test result data in 'report.json' file")
                 parser.add_option("--tmpdir", type="string",
                     help="run tests in the given temporary directory"
                          " (implies --keep-tmpdir)")
                 parser.add_option("-v", "--verbose", action="store_true",
                     help="output verbose messages")
                 parser.add_option("--xunit", type="string",
                                   help="record xunit results at specified path")
                 parser.add_option("--view", type="string",
                     help="external diff viewer")
                 parser.add_option("--with-hg", type="string",
                     metavar="HG",
                     help="test using specified hg script rather than a "
                          "temporary installation")
                 parser.add_option("--chg", action="store_true",
                                   help="install and use chg wrapper in place of hg")
                 parser.add_option("--with-chg", metavar="CHG",
                                   help="use specified chg wrapper in place of hg")
                 parser.add_option("--ipv6", action="store_true",
                                   help="prefer IPv6 to IPv4 for network related tests")
                 parser.add_option("-3", "--py3k-warnings", action="store_true",
                     help="enable Py3k warnings on Python 2.6+")
                 # This option should be deleted once test-check-py3-compat.t and other
                 # Python 3 tests run with Python 3.
                 parser.add_option("--with-python3", metavar="PYTHON3",
                                   help="Python 3 interpreter (if running under Python 2)"
                                        " (TEMPORARY)")
                 parser.add_option('--extra-config-opt', action="append",
                                   help='set the given config opt in the test hgrc')
                 parser.add_option('--random', action="store_true",
                                   help='run tests in random order')
                 parser.add_option('--profile-runner', action='store_true',
                                   help='run statprof on run-tests')
                 parser.add_option('--allow-slow-tests', action='store_true',
                                   help='allow extremely slow tests')
                 parser.add_option('--showchannels', action='store_true',
                                   help='show scheduling channels')
                 parser.add_option('--known-good-rev', type="string",
                                   metavar="known_good_rev",
                                   help=("Automatically bisect any failures using this "
                                         "revision as a known-good revision."))
                 for option, (envvar, default) in defaults.items():
                     defaults[option] = type(default)(os.environ.get(envvar, default))
                 parser.set_defaults(**defaults)
                 return parser
             def parseargs(args, parser):
                 """Parse arguments with our OptionParser and validate results."""
                 (options, args) = parser.parse_args(args)
                 # jython is always pure
                 if 'java' in sys.platform or '__pypy__' in sys.modules:
                     options.pure = True
                 if options.with_hg:
                     options.with_hg = canonpath(_bytespath(options.with_hg))
                     if not (os.path.isfile(options.with_hg) and
                             os.access(options.with_hg, os.X_OK)):
                         parser.error('--with-hg must specify an executable hg script')
                     if not os.path.basename(options.with_hg) == b'hg':
                         sys.stderr.write('warning: --with-hg should specify an hg script\n')
                 if options.local:
                     testdir = os.path.dirname(_bytespath(canonpath(sys.argv[0])))
                     reporootdir = os.path.dirname(testdir)
                     pathandattrs = [(b'hg', 'with_hg')]
                     if options.chg:
                         pathandattrs.append((b'contrib/chg/chg', 'with_chg'))
                     for relpath, attr in pathandattrs:
                         binpath = os.path.join(reporootdir, relpath)
                         if os.name != 'nt' and not os.access(binpath, os.X_OK):
                             parser.error('--local specified, but %r not found or '
                                          'not executable' % binpath)
                         setattr(options, attr, binpath)
                 if (options.chg or options.with_chg) and os.name == 'nt':
                     parser.error('chg does not work on %s' % os.name)
                 if options.with_chg:
                     options.chg = False  # no installation to temporary location
                     options.with_chg = canonpath(_bytespath(options.with_chg))
                     if not (os.path.isfile(options.with_chg) and
                             os.access(options.with_chg, os.X_OK)):
                         parser.error('--with-chg must specify a chg executable')
                 if options.chg and options.with_hg:
                     # chg shares installation location with hg
                     parser.error('--chg does not work when --with-hg is specified '
                                  '(use --with-chg instead)')
                 global useipv6
                 if options.ipv6:
                     useipv6 = checksocketfamily('AF_INET6')
                 else:
                     # only use IPv6 if IPv4 is unavailable and IPv6 is available
                     useipv6 = ((not checksocketfamily('AF_INET'))
                                and checksocketfamily('AF_INET6'))
                 options.anycoverage = options.cover or options.annotate or options.htmlcov
                 if options.anycoverage:
                     try:
                         import coverage
                         covver = version.StrictVersion(coverage.__version__).version
                         if covver < (3, 3):
                             parser.error('coverage options require coverage 3.3 or later')
                     except ImportError:
                         parser.error('coverage options now require the coverage package')
                 if options.anycoverage and options.local:
                     # this needs some path mangling somewhere, I guess
                     parser.error("sorry, coverage options do not work when --local "
                                  "is specified")
                 if options.anycoverage and options.with_hg:
                     parser.error("sorry, coverage options do not work when --with-hg "
                                  "is specified")
                 global verbose
                 if options.verbose:
                     verbose = ''
                 if options.tmpdir:
                     options.tmpdir = canonpath(options.tmpdir)
                 if options.jobs < 1:
                     parser.error('--jobs must be positive')
                 if options.interactive and options.debug:
                     parser.error("-i/--interactive and -d/--debug are incompatible")
                 if options.debug:
                     if options.timeout != defaults['timeout']:
                         sys.stderr.write(
                             'warning: --timeout option ignored with --debug\n')
                     if options.slowtimeout != defaults['slowtimeout']:
                         sys.stderr.write(
                             'warning: --slowtimeout option ignored with --debug\n')
                     options.timeout = 0
                     options.slowtimeout = 0
                 if options.py3k_warnings:
                     if PYTHON3:
                         parser.error(
                             '--py3k-warnings can only be used on Python 2.6 and 2.7')
                 if options.with_python3:
                     if PYTHON3:
                         parser.error('--with-python3 cannot be used when executing with '
                                      'Python 3')
                     options.with_python3 = canonpath(options.with_python3)
                     # Verify Python3 executable is acceptable.
                     proc = subprocess.Popen([options.with_python3, b'--version'],
                                             stdout=subprocess.PIPE,
                                             stderr=subprocess.STDOUT)
                     out, _err = proc.communicate()
                     ret = proc.wait()
                     if ret != 0:
                         parser.error('could not determine version of python 3')
                     if not out.startswith('Python '):
                         parser.error('unexpected output from python3 --version: %s' %
                                      out)
                     vers = version.LooseVersion(out[len('Python '):])
                     if vers < version.LooseVersion('3.5.0'):
                         parser.error('--with-python3 version must be 3.5.0 or greater; '
                                      'got %s' % out)
                 if options.blacklist:
                     options.blacklist = parselistfiles(options.blacklist, 'blacklist')
                 if options.whitelist:
                     options.whitelisted = parselistfiles(options.whitelist, 'whitelist')
                 else:
                     options.whitelisted = {}
                 if options.showchannels:
                     options.nodiff = True
                 return (options, args)
             def rename(src, dst):
                 """Like os.rename(), trade atomicity and opened files friendliness
                 for existing destination support.
                 """
                 shutil.copy(src, dst)
                 os.remove(src)
             _unified_diff = difflib.unified_diff
             if PYTHON3:
                 import functools
                 _unified_diff = functools.partial(difflib.diff_bytes, difflib.unified_diff)
             def getdiff(expected, output, ref, err):
                 servefail = False
                 lines = []
                 for line in _unified_diff(expected, output, ref, err):
                     if line.startswith(b'+++') or line.startswith(b'---'):
                         line = line.replace(b'\\', b'/')
                         if line.endswith(b' \n'):
                             line = line[:-2] + b'\n'
                     lines.append(line)
                     if not servefail and line.startswith(
                                          b'+  abort: child process failed to start'):
                         servefail = True
                 return servefail, lines
             verbose = False
             def vlog(*msg):
                 """Log only when in verbose mode."""
                 if verbose is False:
                     return
                 return log(*msg)
             # Bytes that break XML even in a CDATA block: control characters 0-31
             # sans \t, \n and \r
             CDATA_EVIL = re.compile(br"[\000-\010\013\014\016-\037]")
             # Match feature conditionalized output lines in the form, capturing the feature
             # list in group 2, and the preceeding line output in group 1:
             #
             #   output..output (feature !)\n
             optline = re.compile(b'(.+) \((.+?) !\)\n$')
             def cdatasafe(data):
                 """Make a string safe to include in a CDATA block.
                 Certain control characters are illegal in a CDATA block, and
                 there's no way to include a ]]> in a CDATA either. This function
                 replaces illegal bytes with ? and adds a space between the ]] so
                 that it won't break the CDATA block.
                 """
                 return CDATA_EVIL.sub(b'?', data).replace(b']]>', b'] ]>')
             def log(*msg):
                 """Log something to stdout.
                 Arguments are strings to print.
                 """
                 with iolock:
                     if verbose:
                         print(verbose, end=' ')
                     for m in msg:
                         print(m, end=' ')
                     print()
                     sys.stdout.flush()
             def terminate(proc):
-                """Terminate subprocess (with fallback for Python versions < 2.6)"""
+                """Terminate subprocess"""
                 vlog('# Terminating process %d' % proc.pid)
                 try:
-                    getattr(proc, 'terminate', lambda : os.kill(proc.pid, signal.SIGTERM))()
+                    proc.terminate()
                 except OSError:
                     pass
             def killdaemons(pidfile):
                 import killdaemons as killmod
                 return killmod.killdaemons(pidfile, tryhard=False, remove=True,
                                            logfn=vlog)
             class Test(unittest.TestCase):
                 """Encapsulates a single, runnable test.
                 While this class conforms to the unittest.TestCase API, it differs in that
                 instances need to be instantiated manually. (Typically, unittest.TestCase
                 classes are instantiated automatically by scanning modules.)
                 """
                 # Status code reserved for skipped tests (used by hghave).
                 SKIPPED_STATUS = 80
                 def __init__(self, path, tmpdir, keeptmpdir=False,
                              debug=False,
                              timeout=defaults['timeout'],
                              startport=defaults['port'], extraconfigopts=None,
                              py3kwarnings=False, shell=None, hgcommand=None,
                              slowtimeout=defaults['slowtimeout'], usechg=False,
                              useipv6=False):
                     """Create a test from parameters.
                     path is the full path to the file defining the test.
                     tmpdir is the main temporary directory to use for this test.
                     keeptmpdir determines whether to keep the test's temporary directory
                     after execution. It defaults to removal (False).
                     debug mode will make the test execute verbosely, with unfiltered
                     output.
                     timeout controls the maximum run time of the test. It is ignored when
                     debug is True. See slowtimeout for tests with #require slow.
                     slowtimeout overrides timeout if the test has #require slow.
                     startport controls the starting port number to use for this test. Each
                     test will reserve 3 port numbers for execution. It is the caller's
                     responsibility to allocate a non-overlapping port range to Test
                     instances.
                     extraconfigopts is an iterable of extra hgrc config options. Values
                     must have the form "key=value" (something understood by hgrc). Values
                     of the form "foo.key=value" will result in "[foo] key=value".
                     py3kwarnings enables Py3k warnings.
                     shell is the shell to execute tests in.
                     """
                     self.path = path
                     self.bname = os.path.basename(path)
                     self.name = _strpath(self.bname)
                     self._testdir = os.path.dirname(path)
                     self.errpath = os.path.join(self._testdir, b'%s.err' % self.bname)
                     self._threadtmp = tmpdir
                     self._keeptmpdir = keeptmpdir
                     self._debug = debug
                     self._timeout = timeout
                     self._slowtimeout = slowtimeout
                     self._startport = startport
                     self._extraconfigopts = extraconfigopts or []
                     self._py3kwarnings = py3kwarnings
                     self._shell = _bytespath(shell)
                     self._hgcommand = hgcommand or b'hg'
                     self._usechg = usechg
                     self._useipv6 = useipv6
                     self._aborted = False
                     self._daemonpids = []
                     self._finished = None
                     self._ret = None
                     self._out = None
                     self._skipped = None
                     self._testtmp = None
                     self._chgsockdir = None
                     # If we're not in --debug mode and reference output file exists,
                     # check test output against it.
                     if debug:
                         self._refout = None # to match "out is None"
                     elif os.path.exists(self.refpath):
                         f = open(self.refpath, 'rb')
                         self._refout = f.read().splitlines(True)
                         f.close()
                     else:
                         self._refout = []
                 # needed to get base class __repr__ running
                 @property
                 def _testMethodName(self):
                     return self.name
                 def __str__(self):
                     return self.name
                 def shortDescription(self):
                     return self.name
                 def setUp(self):
                     """Tasks to perform before run()."""
                     self._finished = False
                     self._ret = None
                     self._out = None
                     self._skipped = None
                     try:
                         os.mkdir(self._threadtmp)
                     except OSError as e:
                         if e.errno != errno.EEXIST:
                             raise
                     name = os.path.basename(self.path)
                     self._testtmp = os.path.join(self._threadtmp, name)
                     os.mkdir(self._testtmp)
                     # Remove any previous output files.
                     if os.path.exists(self.errpath):
                         try:
                             os.remove(self.errpath)
                         except OSError as e:
                             # We might have raced another test to clean up a .err
                             # file, so ignore ENOENT when removing a previous .err
                             # file.
                             if e.errno != errno.ENOENT:
                                 raise
                     if self._usechg:
                         self._chgsockdir = os.path.join(self._threadtmp,
                                                         b'%s.chgsock' % name)
                         os.mkdir(self._chgsockdir)
                 def run(self, result):
                     """Run this test and report results against a TestResult instance."""
                     # This function is extremely similar to unittest.TestCase.run(). Once
                     # we require Python 2.7 (or at least its version of unittest), this
                     # function can largely go away.
                     self._result = result
                     result.startTest(self)
                     try:
                         try:
                             self.setUp()
                         except (KeyboardInterrupt, SystemExit):
                             self._aborted = True
                             raise
                         except Exception:
                             result.addError(self, sys.exc_info())
                             return
                         success = False
                         try:
                             self.runTest()
                         except KeyboardInterrupt:
                             self._aborted = True
                             raise
                         except SkipTest as e:
                             result.addSkip(self, str(e))
                             # The base class will have already counted this as a
                             # test we "ran", but we want to exclude skipped tests
                             # from those we count towards those run.
                             result.testsRun -= 1
                         except IgnoreTest as e:
                             result.addIgnore(self, str(e))
                             # As with skips, ignores also should be excluded from
                             # the number of tests executed.
                             result.testsRun -= 1
                         except WarnTest as e:
                             result.addWarn(self, str(e))
                         except ReportedTest as e:
                             pass
                         except self.failureException as e:
                             # This differs from unittest in that we don't capture
                             # the stack trace. This is for historical reasons and
                             # this decision could be revisited in the future,
                             # especially for PythonTest instances.
                             if result.addFailure(self, str(e)):
                                 success = True
                         except Exception:
                             result.addError(self, sys.exc_info())
                         else:
                             success = True
                         try:
                             self.tearDown()
                         except (KeyboardInterrupt, SystemExit):
                             self._aborted = True
                             raise
                         except Exception:
                             result.addError(self, sys.exc_info())
                             success = False
                         if success:
                             result.addSuccess(self)
                     finally:
                         result.stopTest(self, interrupted=self._aborted)
                 def runTest(self):
                     """Run this test instance.
                     This will return a tuple describing the result of the test.
                     """
                     env = self._getenv()
                     self._daemonpids.append(env['DAEMON_PIDS'])
                     self._createhgrc(env['HGRCPATH'])
                     vlog('# Test', self.name)
                     ret, out = self._run(env)
                     self._finished = True
                     self._ret = ret
                     self._out = out
                     def describe(ret):
                         if ret < 0:
                             return 'killed by signal: %d' % -ret
                         return 'returned error code %d' % ret
                     self._skipped = False
                     if ret == self.SKIPPED_STATUS:
                         if out is None: # Debug mode, nothing to parse.
                             missing = ['unknown']
                             failed = None
                         else:
                             missing, failed = TTest.parsehghaveoutput(out)
                         if not missing:
                             missing = ['skipped']
                         if failed:
                             self.fail('hg have failed checking for %s' % failed[-1])
                         else:
                             self._skipped = True
                             raise SkipTest(missing[-1])
                     elif ret == 'timeout':
                         self.fail('timed out')
                     elif ret is False:
                         raise WarnTest('no result code from test')
                     elif out != self._refout:
                         # Diff generation may rely on written .err file.
                         if (ret != 0 or out != self._refout) and not self._skipped \
                             and not self._debug:
                             f = open(self.errpath, 'wb')
                             for line in out:
                                 f.write(line)
                             f.close()
                         # The result object handles diff calculation for us.
                         if self._result.addOutputMismatch(self, ret, out, self._refout):
                             # change was accepted, skip failing
                             return
                         if ret:
                             msg = 'output changed and ' + describe(ret)
                         else:
                             msg = 'output changed'
                         self.fail(msg)
                     elif ret:
                         self.fail(describe(ret))
                 def tearDown(self):
                     """Tasks to perform after run()."""
                     for entry in self._daemonpids:
                         killdaemons(entry)
                     self._daemonpids = []
                     if self._keeptmpdir:
                         log('\nKeeping testtmp dir: %s\nKeeping threadtmp dir: %s' %
                             (self._testtmp.decode('utf-8'),
                              self._threadtmp.decode('utf-8')))
                     else:
                         shutil.rmtree(self._testtmp, True)
                         shutil.rmtree(self._threadtmp, True)
                     if self._usechg:
                         # chgservers will stop automatically after they find the socket
                         # files are deleted
                         shutil.rmtree(self._chgsockdir, True)
                     if (self._ret != 0 or self._out != self._refout) and not self._skipped \
                         and not self._debug and self._out:
                         f = open(self.errpath, 'wb')
                         for line in self._out:
                             f.write(line)
                         f.close()
                     vlog("# Ret was:", self._ret, '(%s)' % self.name)
                 def _run(self, env):
                     # This should be implemented in child classes to run tests.
                     raise SkipTest('unknown test type')
                 def abort(self):
                     """Terminate execution of this test."""
                     self._aborted = True
                 def _portmap(self, i):
                     offset = b'' if i == 0 else b'%d' % i
                     return (br':%d\b' % (self._startport + i), b':$HGPORT%s' % offset)
                 def _getreplacements(self):
                     """Obtain a mapping of text replacements to apply to test output.
                     Test output needs to be normalized so it can be compared to expected
                     output. This function defines how some of that normalization will
                     occur.
                     """
                     r = [
                         # This list should be parallel to defineport in _getenv
                         self._portmap(0),
                         self._portmap(1),
                         self._portmap(2),
                         (br'(?m)^(saved backup bundle to .*\.hg)( \(glob\))?$',
                          br'\1 (glob)'),
                         (br'([^0-9])%s' % re.escape(self._localip()), br'\1$LOCALIP'),
                         (br'\bHG_TXNID=TXN:[a-f0-9]{40}\b', br'HG_TXNID=TXN:$ID$'),
                         ]
                     r.append((self._escapepath(self._testtmp), b'$TESTTMP'))
                     return r
                 def _escapepath(self, p):
                     if os.name == 'nt':
                         return (
                             (b''.join(c.isalpha() and b'[%s%s]' % (c.lower(), c.upper()) or
                                 c in b'/\\' and br'[/\\]' or c.isdigit() and c or b'\\' + c
                                 for c in p))
                         )
                     else:
                         return re.escape(p)
                 def _localip(self):
                     if self._useipv6:
                         return b'::1'
                     else:
                         return b'127.0.0.1'
                 def _getenv(self):
                     """Obtain environment variables to use during test execution."""
                     def defineport(i):
                         offset = '' if i == 0 else '%s' % i
                         env["HGPORT%s" % offset] = '%s' % (self._startport + i)
                     env = os.environ.copy()
                     env['PYTHONUSERBASE'] = sysconfig.get_config_var('userbase')
                     env['HGEMITWARNINGS'] = '1'
                     env['TESTTMP'] = self._testtmp
                     env['HOME'] = self._testtmp
                     # This number should match portneeded in _getport
                     for port in xrange(3):
                         # This list should be parallel to _portmap in _getreplacements
                         defineport(port)
                     env["HGRCPATH"] = os.path.join(self._threadtmp, b'.hgrc')
                     env["DAEMON_PIDS"] = os.path.join(self._threadtmp, b'daemon.pids')
                     env["HGEDITOR"] = ('"' + sys.executable + '"'
                                        + ' -c "import sys; sys.exit(0)"')
                     env["HGMERGE"] = "internal:merge"
                     env["HGUSER"]   = "test"
                     env["HGENCODING"] = "ascii"
                     env["HGENCODINGMODE"] = "strict"
                     env['HGIPV6'] = str(int(self._useipv6))
                     # LOCALIP could be ::1 or 127.0.0.1. Useful for tests that require raw
                     # IP addresses.
                     env['LOCALIP'] = self._localip()
                     # Reset some environment variables to well-known values so that
                     # the tests produce repeatable output.
                     env['LANG'] = env['LC_ALL'] = env['LANGUAGE'] = 'C'
                     env['TZ'] = 'GMT'
                     env["EMAIL"] = "Foo Bar <foo.bar@example.com>"
                     env['COLUMNS'] = '80'
                     env['TERM'] = 'xterm'
                     for k in ('HG HGPROF CDPATH GREP_OPTIONS http_proxy no_proxy ' +
                               'HGPLAIN HGPLAINEXCEPT EDITOR VISUAL PAGER ' +
                               'NO_PROXY CHGDEBUG').split():
                         if k in env:
                             del env[k]
                     # unset env related to hooks
                     for k in env.keys():
                         if k.startswith('HG_'):
                             del env[k]
                     if self._usechg:
                         env['CHGSOCKNAME'] = os.path.join(self._chgsockdir, b'server')
                     return env
                 def _createhgrc(self, path):
                     """Create an hgrc file for this test."""
                     hgrc = open(path, 'wb')
                     hgrc.write(b'[ui]\n')
                     hgrc.write(b'slash = True\n')
                     hgrc.write(b'interactive = False\n')
                     hgrc.write(b'mergemarkers = detailed\n')
                     hgrc.write(b'promptecho = True\n')
                     hgrc.write(b'[defaults]\n')
                     hgrc.write(b'backout = -d "0 0"\n')
                     hgrc.write(b'commit = -d "0 0"\n')
                     hgrc.write(b'shelve = --date "0 0"\n')
                     hgrc.write(b'tag = -d "0 0"\n')
                     hgrc.write(b'[devel]\n')
                     hgrc.write(b'all-warnings = true\n')
                     hgrc.write(b'[largefiles]\n')
                     hgrc.write(b'usercache = %s\n' %
                                (os.path.join(self._testtmp, b'.cache/largefiles')))
                     hgrc.write(b'[web]\n')
                     hgrc.write(b'address = localhost\n')
                     hgrc.write(b'ipv6 = %s\n' % str(self._useipv6).encode('ascii'))
                     for opt in self._extraconfigopts:
                         section, key = opt.split('.', 1)
                         assert '=' in key, ('extra config opt %s must '
                                             'have an = for assignment' % opt)
                         hgrc.write(b'[%s]\n%s\n' % (section, key))
                     hgrc.close()
                 def fail(self, msg):
                     # unittest differentiates between errored and failed.
                     # Failed is denoted by AssertionError (by default at least).
                     raise AssertionError(msg)
                 def _runcommand(self, cmd, env, normalizenewlines=False):
                     """Run command in a sub-process, capturing the output (stdout and
                     stderr).
                     Return a tuple (exitcode, output). output is None in debug mode.
                     """
                     if self._debug:
                         proc = subprocess.Popen(cmd, shell=True, cwd=self._testtmp,
                                                 env=env)
                         ret = proc.wait()
                         return (ret, None)
                     proc = Popen4(cmd, self._testtmp, self._timeout, env)
                     def cleanup():
                         terminate(proc)
                         ret = proc.wait()
                         if ret == 0:
                             ret = signal.SIGTERM << 8
                         killdaemons(env['DAEMON_PIDS'])
                         return ret
                     output = ''
                     proc.tochild.close()
                     try:
                         output = proc.fromchild.read()
                     except KeyboardInterrupt:
                         vlog('# Handling keyboard interrupt')
                         cleanup()
                         raise
                     ret = proc.wait()
                     if wifexited(ret):
                         ret = os.WEXITSTATUS(ret)
                     if proc.timeout:
                         ret = 'timeout'
                     if ret:
                         killdaemons(env['DAEMON_PIDS'])
                     for s, r in self._getreplacements():
                         output = re.sub(s, r, output)
                     if normalizenewlines:
                         output = output.replace('\r\n', '\n')
                     return ret, output.splitlines(True)
             class PythonTest(Test):
                 """A Python-based test."""
                 @property
                 def refpath(self):
                     return os.path.join(self._testdir, b'%s.out' % self.bname)
                 def _run(self, env):
                     py3kswitch = self._py3kwarnings and b' -3' or b''
                     cmd = b'%s%s "%s"' % (PYTHON, py3kswitch, self.path)
                     vlog("# Running", cmd)
                     normalizenewlines = os.name == 'nt'
                     result = self._runcommand(cmd, env,
                                               normalizenewlines=normalizenewlines)
                     if self._aborted:
                         raise KeyboardInterrupt()
                     return result
             # Some glob patterns apply only in some circumstances, so the script
             # might want to remove (glob) annotations that otherwise should be
             # retained.
             checkcodeglobpats = [
                 # On Windows it looks like \ doesn't require a (glob), but we know
                 # better.
                 re.compile(br'^pushing to \$TESTTMP/.*[^)]$'),
                 re.compile(br'^moving \S+/.*[^)]$'),
                 re.compile(br'^pulling from \$TESTTMP/.*[^)]$'),
                 # Not all platforms have 127.0.0.1 as loopback (though most do),
                 # so we always glob that too.
                 re.compile(br'.*\$LOCALIP.*$'),
             ]
             bchr = chr
             if PYTHON3:
                 bchr = lambda x: bytes([x])
             class TTest(Test):
                 """A "t test" is a test backed by a .t file."""
                 SKIPPED_PREFIX = b'skipped: '
                 FAILED_PREFIX = b'hghave check failed: '
                 NEEDESCAPE = re.compile(br'[\x00-\x08\x0b-\x1f\x7f-\xff]').search
                 ESCAPESUB = re.compile(br'[\x00-\x08\x0b-\x1f\\\x7f-\xff]').sub
                 ESCAPEMAP = dict((bchr(i), br'\x%02x' % i) for i in range(256))
                 ESCAPEMAP.update({b'\\': b'\\\\', b'\r': br'\r'})
                 @property
                 def refpath(self):
                     return os.path.join(self._testdir, self.bname)
                 def _run(self, env):
                     f = open(self.path, 'rb')
                     lines = f.readlines()
                     f.close()
                     salt, script, after, expected = self._parsetest(lines)
                     # Write out the generated script.
                     fname = b'%s.sh' % self._testtmp
                     f = open(fname, 'wb')
                     for l in script:
                         f.write(l)
                     f.close()
                     cmd = b'%s "%s"' % (self._shell, fname)
                     vlog("# Running", cmd)
                     exitcode, output = self._runcommand(cmd, env)
                     if self._aborted:
                         raise KeyboardInterrupt()
                     # Do not merge output if skipped. Return hghave message instead.
                     # Similarly, with --debug, output is None.
                     if exitcode == self.SKIPPED_STATUS or output is None:
                         return exitcode, output
                     return self._processoutput(exitcode, output, salt, after, expected)
                 def _hghave(self, reqs):
                     # TODO do something smarter when all other uses of hghave are gone.
                     runtestdir = os.path.abspath(os.path.dirname(_bytespath(__file__)))
                     tdir = runtestdir.replace(b'\\', b'/')
                     proc = Popen4(b'%s -c "%s/hghave %s"' %
                                   (self._shell, tdir, b' '.join(reqs)),
                                   self._testtmp, 0, self._getenv())
                     stdout, stderr = proc.communicate()
                     ret = proc.wait()
                     if wifexited(ret):
                         ret = os.WEXITSTATUS(ret)
                     if ret == 2:
                         print(stdout.decode('utf-8'))
                         sys.exit(1)
                     if ret != 0:
                         return False, stdout
                     if 'slow' in reqs:
                         self._timeout = self._slowtimeout
                     return True, None
                 def _parsetest(self, lines):
                     # We generate a shell script which outputs unique markers to line
                     # up script results with our source. These markers include input
                     # line number and the last return code.
                     salt = b"SALT%d" % time.time()
                     def addsalt(line, inpython):
                         if inpython:
                             script.append(b'%s %d 0\n' % (salt, line))
                         else:
                             script.append(b'echo %s %d $?\n' % (salt, line))
                     script = []
                     # After we run the shell script, we re-unify the script output
                     # with non-active parts of the source, with synchronization by our
                     # SALT line number markers. The after table contains the non-active
                     # components, ordered by line number.
                     after = {}
                     # Expected shell script output.
                     expected = {}
                     pos = prepos = -1
                     # True or False when in a true or false conditional section
                     skipping = None
                     # We keep track of whether or not we're in a Python block so we
                     # can generate the surrounding doctest magic.
                     inpython = False
                     if self._debug:
                         script.append(b'set -x\n')
                     if self._hgcommand != b'hg':
                         script.append(b'alias hg="%s"\n' % self._hgcommand)
                     if os.getenv('MSYSTEM'):
                         script.append(b'alias pwd="pwd -W"\n')
                     n = 0
                     for n, l in enumerate(lines):
                         if not l.endswith(b'\n'):
                             l += b'\n'
                         if l.startswith(b'#require'):
                             lsplit = l.split()
                             if len(lsplit) < 2 or lsplit[0] != b'#require':
                                 after.setdefault(pos, []).append('  !!! invalid #require\n')
                             haveresult, message = self._hghave(lsplit[1:])
                             if not haveresult:
                                 script = [b'echo "%s"\nexit 80\n' % message]
                                 break
                             after.setdefault(pos, []).append(l)
                         elif l.startswith(b'#if'):
                             lsplit = l.split()
                             if len(lsplit) < 2 or lsplit[0] != b'#if':
                                 after.setdefault(pos, []).append('  !!! invalid #if\n')
                             if skipping is not None:
                                 after.setdefault(pos, []).append('  !!! nested #if\n')
                             skipping = not self._hghave(lsplit[1:])[0]
                             after.setdefault(pos, []).append(l)
                         elif l.startswith(b'#else'):
                             if skipping is None:
                                 after.setdefault(pos, []).append('  !!! missing #if\n')
                             skipping = not skipping
                             after.setdefault(pos, []).append(l)
                         elif l.startswith(b'#endif'):
                             if skipping is None:
                                 after.setdefault(pos, []).append('  !!! missing #if\n')
                             skipping = None
                             after.setdefault(pos, []).append(l)
                         elif skipping:
                             after.setdefault(pos, []).append(l)
                         elif l.startswith(b'  >>> '): # python inlines
                             after.setdefault(pos, []).append(l)
                             prepos = pos
                             pos = n
                             if not inpython:
                                 # We've just entered a Python block. Add the header.
                                 inpython = True
                                 addsalt(prepos, False) # Make sure we report the exit code.
                                 script.append(b'%s -m heredoctest <<EOF\n' % PYTHON)
                             addsalt(n, True)
                             script.append(l[2:])
                         elif l.startswith(b'  ... '): # python inlines
                             after.setdefault(prepos, []).append(l)
                             script.append(l[2:])
                         elif l.startswith(b'  $ '): # commands
                             if inpython:
                                 script.append(b'EOF\n')
                                 inpython = False
                             after.setdefault(pos, []).append(l)
                             prepos = pos
                             pos = n
                             addsalt(n, False)
                             cmd = l[4:].split()
                             if len(cmd) == 2 and cmd[0] == b'cd':
                                 l = b'  $ cd %s || exit 1\n' % cmd[1]
                             script.append(l[4:])
                         elif l.startswith(b'  > '): # continuations
                             after.setdefault(prepos, []).append(l)
                             script.append(l[4:])
                         elif l.startswith(b'  '): # results
                             # Queue up a list of expected results.
                             expected.setdefault(pos, []).append(l[2:])
                         else:
                             if inpython:
                                 script.append(b'EOF\n')
                                 inpython = False
                             # Non-command/result. Queue up for merged output.
                             after.setdefault(pos, []).append(l)
                     if inpython:
                         script.append(b'EOF\n')
                     if skipping is not None:
                         after.setdefault(pos, []).append('  !!! missing #endif\n')
                     addsalt(n + 1, False)
                     return salt, script, after, expected
                 def _processoutput(self, exitcode, output, salt, after, expected):
                     # Merge the script output back into a unified test.
                     warnonly = 1 # 1: not yet; 2: yes; 3: for sure not
                     if exitcode != 0:
                         warnonly = 3
                     pos = -1
                     postout = []
                     for l in output:
                         lout, lcmd = l, None
                         if salt in l:
                             lout, lcmd = l.split(salt, 1)
                         while lout:
                             if not lout.endswith(b'\n'):
                                 lout += b' (no-eol)\n'
                             # Find the expected output at the current position.
                             els = [None]
                             if expected.get(pos, None):
                                 els = expected[pos]
                             i = 0
                             optional = []
                             while i < len(els):
                                 el = els[i]
                                 r = TTest.linematch(el, lout)
                                 if isinstance(r, str):
                                     if r == '+glob':
                                         lout = el[:-1] + ' (glob)\n'
                                         r = '' # Warn only this line.
                                     elif r == '-glob':
                                         lout = ''.join(el.rsplit(' (glob)', 1))
                                         r = '' # Warn only this line.
                                     elif r == "retry":
                                         postout.append(b'  ' + el)
                                         els.pop(i)
                                         break
                                     else:
                                         log('\ninfo, unknown linematch result: %r\n' % r)
                                         r = False
                                 if r:
                                     els.pop(i)
                                     break
                                 if el:
                                     if el.endswith(b" (?)\n"):
                                         optional.append(i)
                                     else:
                                         m = optline.match(el)
                                         if m:
                                             conditions = [c for c in m.group(2).split(' ')]
                                             if self._hghave(conditions)[0]:
                                                 lout = el
                                             else:
                                                 optional.append(i)
                                 i += 1
                             if r:
                                 if r == "retry":
                                     continue
                                 # clean up any optional leftovers
                                 for i in optional:
                                     postout.append(b'  ' + els[i])
                                 for i in reversed(optional):
                                     del els[i]
                                 postout.append(b'  ' + el)
                             else:
                                 if self.NEEDESCAPE(lout):
                                     lout = TTest._stringescape(b'%s (esc)\n' %
                                                                lout.rstrip(b'\n'))
                                 postout.append(b'  ' + lout) # Let diff deal with it.
                                 if r != '': # If line failed.
                                     warnonly = 3 # for sure not
                                 elif warnonly == 1: # Is "not yet" and line is warn only.
                                     warnonly = 2 # Yes do warn.
                             break
                         else:
                             # clean up any optional leftovers
                             while expected.get(pos, None):
                                 el = expected[pos].pop(0)
                                 if el:
                                     if (not optline.match(el)
                                         and not el.endswith(b" (?)\n")):
                                         break
                                 postout.append(b'  ' + el)
                         if lcmd:
                             # Add on last return code.
                             ret = int(lcmd.split()[1])
                             if ret != 0:
                                 postout.append(b'  [%d]\n' % ret)
                             if pos in after:
                                 # Merge in non-active test bits.
                                 postout += after.pop(pos)
                             pos = int(lcmd.split()[0])
                     if pos in after:
                         postout += after.pop(pos)
                     if warnonly == 2:
                         exitcode = False # Set exitcode to warned.
                     return exitcode, postout
                 @staticmethod
                 def rematch(el, l):
                     try:
                         # use \Z to ensure that the regex matches to the end of the string
                         if os.name == 'nt':
                             return re.match(el + br'\r?\n\Z', l)
                         return re.match(el + br'\n\Z', l)
                     except re.error:
                         # el is an invalid regex
                         return False
                 @staticmethod
                 def globmatch(el, l):
                     # The only supported special characters are * and ? plus / which also
                     # matches \ on windows. Escaping of these characters is supported.
                     if el + b'\n' == l:
                         if os.altsep:
                             # matching on "/" is not needed for this line
                             for pat in checkcodeglobpats:
                                 if pat.match(el):
                                     return True
                             return b'-glob'
                         return True
                     el = el.replace(b'$LOCALIP', b'*')
                     i, n = 0, len(el)
                     res = b''
                     while i < n:
                         c = el[i:i + 1]
                         i += 1
                         if c == b'\\' and i < n and el[i:i + 1] in b'*?\\/':
                             res += el[i - 1:i + 1]
                             i += 1
                         elif c == b'*':
                             res += b'.*'
                         elif c == b'?':
                             res += b'.'
                         elif c == b'/' and os.altsep:
                             res += b'[/\\\\]'
                         else:
                             res += re.escape(c)
                     return TTest.rematch(res, l)
                 @staticmethod
                 def linematch(el, l):
                     retry = False
                     if el == l: # perfect match (fast)
                         return True
                     if el:
                         if el.endswith(b" (?)\n"):
                             retry = "retry"
                             el = el[:-5] + b"\n"
                         else:
                             m = optline.match(el)
                             if m:
                                 el = m.group(1) + b"\n"
                                 retry = "retry"
                         if el.endswith(b" (esc)\n"):
                             if PYTHON3:
                                 el = el[:-7].decode('unicode_escape') + '\n'
                                 el = el.encode('utf-8')
                             else:
                                 el = el[:-7].decode('string-escape') + '\n'
                         if el == l or os.name == 'nt' and el[:-1] + b'\r\n' == l:
                             return True
                         if el.endswith(b" (re)\n"):
                             return TTest.rematch(el[:-6], l) or retry
                         if el.endswith(b" (glob)\n"):
                             # ignore '(glob)' added to l by 'replacements'
                             if l.endswith(b" (glob)\n"):
                                 l = l[:-8] + b"\n"
                             return TTest.globmatch(el[:-8], l) or retry
                         if os.altsep and l.replace(b'\\', b'/') == el:
                             return b'+glob'
                     return retry
                 @staticmethod
                 def parsehghaveoutput(lines):
                     '''Parse hghave log lines.
                     Return tuple of lists (missing, failed):
                       * the missing/unknown features
                       * the features for which existence check failed'''
                     missing = []
                     failed = []
                     for line in lines:
                         if line.startswith(TTest.SKIPPED_PREFIX):
                             line = line.splitlines()[0]
                             missing.append(line[len(TTest.SKIPPED_PREFIX):].decode('utf-8'))
                         elif line.startswith(TTest.FAILED_PREFIX):
                             line = line.splitlines()[0]
                             failed.append(line[len(TTest.FAILED_PREFIX):].decode('utf-8'))
                     return missing, failed
                 @staticmethod
                 def _escapef(m):
                     return TTest.ESCAPEMAP[m.group(0)]
                 @staticmethod
                 def _stringescape(s):
                     return TTest.ESCAPESUB(TTest._escapef, s)
             iolock = threading.RLock()
             class SkipTest(Exception):
                 """Raised to indicate that a test is to be skipped."""
             class IgnoreTest(Exception):
                 """Raised to indicate that a test is to be ignored."""
             class WarnTest(Exception):
                 """Raised to indicate that a test warned."""
             class ReportedTest(Exception):
                 """Raised to indicate that a test already reported."""
             class TestResult(unittest._TextTestResult):
                 """Holds results when executing via unittest."""
                 # Don't worry too much about accessing the non-public _TextTestResult.
                 # It is relatively common in Python testing tools.
                 def __init__(self, options, *args, **kwargs):
                     super(TestResult, self).__init__(*args, **kwargs)
                     self._options = options
                     # unittest.TestResult didn't have skipped until 2.7. We need to
                     # polyfill it.
                     self.skipped = []
                     # We have a custom "ignored" result that isn't present in any Python
                     # unittest implementation. It is very similar to skipped. It may make
                     # sense to map it into skip some day.
                     self.ignored = []
                     # We have a custom "warned" result that isn't present in any Python
                     # unittest implementation. It is very similar to failed. It may make
                     # sense to map it into fail some day.
                     self.warned = []
                     self.times = []
                     self._firststarttime = None
                     # Data stored for the benefit of generating xunit reports.
                     self.successes = []
                     self.faildata = {}
                 def addFailure(self, test, reason):
                     self.failures.append((test, reason))
                     if self._options.first:
                         self.stop()
                     else:
                         with iolock:
                             if reason == "timed out":
                                 self.stream.write('t')
                             else:
                                 if not self._options.nodiff:
                                     self.stream.write('\nERROR: %s output changed\n' % test)
                                 self.stream.write('!')
                             self.stream.flush()
                 def addSuccess(self, test):
                     with iolock:
                         super(TestResult, self).addSuccess(test)
                     self.successes.append(test)
                 def addError(self, test, err):
                     super(TestResult, self).addError(test, err)
                     if self._options.first:
                         self.stop()
                 # Polyfill.
                 def addSkip(self, test, reason):
                     self.skipped.append((test, reason))
                     with iolock:
                         if self.showAll:
                             self.stream.writeln('skipped %s' % reason)
                         else:
                             self.stream.write('s')
                             self.stream.flush()
                 def addIgnore(self, test, reason):
                     self.ignored.append((test, reason))
                     with iolock:
                         if self.showAll:
                             self.stream.writeln('ignored %s' % reason)
                         else:
                             if reason not in ('not retesting', "doesn't match keyword"):
                                 self.stream.write('i')
                             else:
                                 self.testsRun += 1
                             self.stream.flush()
                 def addWarn(self, test, reason):
                     self.warned.append((test, reason))
                     if self._options.first:
                         self.stop()
                     with iolock:
                         if self.showAll:
                             self.stream.writeln('warned %s' % reason)
                         else:
                             self.stream.write('~')
                             self.stream.flush()
                 def addOutputMismatch(self, test, ret, got, expected):
                     """Record a mismatch in test output for a particular test."""
                     if self.shouldStop:
                         # don't print, some other test case already failed and
                         # printed, we're just stale and probably failed due to our
                         # temp dir getting cleaned up.
                         return
                     accepted = False
                     lines = []
                     with iolock:
                         if self._options.nodiff:
                             pass
                         elif self._options.view:
                             v = self._options.view
                             if PYTHON3:
                                 v = _bytespath(v)
                             os.system(b"%s %s %s" %
                                       (v, test.refpath, test.errpath))
                         else:
                             servefail, lines = getdiff(expected, got,
                                                        test.refpath, test.errpath)
                             if servefail:
                                 self.addFailure(
                                     test,
                                     'server failed to start (HGPORT=%s)' % test._startport)
                                 raise ReportedTest('server failed to start')
                             else:
                                 self.stream.write('\n')
                                 for line in lines:
                                     if PYTHON3:
                                         self.stream.flush()
                                         self.stream.buffer.write(line)
                                         self.stream.buffer.flush()
                                     else:
                                         self.stream.write(line)
                                         self.stream.flush()
                         # handle interactive prompt without releasing iolock
                         if self._options.interactive:
                             self.stream.write('Accept this change? [n] ')
                             answer = sys.stdin.readline().strip()
                             if answer.lower() in ('y', 'yes'):
                                 if test.name.endswith('.t'):
                                     rename(test.errpath, test.path)
                                 else:
                                     rename(test.errpath, '%s.out' % test.path)
                                 accepted = True
                         if not accepted:
                             self.faildata[test.name] = b''.join(lines)
                     return accepted
                 def startTest(self, test):
                     super(TestResult, self).startTest(test)
                     # os.times module computes the user time and system time spent by
                     # child's processes along with real elapsed time taken by a process.
                     # This module has one limitation. It can only work for Linux user
                     # and not for Windows.
                     test.started = os.times()
                     if self._firststarttime is None: # thread racy but irrelevant
                         self._firststarttime = test.started[4]
                 def stopTest(self, test, interrupted=False):
                     super(TestResult, self).stopTest(test)
                     test.stopped = os.times()
                     starttime = test.started
                     endtime = test.stopped
                     origin = self._firststarttime
                     self.times.append((test.name,
                                        endtime[2] - starttime[2], # user space CPU time
                                        endtime[3] - starttime[3], # sys  space CPU time
                                        endtime[4] - starttime[4], # real time
                                        starttime[4] - origin, # start date in run context
                                        endtime[4] - origin, # end date in run context
                                        ))
                     if interrupted:
                         with iolock:
                             self.stream.writeln('INTERRUPTED: %s (after %d seconds)' % (
                                 test.name, self.times[-1][3]))
             class TestSuite(unittest.TestSuite):
                 """Custom unittest TestSuite that knows how to execute Mercurial tests."""
                 def __init__(self, testdir, jobs=1, whitelist=None, blacklist=None,
                              retest=False, keywords=None, loop=False, runs_per_test=1,
                              loadtest=None, showchannels=False,
                              *args, **kwargs):
                     """Create a new instance that can run tests with a configuration.
                     testdir specifies the directory where tests are executed from. This
                     is typically the ``tests`` directory from Mercurial's source
                     repository.
                     jobs specifies the number of jobs to run concurrently. Each test
                     executes on its own thread. Tests actually spawn new processes, so
                     state mutation should not be an issue.
                     If there is only one job, it will use the main thread.
                     whitelist and blacklist denote tests that have been whitelisted and
                     blacklisted, respectively. These arguments don't belong in TestSuite.
                     Instead, whitelist and blacklist should be handled by the thing that
                     populates the TestSuite with tests. They are present to preserve
                     backwards compatible behavior which reports skipped tests as part
                     of the results.
                     retest denotes whether to retest failed tests. This arguably belongs
                     outside of TestSuite.
                     keywords denotes key words that will be used to filter which tests
                     to execute. This arguably belongs outside of TestSuite.
                     loop denotes whether to loop over tests forever.
                     """
                     super(TestSuite, self).__init__(*args, **kwargs)
                     self._jobs = jobs
                     self._whitelist = whitelist
                     self._blacklist = blacklist
                     self._retest = retest
                     self._keywords = keywords
                     self._loop = loop
                     self._runs_per_test = runs_per_test
                     self._loadtest = loadtest
                     self._showchannels = showchannels
                 def run(self, result):
                     # We have a number of filters that need to be applied. We do this
                     # here instead of inside Test because it makes the running logic for
                     # Test simpler.
                     tests = []
                     num_tests = [0]
                     for test in self._tests:
                         def get():
                             num_tests[0] += 1
                             if getattr(test, 'should_reload', False):
                                 return self._loadtest(test.path, num_tests[0])
                             return test
                         if not os.path.exists(test.path):
                             result.addSkip(test, "Doesn't exist")
                             continue
                         if not (self._whitelist and test.name in self._whitelist):
                             if self._blacklist and test.bname in self._blacklist:
                                 result.addSkip(test, 'blacklisted')
                                 continue
                             if self._retest and not os.path.exists(test.errpath):
                                 result.addIgnore(test, 'not retesting')
                                 continue
                             if self._keywords:
                                 f = open(test.path, 'rb')
                                 t = f.read().lower() + test.bname.lower()
                                 f.close()
                                 ignored = False
                                 for k in self._keywords.lower().split():
                                     if k not in t:
                                         result.addIgnore(test, "doesn't match keyword")
                                         ignored = True
                                         break
                                 if ignored:
                                     continue
                         for _ in xrange(self._runs_per_test):
                             tests.append(get())
                     runtests = list(tests)
                     done = queue.Queue()
                     running = 0
                     channels = [""] * self._jobs
                     def job(test, result):
                         for n, v in enumerate(channels):
                             if not v:
                                 channel = n
                                 break
                         channels[channel] = "=" + test.name[5:].split(".")[0]
                         try:
                             test(result)
                             done.put(None)
                         except KeyboardInterrupt:
                             pass
                         except: # re-raises
                             done.put(('!', test, 'run-test raised an error, see traceback'))
                             raise
                         try:
                             channels[channel] = ''
                         except IndexError:
                             pass
                     def stat():
                         count = 0
                         while channels:
                             d = '\n%03s  ' % count
                             for n, v in enumerate(channels):
                                 if v:
                                     d += v[0]
                                     channels[n] = v[1:] or '.'
                                 else:
                                     d += ' '
                                 d += ' '
                             with iolock:
                                 sys.stdout.write(d + '  ')
                                 sys.stdout.flush()
                             for x in xrange(10):
                                 if channels:
                                     time.sleep(.1)
                             count += 1
                     stoppedearly = False
                     if self._showchannels:
                         statthread = threading.Thread(target=stat, name="stat")
                         statthread.start()
                     try:
                         while tests or running:
                             if not done.empty() or running == self._jobs or not tests:
                                 try:
                                     done.get(True, 1)
                                     running -= 1
                                     if result and result.shouldStop:
                                         stoppedearly = True
                                         break
                                 except queue.Empty:
                                     continue
                             if tests and not running == self._jobs:
                                 test = tests.pop(0)
                                 if self._loop:
                                     if getattr(test, 'should_reload', False):
                                         num_tests[0] += 1
                                         tests.append(
                                             self._loadtest(test.name, num_tests[0]))
                                     else:
                                         tests.append(test)
                                 if self._jobs == 1:
                                     job(test, result)
                                 else:
                                     t = threading.Thread(target=job, name=test.name,
                                                          args=(test, result))
                                     t.start()
                                 running += 1
                         # If we stop early we still need to wait on started tests to
                         # finish. Otherwise, there is a race between the test completing
                         # and the test's cleanup code running. This could result in the
                         # test reporting incorrect.
                         if stoppedearly:
                             while running:
                                 try:
                                     done.get(True, 1)
                                     running -= 1
                                 except queue.Empty:
                                     continue
                     except KeyboardInterrupt:
                         for test in runtests:
                             test.abort()
                     channels = []
                     return result
             # Save the most recent 5 wall-clock runtimes of each test to a
             # human-readable text file named .testtimes. Tests are sorted
             # alphabetically, while times for each test are listed from oldest to
             # newest.
             def loadtimes(testdir):
                 times = []
                 try:
                     with open(os.path.join(testdir, b'.testtimes-')) as fp:
                         for line in fp:
                             ts = line.split()
                             times.append((ts[0], [float(t) for t in ts[1:]]))
                 except IOError as err:
                     if err.errno != errno.ENOENT:
                         raise
                 return times
             def savetimes(testdir, result):
                 saved = dict(loadtimes(testdir))
                 maxruns = 5
                 skipped = set([str(t[0]) for t in result.skipped])
                 for tdata in result.times:
                     test, real = tdata[0], tdata[3]
                     if test not in skipped:
                         ts = saved.setdefault(test, [])
                         ts.append(real)
                         ts[:] = ts[-maxruns:]
                 fd, tmpname = tempfile.mkstemp(prefix=b'.testtimes',
                                                dir=testdir, text=True)
                 with os.fdopen(fd, 'w') as fp:
                     for name, ts in sorted(saved.items()):
                         fp.write('%s %s\n' % (name, ' '.join(['%.3f' % (t,) for t in ts])))
                 timepath = os.path.join(testdir, b'.testtimes')
                 try:
                     os.unlink(timepath)
                 except OSError:
                     pass
                 try:
                     os.rename(tmpname, timepath)
                 except OSError:
                     pass
             class TextTestRunner(unittest.TextTestRunner):
                 """Custom unittest test runner that uses appropriate settings."""
                 def __init__(self, runner, *args, **kwargs):
                     super(TextTestRunner, self).__init__(*args, **kwargs)
                     self._runner = runner
                 def run(self, test):
                     result = TestResult(self._runner.options, self.stream,
                                         self.descriptions, self.verbosity)
                     test(result)
                     failed = len(result.failures)
                     warned = len(result.warned)
                     skipped = len(result.skipped)
                     ignored = len(result.ignored)
                     with iolock:
                         self.stream.writeln('')
                         if not self._runner.options.noskips:
                             for test, msg in result.skipped:
                                 self.stream.writeln('Skipped %s: %s' % (test.name, msg))
                         for test, msg in result.warned:
                             self.stream.writeln('Warned %s: %s' % (test.name, msg))
                         for test, msg in result.failures:
                             self.stream.writeln('Failed %s: %s' % (test.name, msg))
                         for test, msg in result.errors:
                             self.stream.writeln('Errored %s: %s' % (test.name, msg))
                         if self._runner.options.xunit:
                             with open(self._runner.options.xunit, 'wb') as xuf:
                                 timesd = dict((t[0], t[3]) for t in result.times)
                                 doc = minidom.Document()
                                 s = doc.createElement('testsuite')
                                 s.setAttribute('name', 'run-tests')
                                 s.setAttribute('tests', str(result.testsRun))
                                 s.setAttribute('errors', "0") # TODO
                                 s.setAttribute('failures', str(failed))
                                 s.setAttribute('skipped', str(skipped + ignored))
                                 doc.appendChild(s)
                                 for tc in result.successes:
                                     t = doc.createElement('testcase')
                                     t.setAttribute('name', tc.name)
                                     t.setAttribute('time', '%.3f' % timesd[tc.name])
                                     s.appendChild(t)
                                 for tc, err in sorted(result.faildata.items()):
                                     t = doc.createElement('testcase')
                                     t.setAttribute('name', tc)
                                     t.setAttribute('time', '%.3f' % timesd[tc])
                                     # createCDATASection expects a unicode or it will
                                     # convert using default conversion rules, which will
                                     # fail if string isn't ASCII.
                                     err = cdatasafe(err).decode('utf-8', 'replace')
                                     cd = doc.createCDATASection(err)
                                     t.appendChild(cd)
                                     s.appendChild(t)
                                 xuf.write(doc.toprettyxml(indent='  ', encoding='utf-8'))
                         if self._runner.options.json:
                             jsonpath = os.path.join(self._runner._testdir, b'report.json')
                             with open(jsonpath, 'w') as fp:
                                 timesd = {}
                                 for tdata in result.times:
                                     test = tdata[0]
                                     timesd[test] = tdata[1:]
                                 outcome = {}
                                 groups = [('success', ((tc, None)
                                            for tc in result.successes)),
                                           ('failure', result.failures),
                                           ('skip', result.skipped)]
                                 for res, testcases in groups:
                                     for tc, __ in testcases:
                                         if tc.name in timesd:
                                             diff = result.faildata.get(tc.name, b'')
                                             tres = {'result': res,
                                                     'time': ('%0.3f' % timesd[tc.name][2]),
                                                     'cuser': ('%0.3f' % timesd[tc.name][0]),
                                                     'csys': ('%0.3f' % timesd[tc.name][1]),
                                                     'start': ('%0.3f' % timesd[tc.name][3]),
                                                     'end': ('%0.3f' % timesd[tc.name][4]),
                                                     'diff': diff.decode('unicode_escape'),
                                                     }
                                         else:
                                             # blacklisted test
                                             tres = {'result': res}
                                         outcome[tc.name] = tres
                                 jsonout = json.dumps(outcome, sort_keys=True, indent=4,
                                                      separators=(',', ': '))
                                 fp.writelines(("testreport =", jsonout))
                         self._runner._checkhglib('Tested')
                         savetimes(self._runner._testdir, result)
                         if failed and self._runner.options.known_good_rev:
                             def nooutput(args):
                                 p = subprocess.Popen(args, stderr=subprocess.STDOUT,
                                                      stdout=subprocess.PIPE)
                                 p.stdout.read()
                                 p.wait()
                             for test, msg in result.failures:
                                 nooutput(['hg', 'bisect', '--reset']),
                                 nooutput(['hg', 'bisect', '--bad', '.'])
                                 nooutput(['hg', 'bisect', '--good',
                                           self._runner.options.known_good_rev])
                                 # TODO: we probably need to forward some options
                                 # that alter hg's behavior inside the tests.
                                 rtc = '%s %s %s' % (sys.executable, sys.argv[0], test)
                                 sub = subprocess.Popen(['hg', 'bisect', '--command', rtc],
                                                        stderr=subprocess.STDOUT,
                                                        stdout=subprocess.PIPE)
                                 data = sub.stdout.read()
                                 sub.wait()
                                 m = re.search(
                                     (r'\nThe first (?P<goodbad>bad|good) revision '
                                      r'is:\nchangeset: +\d+:(?P<node>[a-f0-9]+)\n.*\n'
                                      r'summary: +(?P<summary>[^\n]+)\n'),
                                     data, (re.MULTILINE | re.DOTALL))
                                 if m is None:
                                     self.stream.writeln(
                                         'Failed to identify failure point for %s' % test)
                                     continue
                                 dat = m.groupdict()
                                 verb = 'broken' if dat['goodbad'] == 'bad' else 'fixed'
                                 self.stream.writeln(
                                     '%s %s by %s (%s)' % (
                                         test, verb, dat['node'], dat['summary']))
                         self.stream.writeln(
                             '# Ran %d tests, %d skipped, %d warned, %d failed.'
                             % (result.testsRun,
                                skipped + ignored, warned, failed))
                         if failed:
                             self.stream.writeln('python hash seed: %s' %
                                 os.environ['PYTHONHASHSEED'])
                         if self._runner.options.time:
                             self.printtimes(result.times)
                     return result
                 def printtimes(self, times):
                     # iolock held by run
                     self.stream.writeln('# Producing time report')
                     times.sort(key=lambda t: (t[3]))
                     cols = '%7.3f %7.3f %7.3f %7.3f %7.3f   %s'
                     self.stream.writeln('%-7s %-7s %-7s %-7s %-7s   %s' %
                                         ('start', 'end', 'cuser', 'csys', 'real', 'Test'))
                     for tdata in times:
                         test = tdata[0]
                         cuser, csys, real, start, end = tdata[1:6]
                         self.stream.writeln(cols % (start, end, cuser, csys, real, test))
             class TestRunner(object):
                 """Holds context for executing tests.
                 Tests rely on a lot of state. This object holds it for them.
                 """
                 # Programs required to run tests.
                 REQUIREDTOOLS = [
                     os.path.basename(_bytespath(sys.executable)),
                     b'diff',
                     b'grep',
                     b'unzip',
                     b'gunzip',
                     b'bunzip2',
                     b'sed',
                 ]
                 # Maps file extensions to test class.
                 TESTTYPES = [
                     (b'.py', PythonTest),
                     (b'.t', TTest),
                 ]
                 def __init__(self):
                     self.options = None
                     self._hgroot = None
                     self._testdir = None
                     self._hgtmp = None
                     self._installdir = None
                     self._bindir = None
                     self._tmpbinddir = None
                     self._pythondir = None
                     self._coveragefile = None
                     self._createdfiles = []
                     self._hgcommand = None
                     self._hgpath = None
                     self._portoffset = 0
                     self._ports = {}
                 def run(self, args, parser=None):
                     """Run the test suite."""
                     oldmask = os.umask(0o22)
                     try:
                         parser = parser or getparser()
                         options, args = parseargs(args, parser)
                         # positional arguments are paths to test files to run, so
                         # we make sure they're all bytestrings
                         args = [_bytespath(a) for a in args]
                         self.options = options
                         self._checktools()
                         tests = self.findtests(args)
                         if options.profile_runner:
                             import statprof
                             statprof.start()
                         result = self._run(tests)
                         if options.profile_runner:
                             statprof.stop()
                             statprof.display()
                         return result
                     finally:
                         os.umask(oldmask)
                 def _run(self, tests):
                     if self.options.random:
                         random.shuffle(tests)
                     else:
                         # keywords for slow tests
                         slow = {b'svn': 10,
                                 b'cvs': 10,
                                 b'hghave': 10,
                                 b'largefiles-update': 10,
                                 b'run-tests': 10,
                                 b'corruption': 10,
                                 b'race': 10,
                                 b'i18n': 10,
                                 b'check': 100,
                                 b'gendoc': 100,
                                 b'contrib-perf': 200,
                                }
                         perf = {}
                         def sortkey(f):
                             # run largest tests first, as they tend to take the longest
                             try:
                                 return perf[f]
                             except KeyError:
                                 try:
                                     val = -os.stat(f).st_size
                                 except OSError as e:
                                     if e.errno != errno.ENOENT:
                                         raise
                                     perf[f] = -1e9 # file does not exist, tell early
                                     return -1e9
                                 for kw, mul in slow.items():
                                     if kw in f:
                                         val *= mul
                                 if f.endswith(b'.py'):
                                     val /= 10.0
                                 perf[f] = val / 1000.0
                                 return perf[f]
                         tests.sort(key=sortkey)
                     self._testdir = osenvironb[b'TESTDIR'] = getattr(
                         os, 'getcwdb', os.getcwd)()
                     if 'PYTHONHASHSEED' not in os.environ:
                         # use a random python hash seed all the time
                         # we do the randomness ourself to know what seed is used
                         os.environ['PYTHONHASHSEED'] = str(random.getrandbits(32))
                     if self.options.tmpdir:
                         self.options.keep_tmpdir = True
                         tmpdir = _bytespath(self.options.tmpdir)
                         if os.path.exists(tmpdir):
                             # Meaning of tmpdir has changed since 1.3: we used to create
                             # HGTMP inside tmpdir; now HGTMP is tmpdir.  So fail if
                             # tmpdir already exists.
                             print("error: temp dir %r already exists" % tmpdir)
                             return 1
                             # Automatically removing tmpdir sounds convenient, but could
                             # really annoy anyone in the habit of using "--tmpdir=/tmp"
                             # or "--tmpdir=$HOME".
                             #vlog("# Removing temp dir", tmpdir)
                             #shutil.rmtree(tmpdir)
                         os.makedirs(tmpdir)
                     else:
                         d = None
                         if os.name == 'nt':
                             # without this, we get the default temp dir location, but
                             # in all lowercase, which causes troubles with paths (issue3490)
                             d = osenvironb.get(b'TMP', None)
                         tmpdir = tempfile.mkdtemp(b'', b'hgtests.', d)
                     self._hgtmp = osenvironb[b'HGTMP'] = (
                         os.path.realpath(tmpdir))
                     if self.options.with_hg:
                         self._installdir = None
                         whg = self.options.with_hg
                         self._bindir = os.path.dirname(os.path.realpath(whg))
                         assert isinstance(self._bindir, bytes)
                         self._hgcommand = os.path.basename(whg)
                         self._tmpbindir = os.path.join(self._hgtmp, b'install', b'bin')
                         os.makedirs(self._tmpbindir)
                         # This looks redundant with how Python initializes sys.path from
                         # the location of the script being executed.  Needed because the
                         # "hg" specified by --with-hg is not the only Python script
                         # executed in the test suite that needs to import 'mercurial'
                         # ... which means it's not really redundant at all.
                         self._pythondir = self._bindir
                     else:
                         self._installdir = os.path.join(self._hgtmp, b"install")
                         self._bindir = os.path.join(self._installdir, b"bin")
                         self._hgcommand = b'hg'
                         self._tmpbindir = self._bindir
                         self._pythondir = os.path.join(self._installdir, b"lib", b"python")
                     # set CHGHG, then replace "hg" command by "chg"
                     chgbindir = self._bindir
                     if self.options.chg or self.options.with_chg:
                         osenvironb[b'CHGHG'] = os.path.join(self._bindir, self._hgcommand)
                     else:
                         osenvironb.pop(b'CHGHG', None)  # drop flag for hghave
                     if self.options.chg:
                         self._hgcommand = b'chg'
                     elif self.options.with_chg:
                         chgbindir = os.path.dirname(os.path.realpath(self.options.with_chg))
                         self._hgcommand = os.path.basename(self.options.with_chg)
                     osenvironb[b"BINDIR"] = self._bindir
                     osenvironb[b"PYTHON"] = PYTHON
                     if self.options.with_python3:
                         osenvironb[b'PYTHON3'] = self.options.with_python3
                     fileb = _bytespath(__file__)
                     runtestdir = os.path.abspath(os.path.dirname(fileb))
                     osenvironb[b'RUNTESTDIR'] = runtestdir
                     if PYTHON3:
                         sepb = _bytespath(os.pathsep)
                     else:
                         sepb = os.pathsep
                     path = [self._bindir, runtestdir] + osenvironb[b"PATH"].split(sepb)
                     if os.path.islink(__file__):
                         # test helper will likely be at the end of the symlink
                         realfile = os.path.realpath(fileb)
                         realdir = os.path.abspath(os.path.dirname(realfile))
                         path.insert(2, realdir)
                     if chgbindir != self._bindir:
                         path.insert(1, chgbindir)
                     if self._testdir != runtestdir:
                         path = [self._testdir] + path
                     if self._tmpbindir != self._bindir:
                         path = [self._tmpbindir] + path
                     osenvironb[b"PATH"] = sepb.join(path)
                     # Include TESTDIR in PYTHONPATH so that out-of-tree extensions
                     # can run .../tests/run-tests.py test-foo where test-foo
                     # adds an extension to HGRC. Also include run-test.py directory to
                     # import modules like heredoctest.
                     pypath = [self._pythondir, self._testdir, runtestdir]
                     # We have to augment PYTHONPATH, rather than simply replacing
                     # it, in case external libraries are only available via current
                     # PYTHONPATH.  (In particular, the Subversion bindings on OS X
                     # are in /opt/subversion.)
                     oldpypath = osenvironb.get(IMPL_PATH)
                     if oldpypath:
                         pypath.append(oldpypath)
                     osenvironb[IMPL_PATH] = sepb.join(pypath)
                     if self.options.pure:
                         os.environ["HGTEST_RUN_TESTS_PURE"] = "--pure"
                         os.environ["HGMODULEPOLICY"] = "py"
                     if self.options.allow_slow_tests:
                         os.environ["HGTEST_SLOW"] = "slow"
                     elif 'HGTEST_SLOW' in os.environ:
                         del os.environ['HGTEST_SLOW']
                     self._coveragefile = os.path.join(self._testdir, b'.coverage')
                     vlog("# Using TESTDIR", self._testdir)
                     vlog("# Using RUNTESTDIR", osenvironb[b'RUNTESTDIR'])
                     vlog("# Using HGTMP", self._hgtmp)
                     vlog("# Using PATH", os.environ["PATH"])
                     vlog("# Using", IMPL_PATH, osenvironb[IMPL_PATH])
                     try:
                         return self._runtests(tests) or 0
                     finally:
                         time.sleep(.1)
                         self._cleanup()
                 def findtests(self, args):
                     """Finds possible test files from arguments.
                     If you wish to inject custom tests into the test harness, this would
                     be a good function to monkeypatch or override in a derived class.
                     """
                     if not args:
                         if self.options.changed:
                             proc = Popen4('hg st --rev "%s" -man0 .' %
                                           self.options.changed, None, 0)
                             stdout, stderr = proc.communicate()
                             args = stdout.strip(b'\0').split(b'\0')
                         else:
                             args = os.listdir(b'.')
                     return [t for t in args
                             if os.path.basename(t).startswith(b'test-')
                                 and (t.endswith(b'.py') or t.endswith(b'.t'))]
                 def _runtests(self, tests):
                     try:
                         if self._installdir:
                             self._installhg()
                             self._checkhglib("Testing")
                         else:
                             self._usecorrectpython()
                         if self.options.chg:
                             assert self._installdir
                             self._installchg()
                         if self.options.restart:
                             orig = list(tests)
                             while tests:
                                 if os.path.exists(tests[0] + ".err"):
                                     break
                                 tests.pop(0)
                             if not tests:
                                 print("running all tests")
                                 tests = orig
                         tests = [self._gettest(t, i) for i, t in enumerate(tests)]
                         failed = False
                         warned = False
                         kws = self.options.keywords
                         if kws is not None and PYTHON3:
                             kws = kws.encode('utf-8')
                         suite = TestSuite(self._testdir,
                                           jobs=self.options.jobs,
                                           whitelist=self.options.whitelisted,
                                           blacklist=self.options.blacklist,
                                           retest=self.options.retest,
                                           keywords=kws,
                                           loop=self.options.loop,
                                           runs_per_test=self.options.runs_per_test,
                                           showchannels=self.options.showchannels,
                                           tests=tests, loadtest=self._gettest)
                         verbosity = 1
                         if self.options.verbose:
                             verbosity = 2
                         runner = TextTestRunner(self, verbosity=verbosity)
                         result = runner.run(suite)
                         if result.failures:
                             failed = True
                         if result.warned:
                             warned = True
                         if self.options.anycoverage:
                             self._outputcoverage()
                     except KeyboardInterrupt:
                         failed = True
                         print("\ninterrupted!")
                     if failed:
                         return 1
                     if warned:
                         return 80
                 def _getport(self, count):
                     port = self._ports.get(count) # do we have a cached entry?
                     if port is None:
                         portneeded = 3
                         # above 100 tries we just give up and let test reports failure
                         for tries in xrange(100):
                             allfree = True
                             port = self.options.port + self._portoffset
                             for idx in xrange(portneeded):
                                 if not checkportisavailable(port + idx):
                                     allfree = False
                                     break
                             self._portoffset += portneeded
                             if allfree:
                                 break
                         self._ports[count] = port
                     return port
                 def _gettest(self, test, count):
                     """Obtain a Test by looking at its filename.
                     Returns a Test instance. The Test may not be runnable if it doesn't
                     map to a known type.
                     """
                     lctest = test.lower()
                     testcls = Test
                     for ext, cls in self.TESTTYPES:
                         if lctest.endswith(ext):
                             testcls = cls
                             break
                     refpath = os.path.join(self._testdir, test)
                     tmpdir = os.path.join(self._hgtmp, b'child%d' % count)
                     t = testcls(refpath, tmpdir,
                                 keeptmpdir=self.options.keep_tmpdir,
                                 debug=self.options.debug,
                                 timeout=self.options.timeout,
                                 startport=self._getport(count),
                                 extraconfigopts=self.options.extra_config_opt,
                                 py3kwarnings=self.options.py3k_warnings,
                                 shell=self.options.shell,
                                 hgcommand=self._hgcommand,
                                 usechg=bool(self.options.with_chg or self.options.chg),
                                 useipv6=useipv6)
                     t.should_reload = True
                     return t
                 def _cleanup(self):
                     """Clean up state from this test invocation."""
                     if self.options.keep_tmpdir:
                         return
                     vlog("# Cleaning up HGTMP", self._hgtmp)
                     shutil.rmtree(self._hgtmp, True)
                     for f in self._createdfiles:
                         try:
                             os.remove(f)
                         except OSError:
                             pass
                 def _usecorrectpython(self):
                     """Configure the environment to use the appropriate Python in tests."""
                     # Tests must use the same interpreter as us or bad things will happen.
                     pyexename = sys.platform == 'win32' and b'python.exe' or b'python'
                     if getattr(os, 'symlink', None):
                         vlog("# Making python executable in test path a symlink to '%s'" %
                              sys.executable)
                         mypython = os.path.join(self._tmpbindir, pyexename)
                         try:
                             if os.readlink(mypython) == sys.executable:
                                 return
                             os.unlink(mypython)
                         except OSError as err:
                             if err.errno != errno.ENOENT:
                                 raise
                         if self._findprogram(pyexename) != sys.executable:
                             try:
                                 os.symlink(sys.executable, mypython)
                                 self._createdfiles.append(mypython)
                             except OSError as err:
                                 # child processes may race, which is harmless
                                 if err.errno != errno.EEXIST:
                                     raise
                     else:
                         exedir, exename = os.path.split(sys.executable)
                         vlog("# Modifying search path to find %s as %s in '%s'" %
                              (exename, pyexename, exedir))
                         path = os.environ['PATH'].split(os.pathsep)
                         while exedir in path:
                             path.remove(exedir)
                         os.environ['PATH'] = os.pathsep.join([exedir] + path)
                         if not self._findprogram(pyexename):
                             print("WARNING: Cannot find %s in search path" % pyexename)
                 def _installhg(self):
                     """Install hg into the test environment.
                     This will also configure hg with the appropriate testing settings.
                     """
                     vlog("# Performing temporary installation of HG")
                     installerrs = os.path.join(self._hgtmp, b"install.err")
                     compiler = ''
                     if self.options.compiler:
                         compiler = '--compiler ' + self.options.compiler
                     if self.options.pure:
                         pure = b"--pure"
                     else:
                         pure = b""
                     # Run installer in hg root
                     script = os.path.realpath(sys.argv[0])
                     exe = sys.executable
                     if PYTHON3:
                         compiler = _bytespath(compiler)
                         script = _bytespath(script)
                         exe = _bytespath(exe)
                     hgroot = os.path.dirname(os.path.dirname(script))
                     self._hgroot = hgroot
                     os.chdir(hgroot)
                     nohome = b'--home=""'
                     if os.name == 'nt':
                         # The --home="" trick works only on OS where os.sep == '/'
                         # because of a distutils convert_path() fast-path. Avoid it at
                         # least on Windows for now, deal with .pydistutils.cfg bugs
                         # when they happen.
                         nohome = b''
                     cmd = (b'%(exe)s setup.py %(pure)s clean --all'
                            b' build %(compiler)s --build-base="%(base)s"'
                            b' install --force --prefix="%(prefix)s"'
                            b' --install-lib="%(libdir)s"'
                            b' --install-scripts="%(bindir)s" %(nohome)s >%(logfile)s 2>&1'
                            % {b'exe': exe, b'pure': pure,
                               b'compiler': compiler,
                               b'base': os.path.join(self._hgtmp, b"build"),
                               b'prefix': self._installdir, b'libdir': self._pythondir,
                               b'bindir': self._bindir,
                               b'nohome': nohome, b'logfile': installerrs})
                     # setuptools requires install directories to exist.
                     def makedirs(p):
                         try:
                             os.makedirs(p)
                         except OSError as e:
                             if e.errno != errno.EEXIST:
                                 raise
                     makedirs(self._pythondir)
                     makedirs(self._bindir)
                     vlog("# Running", cmd)
                     if os.system(cmd) == 0:
                         if not self.options.verbose:
                             try:
                                 os.remove(installerrs)
                             except OSError as e:
                                 if e.errno != errno.ENOENT:
                                     raise
                     else:
                         f = open(installerrs, 'rb')
                         for line in f:
                             if PYTHON3:
                                 sys.stdout.buffer.write(line)
                             else:
                                 sys.stdout.write(line)
                         f.close()
                         sys.exit(1)
                     os.chdir(self._testdir)
                     self._usecorrectpython()
                     if self.options.py3k_warnings and not self.options.anycoverage:
                         vlog("# Updating hg command to enable Py3k Warnings switch")
                         f = open(os.path.join(self._bindir, 'hg'), 'rb')
                         lines = [line.rstrip() for line in f]
                         lines[0] += ' -3'
                         f.close()
                         f = open(os.path.join(self._bindir, 'hg'), 'wb')
                         for line in lines:
                             f.write(line + '\n')
                         f.close()
                     hgbat = os.path.join(self._bindir, b'hg.bat')
                     if os.path.isfile(hgbat):
                         # hg.bat expects to be put in bin/scripts while run-tests.py
                         # installation layout put it in bin/ directly. Fix it
                         f = open(hgbat, 'rb')
                         data = f.read()
                         f.close()
                         if b'"%~dp0..\python" "%~dp0hg" %*' in data:
                             data = data.replace(b'"%~dp0..\python" "%~dp0hg" %*',
                                                 b'"%~dp0python" "%~dp0hg" %*')
                             f = open(hgbat, 'wb')
                             f.write(data)
                             f.close()
                         else:
                             print('WARNING: cannot fix hg.bat reference to python.exe')
                     if self.options.anycoverage:
                         custom = os.path.join(self._testdir, 'sitecustomize.py')
                         target = os.path.join(self._pythondir, 'sitecustomize.py')
                         vlog('# Installing coverage trigger to %s' % target)
                         shutil.copyfile(custom, target)
                         rc = os.path.join(self._testdir, '.coveragerc')
                         vlog('# Installing coverage rc to %s' % rc)
                         os.environ['COVERAGE_PROCESS_START'] = rc
                         covdir = os.path.join(self._installdir, '..', 'coverage')
                         try:
                             os.mkdir(covdir)
                         except OSError as e:
                             if e.errno != errno.EEXIST:
                                 raise
                         os.environ['COVERAGE_DIR'] = covdir
                 def _checkhglib(self, verb):
                     """Ensure that the 'mercurial' package imported by python is
                     the one we expect it to be.  If not, print a warning to stderr."""
                     if ((self._bindir == self._pythondir) and
                         (self._bindir != self._tmpbindir)):
                         # The pythondir has been inferred from --with-hg flag.
                         # We cannot expect anything sensible here.
                         return
                     expecthg = os.path.join(self._pythondir, b'mercurial')
                     actualhg = self._gethgpath()
                     if os.path.abspath(actualhg) != os.path.abspath(expecthg):
                         sys.stderr.write('warning: %s with unexpected mercurial lib: %s\n'
                                          '         (expected %s)\n'
                                          % (verb, actualhg, expecthg))
                 def _gethgpath(self):
                     """Return the path to the mercurial package that is actually found by
                     the current Python interpreter."""
                     if self._hgpath is not None:
                         return self._hgpath
                     cmd = b'%s -c "import mercurial; print (mercurial.__path__[0])"'
                     cmd = cmd % PYTHON
                     if PYTHON3:
                         cmd = _strpath(cmd)
                     pipe = os.popen(cmd)
                     try:
                         self._hgpath = _bytespath(pipe.read().strip())
                     finally:
                         pipe.close()
                     return self._hgpath
                 def _installchg(self):
                     """Install chg into the test environment"""
                     vlog('# Performing temporary installation of CHG')
                     assert os.path.dirname(self._bindir) == self._installdir
                     assert self._hgroot, 'must be called after _installhg()'
                     cmd = (b'"%(make)s" clean install PREFIX="%(prefix)s"'
                            % {b'make': 'make',  # TODO: switch by option or environment?
                               b'prefix': self._installdir})
                     cwd = os.path.join(self._hgroot, b'contrib', b'chg')
                     vlog("# Running", cmd)
                     proc = subprocess.Popen(cmd, shell=True, cwd=cwd,
                                             stdin=subprocess.PIPE, stdout=subprocess.PIPE,
                                             stderr=subprocess.STDOUT)
                     out, _err = proc.communicate()
                     if proc.returncode != 0:
                         if PYTHON3:
                             sys.stdout.buffer.write(out)
                         else:
                             sys.stdout.write(out)
                         sys.exit(1)
                 def _outputcoverage(self):
                     """Produce code coverage output."""
                     import coverage
                     coverage = coverage.coverage
                     vlog('# Producing coverage report')
                     # chdir is the easiest way to get short, relative paths in the
                     # output.
                     os.chdir(self._hgroot)
                     covdir = os.path.join(self._installdir, '..', 'coverage')
                     cov = coverage(data_file=os.path.join(covdir, 'cov'))
                     # Map install directory paths back to source directory.
                     cov.config.paths['srcdir'] = ['.', self._pythondir]
                     cov.combine()
                     omit = [os.path.join(x, '*') for x in [self._bindir, self._testdir]]
                     cov.report(ignore_errors=True, omit=omit)
                     if self.options.htmlcov:
                         htmldir = os.path.join(self._testdir, 'htmlcov')
                         cov.html_report(directory=htmldir, omit=omit)
                     if self.options.annotate:
                         adir = os.path.join(self._testdir, 'annotated')
                         if not os.path.isdir(adir):
                             os.mkdir(adir)
                         cov.annotate(directory=adir, omit=omit)
                 def _findprogram(self, program):
                     """Search PATH for a executable program"""
                     dpb = _bytespath(os.defpath)
                     sepb = _bytespath(os.pathsep)
                     for p in osenvironb.get(b'PATH', dpb).split(sepb):
                         name = os.path.join(p, program)
                         if os.name == 'nt' or os.access(name, os.X_OK):
                             return name
                     return None
                 def _checktools(self):
                     """Ensure tools required to run tests are present."""
                     for p in self.REQUIREDTOOLS:
                         if os.name == 'nt' and not p.endswith('.exe'):
                             p += '.exe'
                         found = self._findprogram(p)
                         if found:
                             vlog("# Found prerequisite", p, "at", found)
                         else:
                             print("WARNING: Did not find prerequisite tool: %s " %
                                   p.decode("utf-8"))
             if __name__ == '__main__':
                 runner = TestRunner()
                 try:
                     import msvcrt
                     msvcrt.setmode(sys.stdin.fileno(), os.O_BINARY)
                     msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY)
                     msvcrt.setmode(sys.stderr.fileno(), os.O_BINARY)
                 except ImportError:
                     pass
                 sys.exit(runner.run(sys.argv[1:]))