def worker(test_queue, done_queue, worker_id, addr, authkey):
"""This is used by concurrent test processes. It takes a test
off of the test_queue, runs it, then puts the Test object
on the done_queue.
"""
if addr is None:
server = None
else:
server = get_client_manager(addr, authkey)
# need a unique profile output file for each worker process
testflo.profile._prof_file = 'profile_%s.out' % worker_id
test_count = 0
for test in iter(test_queue.get, 'STOP'):
try:
test_count += 1
done_queue.put(test.run(server, addr, authkey))
except:
# we generally shouldn't get here, but just in case,
# handle it so that the main process doesn't hang at the
# end when it tries to join all of the concurrent processes.
done_queue.put(test)
# don't save anything unless we actually ran a test
if test_count > 0:
save_coverage()
save_profile()
def get_iter(self, input_iter):
"""Run tests serially."""
for test in input_iter:
result = test.run(self._server, self._addr, self._authkey)
yield result
if self.stop and result.status == 'FAIL':
break
save_coverage()
def get_iter(self, input_iter):
"""Run tests serially."""
for test in input_iter:
result = self.run_testspec(test)
yield result
if self.stop and result.status == "FAIL":
break
save_coverage()
def get_iter(self, input_iter):
"""Run tests serially."""
for tests in input_iter:
stop = False
for test in tests:
if self.pre_announce:
print(" about to run %s" % test.short_name())
result = test.run(self._queue)
yield result
if self.stop:
if (result.status == 'FAIL' and not result.expected_fail) or (
result.status == 'OK' and result.expected_fail):
stop = True
break
if stop:
break
save_coverage()
def get_iter(self, input_iter):
"""Run tests serially."""
for tests in input_iter:
stop = False
for test in tests:
if self.pre_announce:
print(" about to run %s" % test.short_name())
sys.stdout.flush()
result = test.run(self._queue)
yield result
if self.stop:
if (result.status == 'FAIL' and not result.expected_fail
) or (result.status == 'OK' and result.expected_fail):
stop = True
break
if stop:
break
save_coverage()
def worker(runner, test_queue, done_queue, worker_id):
"""This is used by concurrent test processes. It takes a test
off of the test_queue, runs it, then puts the TestResult object
on the done_queue.
"""
# need a unique profile output file for each worker process
testflo.profile._prof_file = "profile_%s.out" % worker_id
test_count = 0
for testspec in iter(test_queue.get, "STOP"):
try:
test_count += 1
done_queue.put(runner.run_testspec(testspec))
except:
# we generally shouldn't get here, but just in case,
# handle it so that the main process doesn't hang at the
# end when it tries to join all of the concurrent processes.
done_queue.put(TestResult(testspec, 0.0, 0.0, "FAIL", traceback.format_exc()))
# don't save anything unless we actually ran a test
if test_count > 0:
save_coverage()
save_profile()
def worker(test_queue, done_queue, subproc_queue, worker_id):
"""This is used by concurrent test processes. It takes a test
off of the test_queue, runs it, then puts the Test object
on the done_queue.
"""
test_count = 0
for tests in iter(test_queue.get, 'STOP'):
done_tests = []
for test in tests:
try:
test_count += 1
done_tests.append(test.run(subproc_queue))
except:
# we generally shouldn't get here, but just in case,
# handle it so that the main process doesn't hang at the
# end when it tries to join all of the concurrent processes.
done_tests.append(test)
done_queue.put(done_tests)
# don't save anything unless we actually ran a test
if test_count > 0:
save_coverage()
def worker(test_queue, done_queue, subproc_queue, worker_id):
"""This is used by concurrent test processes. It takes a test
off of the test_queue, runs it, then puts the Test object
on the done_queue.
"""
test_count = 0
for tests in iter(test_queue.get, 'STOP'):
done_tests = []
for test in tests:
try:
test_count += 1
done_tests.append(test.run(subproc_queue))
except:
# we generally shouldn't get here, but just in case,
# handle it so that the main process doesn't hang at the
# end when it tries to join all of the concurrent processes.
done_tests.append(test)
done_queue.put(done_tests)
# don't save anything unless we actually ran a test
if test_count > 0:
save_coverage()
# test already failed during discovery, probably an
# import failure
yield testspec
else:
yield run_isolated(testspec, self.args)
if __name__ == '__main__':
exitcode = 0
try:
options = _get_parser().parse_args()
runner = TestRunner(options)
for result in runner.get_iter([options.tests[0]]):
break
if result.status != 'OK':
sys.stderr.write(result.err_msg)
exitcode = exit_codes[result.status]
save_coverage()
except:
sys.stderr.write(traceback.format_exc())
exitcode = exit_codes['FAIL']
finally:
sys.stdout.flush()
sys.stderr.flush()
sys.exit(exitcode)
# collect results
results = comm.gather(test, root=0)
if comm.rank == 0:
if not all([isinstance(r, Test) for r in results]):
print("\nNot all results gathered are Test objects. "
"You may have out-of-sync collective MPI calls.\n")
total_mem_usage = sum(r.memory_usage for r in results
if isinstance(r, Test))
test.memory_usage = total_mem_usage
# check for errors and record error message
for r in results:
if test.status != 'FAIL' and r.status in ('SKIP', 'FAIL'):
test.err_msg = r.err_msg
test.status = r.status
if r.status == 'FAIL':
break
save_coverage()
except Exception:
test.err_msg = traceback.format_exc()
test.status = 'FAIL'
finally:
sys.stdout.flush()
sys.stderr.flush()
if comm.rank == 0:
queue.put(test)
