Lines Matching refs:self
55 def __init__(self):
56 self._writers = {}
58 def open_writer(self, test_result):
59 if test_result in self._writers:
61 self._writers[test_result] = _TestStreams(test_result.stdout,
64 def get_writer(self, test_result):
65 if test_result not in self._writers:
66 self.open_writer(test_result)
67 return self._writers[test_result]
69 def close_writer(self, test_result):
70 if test_result in self._writers:
71 writer = self._writers.pop(test_result)
74 def close(self):
75 for writer in self._writers.values():
77 self._writers.clear()
80 def __init__(self, stdout, stderr):
83 self.stdout = open(stdout, 'w')
84 self.stderr = open(stderr, 'w')
86 def close(self):
87 self.stdout.close()
88 self.stderr.close()
98 def __init__(self, schedule, directory):
106 self.directory = directory
107 self.internal_results = result.InternalLibraryResults(schedule,
109 self.test_stream_manager = _TestStreamManager()
110 self._closed = False
112 self.mapping = {
113 log.LibraryStatus.type_id: self.handle_library_status,
115 log.SuiteResult.type_id: self.handle_suite_result,
116 log.TestResult.type_id: self.handle_test_result,
118 log.TestStderr.type_id: self.handle_stderr,
119 log.TestStdout.type_id: self.handle_stdout,
122 def handle(self, record):
123 if not self._closed:
124 self.mapping.get(record.type_id, lambda _:None)(record)
126 def handle_library_status(self, record):
128 self.test_stream_manager.close()
130 def handle_suite_result(self, record):
131 suite_result = self.internal_results.get_suite_result(
135 def handle_test_result(self, record):
136 test_result = self._get_test_result(record)
139 def handle_stderr(self, record):
140 self.test_stream_manager.get_writer(
141 self._get_test_result(record)
144 def handle_stdout(self, record):
145 self.test_stream_manager.get_writer(
146 self._get_test_result(record)
149 def _get_test_result(self, test_record):
150 return self.internal_results.get_test_result(
154 def _save(self):
157 self.internal_results,
158 os.path.join(self.directory, constants.pickle_filename))
160 self.internal_results,
161 os.path.join(self.directory, constants.xml_filename))
163 def close(self):
164 if self._closed:
166 self._closed = True
167 self._save()
169 def unsuccessful(self):
175 for suite_result in self.internal_results:
200 def __init__(self):
201 self.mapping = {
202 log.TestResult.type_id: self.handle_testresult,
203 log.LibraryStatus.type_id: self.handle_library_status,
205 self._timer = helper.Timer()
206 self.results = []
208 def handle_library_status(self, record):
210 self._timer.restart()
212 def handle_testresult(self, record):
216 self.results.append(result)
218 def handle(self, record):
219 self.mapping.get(record.type_id, lambda _:None)(record)
221 def close(self):
222 print(self._display_summary())
224 def _display_summary(self):
230 for result in self.results:
247 self._timer.active_time())
251 color=self.colormap[most_severe_outcome] + self.color.Bold)
261 def __init__(self, verbosity=log.LogLevel.Info, machine_only=False):
262 self.stream = verbosity >= log.LogLevel.Trace
263 self.verbosity = verbosity
264 self.machine_only = machine_only
265 self.mapping = {
266 log.TestResult.type_id: self.handle_testresult,
267 log.SuiteStatus.type_id: self.handle_suitestatus,
268 log.TestStatus.type_id: self.handle_teststatus,
269 log.TestStderr.type_id: self.handle_stderr,
270 log.TestStdout.type_id: self.handle_stdout,
271 log.TestMessage.type_id: self.handle_testmessage,
272 log.LibraryMessage.type_id: self.handle_librarymessage,
275 def _display_outcome(self, name, outcome, reason=None):
276 print(self.color.Bold
289 def handle_teststatus(self, record):
294 def handle_testresult(self, record):
295 self._display_outcome(
299 def handle_suitestatus(self, record):
304 def handle_stderr(self, record):
305 if self.stream:
308 def handle_stdout(self, record):
309 if self.stream:
312 def handle_testmessage(self, record):
313 if self.stream:
314 print(self._colorize(record['message'], record['level']))
316 def handle_librarymessage(self, record):
317 if not self.machine_only or record.data.get('machine_readable', False):
318 print(self._colorize(record['message'], record['level'],
321 def _colorize(self, message, level, bold=False):
323 self.color.Bold if bold else '',
324 self.verbosity_mapping.get(level, ''),
326 self.default)
328 def handle(self, record):
329 if record.data.get('level', self.verbosity) > self.verbosity:
331 self.mapping.get(record.type_id, lambda _:None)(record)
333 def set_verbosity(self, verbosity):
334 self.verbosity = verbosity
338 def __init__(self):
341 def handle(self, record):
344 def close(self):
357 def __init__(self, *subhandlers):
360 self.queue = multiprocessing.Queue()
361 self.queue.cancel_join_thread()
362 self._shutdown = threading.Event()
365 self._handler_lock = threading.Lock()
366 self._subhandlers = subhandlers
368 def add_handler(self, handler):
369 self._handler_lock.acquire()
370 self._subhandlers = (handler, ) + self._subhandlers
371 self._handler_lock.release()
373 def _with_handlers(self, callback):
375 self._handler_lock.acquire()
376 for handler in self._subhandlers:
384 self._handler_lock.release()
389 def async_process(self):
390 self.thread = threading.Thread(target=self.process)
391 self.thread.daemon = True
392 self.thread.start()
394 def process(self):
395 while not self._shutdown.is_set():
397 item = self.queue.get(timeout=0.1)
398 self._handle(item)
406 def _drain(self):
409 item = self.queue.get(block=False)
410 self._handle(item)
418 def _handle(self, record):
419 self._with_handlers(lambda handler: handler.handle(record))
421 def handle(self, record):
422 self.queue.put(record)
424 def _close(self):
425 if hasattr(self, 'thread'):
426 self.thread.join()
427 _wrap(self._drain)
428 self._with_handlers(lambda handler: _wrap(handler.close))
436 self.queue.close()
439 def close(self):
440 if not self._shutdown.is_set():
441 self._shutdown.set()
442 self._close()