def startTest(self, test):
TestResult.startTest(self, test)
#need to add write and writln method for terminal output
self.logger.debug(
time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time())))
self.logger.debug(self.getDescription(test))
self.logger.debug("START")
def startTest(self, test):
""" Called before execute each method. """
self.start_time = time.time()
TestResult.startTest(self, test)
if self.showAll:
self.stream.write(" " + str(test))
self.stream.write(" ... ")
def startTest(self, test):
"Called before execute each test method."
self.start_time = time.time()
TestResult.startTest(self, test)
if self.showAll:
self.stream.write(' ' + self.getDescription(test))
self.stream.write(" ... ")
def startTest(self, test):
"Called before execute each test method."
self.start_time = time.time()
TestResult.startTest(self, test)
if self.showAll:
self.stream.write(' ' + self.getDescription(test))
self.stream.write(" ... ")
def startTest(self, test):
TestResult.startTest(self, test)
# just one buffer for both stdout and stderr
stdout_redirector.fp = self.outputBuffer
stderr_redirector.fp = self.outputBuffer
self.stdout0 = sys.stdout
self.stderr0 = sys.stderr
sys.stdout = stdout_redirector
sys.stderr = stderr_redirector
def startTest(self, test):
"""
Method called at the start of a test.
@param test Reference to the test object
"""
TestResult.startTest(self, test)
self.parent.write('%s%s\n' % (ResponseUTStartTest,
unicode((unicode(test), test.shortDescription()))))
def startTest(self, test):
"""
Method called at the start of a test.
@param test Reference to the test object
"""
TestResult.startTest(self, test)
self.parent.write('{0}{1}\n'.format(ResponseUTStartTest,
str((str(test), test.shortDescription()))))
def startTest(self, test):
TestResult.startTest(self, test)
# just one buffer for both stdout and stderr
stdout_redirector.fp = self.outputBuffer
stderr_redirector.fp = self.outputBuffer
self.stdout0 = sys.stdout
self.stderr0 = sys.stderr
sys.stdout = stdout_redirector
sys.stderr = stderr_redirector
def startTest(self, test):
"""
Public method called at the start of a test.
@param test Reference to the test object
"""
TestResult.startTest(self, test)
self.parent.write('{0}{1}\n'.format(
ResponseUTStartTest, str((str(test), test.shortDescription()))))
def startTest(self, test):
print(
"\n\n++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n\n"
)
print("Starting test {}".format(test))
print(
"\n\n++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n\n"
)
TestResult.startTest(self, test)
def startTest(self, test):
""" Called before execute each method. """
if self.retry == 0:
self.testRun += 1
self.start_time = time.time()
TestResult.startTest(self, test)
if self.showAll:
self.stream.write(" " + self.getDescription(test))
self.stream.write(" ... ")
def startTest(self, test):
"""
Public method called at the start of a test.
@param test Reference to the test object
"""
TestResult.startTest(self, test)
self.__dbgClient.sendJsonCommand("ResponseUTStartTest", {
"testname": str(test),
"description": test.shortDescription(),
})
def startTest(self, test): # CONSIDER why are there 2 startTests in here?
self._startTime = time.time()
test._extraXML = ''
test._extraAssertions = []
TestResult.startTest(self, test)
self.stream.write('<testcase classname="%s' % test.__class__.__name__ + '" name="%s' % test.id().split('.')[-1] + '"')
desc = test.shortDescription()
if desc:
desc = _cleanHTML(desc)
self.stream.write(' desc="%s"' % desc)
def startTest(self, test):
GeneralLogger().get_logger(True)
GeneralLogger().get_logger().info((self.LANG == 'cn' and "开始测试： {}"
or "Start Test: {}").format(test))
self.result_tmp[str(threading.current_thread().ident)] = {
'result_code': 0,
'testCase_object': test,
'test_output': '',
'image_paths': []
}
self.time[str(threading.current_thread().ident)] = time.clock()
TestResult.startTest(self, test)
def startTest(self, test): # CONSIDER why are there 2 startTests in here?
self._startTime = time.time()
test._extraXML = ''
test._extraAssertions = []
TestResult.startTest(self, test)
self.stream.write('<testcase classname="%s' % test.__class__.__name__ + '" name="%s' % test.id().split('.')[-1] + '"')
desc = (test._testMethodDoc or '').strip()
# desc = test.shortDescription() # CONSIDER why did this fail?
if desc:
desc = _cleanHTML(desc)
desc = desc.replace('\n', ' ')
self.stream.write(' desc="%s"' % desc)
def startTest(self, test):
"""
Called before executing each test method.
"""
self.comm.Barrier()
if isinstance(test, MPITestCase):
test.setComm(self.comm)
self.start_time = MPI.Wtime()
TestResult.startTest(self, test)
if self.showAll:
self.stream.write(' ' + self.getDescription(test))
self.stream.write(" ... ")
def startTest(self, test):
""" Called before execute each method. """
self.start_time = time.time()
''' capture warning message in each of test '''
self.catch_warn = warnings.catch_warnings(record=True)
self.catch_warn_msg = self.catch_warn.__enter__()
self._warning_message = None
TestResult.startTest(self, test)
if self.showAll:
self.stream.write(" " + self.getDescription(test))
self.stream.write(" ... ")
def startTest(self, test):
TestResult.startTest(self, test)
if self.showAll:
self.stream.writeln()
self.stream.writeln()
self.stream.writeln(self.separator1)
methodName = logger._do_hide_error_and_warning_words(get_test_method_name(test))
methodClass = logger._do_hide_error_and_warning_words(_strclass(test.__class__))
self.stream.writeln(_get_centered_string(methodClass, self.sep_len))
self.stream.writeln(_get_centered_string(methodName, self.sep_len))
self.stream.writeln(self.separator1)
def startTest(self, test):
TestResult.startTest(self, test)
methodName = get_test_method_name(test)
methodClass = _strclass(test.__class__)
if methodClass not in self._testsuites:
self._testsuite = self.xml.createElement('testsuite')
self._testsuite.setAttribute('name', '%s' % methodClass)
self._testsuites[methodClass] = self._testsuite
self.xml.documentElement.appendChild(self._testsuite)
else:
self._testsuite = self._testsuites[methodClass]
self._testcase_xml = self.xml.createElement('testcase')
self._testcase_xml.setAttribute('name', '%s' % methodName)
self._startTime = time.time()
def startTest(self, test):
TestResult.startTest(self, test)
logger.setLogOn()
TestController.getInstance().setTestcaseOrder(test)
# need to add write and writln method for terminal output
logger.info("start test".center(20, "*"))
logger.info(self.getDescription(test))
logger.info(
"START: %s" %
(time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time()))) +
" || Current Cycle:" +
str(TestController.getInstance().getCurrentCycle()) +
" || Current Order:" +
str(TestController.getInstance().getCurrentcaseOrder()))
def startTest(self, test):
TestResult.startTest(self, test)
methodName = get_test_method_name(test)
methodClass = _strclass(test.__class__)
if methodClass not in self._testsuites:
self._testsuite = self.xml.createElement('testsuite')
self._testsuite.setAttribute('name', '%s' % methodClass)
self._testsuites[methodClass] = self._testsuite
self.xml.documentElement.appendChild(self._testsuite)
else:
self._testsuite = self._testsuites[methodClass]
self._testcase_xml = self.xml.createElement('testcase')
self._testcase_xml.setAttribute('name', '%s' % methodName)
self._startTime = time.time()
def startTest(self, test):
TestResult.startTest(self, test)
if self.showAll:
self.stream.writeln()
self.stream.writeln()
self.stream.writeln(self.separator1)
methodName = logger._do_hide_error_and_warning_words(get_test_method_name(test))
methodClass = logger._do_hide_error_and_warning_words(_strclass(test.__class__))
self.stream.writeln(_get_centered_string(methodClass, self.sep_len))
self.stream.writeln(_get_centered_string(methodName, self.sep_len))
self.stream.writeln(self.separator1)
def run(self, result: TestResult, debug=False):
name = f"{self._server.protocol:<10} : {self._server.name:<20} server"
server_test = DummyTestForServer(
self._server, f"{name} starting ")
result.startTest(server_test)
try:
with self._server.with_running():
result.addSuccess(server_test)
super().run(result, debug=debug)
server_test = DummyTestForServer(
self._server, f"{name} stopping ")
result.startTest(server_test)
result.addSuccess(server_test)
except Exception as e:
exc_info = sys.exc_info()
result.addError(server_test, exc_info)
def startTest(self, test):
TestResult.startTest(self, test)
# set_trace()
methname = self.get_testMethodName(test)
# if hasattr( test, '_testMethodName'): # python2.5
# methname = getattr( test, '_testMethodName' )
# elif hasattr( test, '_TestCase__testMethodName' ): # python2.4
# methname = getattr( test, '_TestCase__testMethodName' )
methname = self.make_latex_safe( methname)
case_file = sys.modules[type(test).__module__].__file__
base,ext = splitext(case_file)
case_file = "".join( [base, ext.replace('.pyc', '.py')] )
case_name = self.make_latex_safe(type(test).__name__)
self.stream.write(" \\lineiii{%(methname)s} {\\citetitle[%(case_file)s]{%(case_name)s}}" %vars() )
def startTest(self, test):
logging.info((self.LANG == "cn" and "开始测试： {}"
or "Start Test: {}").format(test))
current_id = str(threading.current_thread().ident)
if current_id in self.result_tmp:
self.result_tmp[current_id]["tries"] += 1
else:
self.result_tmp[current_id] = dict(result_code=0,
testCase_object=test,
test_output={},
image_paths={},
tries=0,
retry=True,
style={},
local_delay=self.delay)
self.time[str(threading.current_thread().ident)] = time.time()
TestResult.startTest(self, test)
def startTest(self, test):
logging.info((self.LANG == 'cn' and "开始测试： {}" or "Start Test: {}").format(test))
current_id = str(threading.current_thread().ident)
if current_id in self.result_tmp:
self.result_tmp[current_id]['tries'] += 1
else:
self.result_tmp[current_id] = {
'result_code': 0,
'testCase_object': test,
'test_output': {},
'image_paths': {},
'tries': 0,
'retry': True,
'style': {},
'local_delay': self.delay
}
self.time[str(threading.current_thread().ident)] = time.time()
TestResult.startTest(self, test)
def startTest(self, test):
self.test_start_at = time.time()
self.all_tests[test.id()] = None
self.results_log[test.id()] = [None, None, 0, datetime.now(),
self.testsRun, test.shortDescription() or str(test)]
return TestResult.startTest(self, test)
def startTest(self, test):
TestResult.startTest(self, test)
if self.showAll:
self.stream.write_message(self.getDescription(test))
self.stream.write_message(" ... ")
def startTest(self, test):
TestResult.startTest(self, test)
self._writeToStream("\t%s: " % test.id())
if self._logging:
self._writeToStream("\n")
def startTest(self, test):
"Called when the given test is about to be run. Resets global flags."
self.last_errors.fill(False)
self.last_failed.fill(False)
TestResult.startTest(self, test)
def startTest(self, test):
TestResult.startTest(self, test)
def startTest(self, test):
"Called when the given test is about to be run. Resets global flags."
self.last_errors.fill(False)
self.last_failed.fill(False)
TestResult.startTest(self, test)
from __future__ import print_function
def startTest(self, test):
TestResult.startTest(self, test)
#need to add write and writln method for terminal output
self.logger.debug(time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time())))
self.logger.debug(self.getDescription(test))
self.logger.debug("START")
def startTest(self, test):
TestResult.startTest(self, test)
self.stream.writeln("%%TEST_STARTED%% %s" % self.getDescription(test))
self._start_time = time.time()
def startTest(self, test):
TestResult.startTest(self, test)
def startTest(self, test):
self._startTime = time.time()
TestResult.startTest(self, test)
self.stream.write('<testcase classname="%s' % test.__class__.__name__ + '" name="%s' % test.id().split('.')[-1] + '"')
def startTest(self, test):
"Called when the given test is about to be run"
TestResult.startTest(self, test)
if self.verbose:
self.stream.write(get_description(test))
self.stream.write(' ... ')
def startTest(self, test):
TestResult.startTest(self, test)
self.step.setProgress('tests', self.testsRun)
def startTest(self, test):
UnitTestResult.startTest(self, test)
if self.showAll:
self._errWrite(str(test))
self._errWrite(' ... ')
def startTest(self, test):
"Called when the given test is about to be run"
TestResult.startTest(self, test)
if self.verbose:
self.stream.write(get_description(test))
self.stream.write(' ... ')
def startTest(self, test):
TestResult.startTest(self, test)
for listener in self.listeners:
listener.startTest(test)
def startTest(self, test):
test._subunit_started = True
#instead of calling TestProtocolClient.startTest(self, test),
#which uses test.id(), we follow what vanilla unittest does
self._stream.write("test: %s\n" % self.getDescription(test))
TestResult.startTest(self, test)
def startTest(self, test):
TestResult.startTest(self, test)
self._writeToStream("\t%s: " % test.id())
if self._logging:
self._writeToStream("\n")
def startTest(self, test):
UnitTestResult.startTest(self, test)
if self.showAll:
self._errWrite(str(test))
self._errWrite(' ... ')
def startTest(self, test):
TestResult.startTest(self, test)
self.step.setProgress("tests", self.testsRun)
def startTest(self, test):
TestResult.startTest(self, test)
for listener in self.listeners:
listener.startTest(test)
def startTest(self, test):
TestResult.startTest(self, test)
if not self.iterations:
self.stream.write("%-75s" % self.getDescription(test))
