Source.Python/addons/source-python/Python3/unittest/runner.py at master · srpg/Source.Python · GitHub

Repository navigation

History

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

"""Running tests"""

import sys

import time

import warnings

from . import result

from .signals import registerResult

__unittest = True

class _WritelnDecorator(object):

"""Used to decorate file-like objects with a handy 'writeln' method"""

def __init__(self,stream):

self.stream = stream

def __getattr__(self, attr):

if attr in ('stream', '__getstate__'):

raise AttributeError(attr)

return getattr(self.stream,attr)

def writeln(self, arg=None):

if arg:

self.write(arg)

self.write('\n') # text-mode streams translate to \r\n if needed

class TextTestResult(result.TestResult):

"""A test result class that can print formatted text results to a stream.

Used by TextTestRunner.

"""

separator1 = '=' * 70

separator2 = '-' * 70

def __init__(self, stream, descriptions, verbosity):

super(TextTestResult, self).__init__(stream, descriptions, verbosity)

self.stream = stream

self.showAll = verbosity > 1

self.dots = verbosity == 1

self.descriptions = descriptions

def getDescription(self, test):

doc_first_line = test.shortDescription()

if self.descriptions and doc_first_line:

return '\n'.join((str(test), doc_first_line))

else:

return str(test)

def startTest(self, test):

super(TextTestResult, self).startTest(test)

if self.showAll:

self.stream.write(self.getDescription(test))

self.stream.write(" ... ")

self.stream.flush()

def addSuccess(self, test):

super(TextTestResult, self).addSuccess(test)

if self.showAll:

self.stream.writeln("ok")

elif self.dots:

self.stream.write('.')

self.stream.flush()

def addError(self, test, err):

super(TextTestResult, self).addError(test, err)

if self.showAll:

self.stream.writeln("ERROR")

elif self.dots:

self.stream.write('E')

self.stream.flush()

def addFailure(self, test, err):

super(TextTestResult, self).addFailure(test, err)

if self.showAll:

self.stream.writeln("FAIL")

elif self.dots:

self.stream.write('F')

self.stream.flush()

def addSkip(self, test, reason):

super(TextTestResult, self).addSkip(test, reason)

if self.showAll:

self.stream.writeln("skipped {0!r}".format(reason))

elif self.dots:

self.stream.write("s")

self.stream.flush()

def addExpectedFailure(self, test, err):

super(TextTestResult, self).addExpectedFailure(test, err)

if self.showAll:

self.stream.writeln("expected failure")

elif self.dots:

self.stream.write("x")

self.stream.flush()

def addUnexpectedSuccess(self, test):

super(TextTestResult, self).addUnexpectedSuccess(test)

if self.showAll:

self.stream.writeln("unexpected success")

elif self.dots:

self.stream.write("u")

self.stream.flush()

def printErrors(self):

if self.dots or self.showAll:

self.stream.writeln()

self.printErrorList('ERROR', self.errors)

self.printErrorList('FAIL', self.failures)

def printErrorList(self, flavour, errors):

for test, err in errors:

self.stream.writeln(self.separator1)

self.stream.writeln("%s: %s" % (flavour,self.getDescription(test)))

self.stream.writeln(self.separator2)

self.stream.writeln("%s" % err)

class TextTestRunner(object):

"""A test runner class that displays results in textual form.

It prints out the names of tests as they are run, errors as they

occur, and a summary of the results at the end of the test run.

"""

resultclass = TextTestResult

def __init__(self, stream=None, descriptions=True, verbosity=1,

failfast=False, buffer=False, resultclass=None, warnings=None,

*, tb_locals=False):

"""Construct a TextTestRunner.

Subclasses should accept **kwargs to ensure compatibility as the

interface changes.

"""

if stream is None:

stream = sys.stderr

self.stream = _WritelnDecorator(stream)

self.descriptions = descriptions

self.verbosity = verbosity

self.failfast = failfast

self.buffer = buffer

self.tb_locals = tb_locals

self.warnings = warnings

if resultclass is not None:

self.resultclass = resultclass

def _makeResult(self):

return self.resultclass(self.stream, self.descriptions, self.verbosity)

def run(self, test):

"Run the given test case or test suite."

result = self._makeResult()

registerResult(result)

result.failfast = self.failfast

result.buffer = self.buffer

result.tb_locals = self.tb_locals

with warnings.catch_warnings():

if self.warnings:

# if self.warnings is set, use it to filter all the warnings

warnings.simplefilter(self.warnings)

# if the filter is 'default' or 'always', special-case the

# warnings from the deprecated unittest methods to show them

# no more than once per module, because they can be fairly

# noisy. The -Wd and -Wa flags can be used to bypass this

# only when self.warnings is None.

if self.warnings in ['default', 'always']:

warnings.filterwarnings('module',

category=DeprecationWarning,

message=r'Please use assert\w+ instead.')

startTime = time.time()

startTestRun = getattr(result, 'startTestRun', None)

if startTestRun is not None:

startTestRun()

try:

test(result)

finally:

stopTestRun = getattr(result, 'stopTestRun', None)

if stopTestRun is not None:

stopTestRun()

stopTime = time.time()

timeTaken = stopTime - startTime

result.printErrors()

if hasattr(result, 'separator2'):

self.stream.writeln(result.separator2)

run = result.testsRun

self.stream.writeln("Ran %d test%s in %.3fs" %

(run, run != 1 and "s" or "", timeTaken))

self.stream.writeln()

expectedFails = unexpectedSuccesses = skipped = 0

try:

results = map(len, (result.expectedFailures,

result.unexpectedSuccesses,

result.skipped))

except AttributeError:

pass

else:

expectedFails, unexpectedSuccesses, skipped = results

infos = []

if not result.wasSuccessful():

self.stream.write("FAILED")

failed, errored = len(result.failures), len(result.errors)

if failed:

infos.append("failures=%d" % failed)

if errored:

infos.append("errors=%d" % errored)

else:

self.stream.write("OK")

if skipped:

infos.append("skipped=%d" % skipped)

if expectedFails:

infos.append("expected failures=%d" % expectedFails)

if unexpectedSuccesses:

infos.append("unexpected successes=%d" % unexpectedSuccesses)

if infos:

self.stream.writeln(" (%s)" % (", ".join(infos),))

else:

self.stream.write("\n")

return result

Source.Python/addons/source-python/Python3/unittest/runner.py at master · srpg/Source.Python · GitHub

Repository navigation

Expand file tree

Breadcrumbs

runner.py

Latest commit

History

Breadcrumbs

runner.py

File metadata and controls