Changeset 112019 in webkit
- Timestamp:
- Mar 24, 2012 8:50:49 PM (12 years ago)
- Location:
- trunk/Tools
- Files:
-
- 12 edited
Legend:
- Unmodified
- Added
- Removed
-
trunk/Tools/ChangeLog
r112017 r112019 1 2012-03-24 Sheriff Bot <webkit.review.bot@gmail.com> 2 3 Unreviewed, rolling out r112014. 4 http://trac.webkit.org/changeset/112014 5 https://bugs.webkit.org/show_bug.cgi?id=82138 6 7 Broke SnowLeopard, Chromium and GTK+ bots (Requested by kov on 8 #webkit). 9 10 * Scripts/webkitpy/layout_tests/controllers/manager_unittest.py: 11 (ManagerTest.test_http_locking): 12 * Scripts/webkitpy/layout_tests/controllers/manager_worker_broker.py: 13 (AbstractWorker.run): 14 * Scripts/webkitpy/layout_tests/controllers/worker.py: 15 (Worker.__init__): 16 (Worker.safe_init): 17 (Worker.run): 18 (Worker.cleanup): 19 * Scripts/webkitpy/layout_tests/controllers/worker_unittest.py: 20 (WorkerTest.test_default_platform_in_worker): 21 * Scripts/webkitpy/layout_tests/run_webkit_tests.py: 22 (run): 23 (main): 24 * Scripts/webkitpy/layout_tests/views/metered_stream.py: 25 (MeteredStream): 26 (MeteredStream.is): 27 (MeteredStream.__init__): 28 (MeteredStream.write): 29 (MeteredStream.update): 30 (MeteredStream._overwrite): 31 (MeteredStream._reset): 32 * Scripts/webkitpy/layout_tests/views/metered_stream_unittest.py: 33 (TestMeteredStream): 34 (TestMeteredStream.test_regular): 35 * Scripts/webkitpy/layout_tests/views/printing.py: 36 (_configure_logging): 37 (_restore_logging): 38 (Printer.__init__): 39 (Printer.cleanup): 40 (Printer.print_progress): 41 (Printer.print_update): 42 (Printer._write): 43 (Printer): 44 (Printer._update): 45 * Scripts/webkitpy/layout_tests/views/printing_unittest.py: 46 (TestUtilityFunctions.assertEmpty): 47 (TestUtilityFunctions): 48 (TestUtilityFunctions.assertNotEmpty): 49 (TestUtilityFunctions.assertWritten): 50 (TestUtilityFunctions.test_configure_logging): 51 (Testprinter.get_printer): 52 (Testprinter.test_print_progress): 53 (Testprinter.test_print_progress.mock_time): 54 * Scripts/webkitpy/performance_tests/perftestsrunner.py: 55 (PerfTestsRunner.__init__): 56 * Scripts/webkitpy/performance_tests/perftestsrunner_unittest.py: 57 (test_run_test_pause_before_testing): 58 1 59 2012-03-24 Kevin Ollivier <kevino@theolliviers.com> 2 60 -
trunk/Tools/Scripts/webkitpy/layout_tests/controllers/manager_unittest.py
r112014 r112019 215 215 port = host.port_factory.get(port_name=options.platform, options=options) 216 216 run_webkit_tests._set_up_derived_options(port, options) 217 printer = printing.Printer(port, options, StringIO.StringIO(), StringIO.StringIO() )217 printer = printing.Printer(port, options, StringIO.StringIO(), StringIO.StringIO(), configure_logging=False) 218 218 manager = LockCheckingManager(port, options, printer) 219 219 manager.collect_tests(args) -
trunk/Tools/Scripts/webkitpy/layout_tests/controllers/manager_worker_broker.py
r112014 r112019 275 275 remaining initialization and then calls broker_connection.run_message_loop().""" 276 276 exception_msg = "" 277 _log.debug("%s starting" % self._name) 277 278 278 279 try: -
trunk/Tools/Scripts/webkitpy/layout_tests/controllers/worker.py
r112014 r112019 39 39 from webkitpy.layout_tests.models import test_expectations 40 40 from webkitpy.layout_tests.models import test_results 41 from webkitpy.layout_tests.views import metered_stream41 from webkitpy.layout_tests.views import printing 42 42 43 43 … … 66 66 self._tests_run_file = None 67 67 self._tests_run_filename = None 68 self._ meter = None68 self._printer = None 69 69 70 70 def __del__(self): … … 83 83 self._tests_run_file = self._filesystem.open_text_file_for_writing(tests_run_filename) 84 84 85 def _set_up_logging(self):86 # The unix multiprocessing implementation clones the MeteredStream log handler87 # into the child process, so we need to remove it before we can88 # add a new one to get the correct pid logged.89 root_logger = logging.getLogger()90 handler_to_remove = None91 for h in root_logger.handlers:92 if h.name == metered_stream.LOG_HANDLER_NAME:93 handler_to_remove = h94 break95 if handler_to_remove:96 root_logger.removeHandler(handler_to_remove)97 98 # FIXME: This won't work if the calling process is logging99 # somewhere other than sys.stderr, but I'm not sure100 # if this will be an issue in practice. Also, it would be101 # nice if we trapped all of the messages for a given test102 # and sent them back in finished_test() rather than logging103 # them to stderr.104 if not root_logger.handlers:105 options = self._options106 root_logger.setLevel(logging.DEBUG if options.verbose else logging.INFO)107 self._meter = metered_stream.MeteredStream(sys.stderr, options.verbose, logger=root_logger)108 109 def _set_up_host_and_port(self):110 options = self._options111 if options.platform and 'test' in options.platform:112 # It is lame to import mocks into real code, but this allows us to use the test port in multi-process tests as well.113 from webkitpy.common.host_mock import MockHost114 host = MockHost()115 else:116 host = Host()117 self._port = host.port_factory.get(options.platform, options)118 119 85 def set_inline_arguments(self, port): 120 86 self._port = port … … 122 88 def run(self): 123 89 if not self._port: 124 # We are running in a child process and need to initialize things. 125 self._set_up_logging() 126 self._set_up_host_and_port() 90 # We are running in a child process and need to create a new Host. 91 if self._options.platform and 'test' in self._options.platform: 92 # It is lame to import mocks into real code, but this allows us to use the test port in multi-process tests as well. 93 from webkitpy.common.host_mock import MockHost 94 host = MockHost() 95 else: 96 host = Host() 97 98 options = self._options 99 self._port = host.port_factory.get(options.platform, options) 100 101 # The unix multiprocessing implementation clones the 102 # log handler configuration into the child processes, 103 # but the win implementation doesn't. 104 configure_logging = (sys.platform == 'win32') 105 106 # FIXME: This won't work if the calling process is logging 107 # somewhere other than sys.stderr and sys.stdout, but I'm not sure 108 # if this will be an issue in practice. 109 self._printer = printing.Printer(self._port, options, sys.stderr, sys.stdout, configure_logging) 127 110 128 111 self.safe_init() 112 129 113 try: 130 114 _log.debug("%s starting" % self._name) 131 115 super(Worker, self).run() 132 116 finally: 133 self.kill_driver()134 117 self._worker_connection.post_message('done') 118 self.cleanup() 135 119 _log.debug("%s exiting" % self._name) 136 self.cleanup()137 120 138 121 def handle_test_list(self, src, list_name, test_list): … … 171 154 self._tests_run_file.close() 172 155 self._tests_run_file = None 173 if self._ meter:174 self._ meter.cleanup()175 self._ meter = None156 if self._printer: 157 self._printer.cleanup() 158 self._printer = None 176 159 177 160 def timeout(self, test_input): -
trunk/Tools/Scripts/webkitpy/layout_tests/controllers/worker_unittest.py
r112014 r112019 47 47 worker_connection = FakeConnection() 48 48 worker = Worker(worker_connection, WorkerArguments(1, '/tmp', MockOptions(platform=None, print_options=None, verbose=False, batch_size=0))) 49 worker._set_up_host_and_port() 49 worker._done = True 50 worker.run() 50 51 self.assertNotEquals(worker._port, None) 51 52 -
trunk/Tools/Scripts/webkitpy/layout_tests/run_webkit_tests.py
r112014 r112019 86 86 warnings = _set_up_derived_options(port, options) 87 87 88 printer = printing.Printer(port, options, regular_output, buildbot_output, logger=logging.getLogger())88 printer = printing.Printer(port, options, regular_output, buildbot_output, configure_logging=True) 89 89 90 90 for warning in warnings: … … 480 480 host._initialize_scm() 481 481 port = host.port_factory.get(options.platform, options) 482 logging.getLogger().setLevel(logging.DEBUG if options.verbose else logging.INFO)483 482 return run(port, options, args) 484 483 -
trunk/Tools/Scripts/webkitpy/layout_tests/views/metered_stream.py
r112014 r112019 1 1 #!/usr/bin/env python 2 # Copyright (C) 2010 , 2012Google Inc. All rights reserved.2 # Copyright (C) 2010 Google Inc. All rights reserved. 3 3 # 4 4 # Redistribution and use in source and binary forms, with or without … … 28 28 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29 29 30 import logging 31 import os 32 import sys 33 import time 30 """ 31 Package that implements a stream wrapper that has 'meters' as well as 32 regular output. A 'meter' is a single line of text that can be erased 33 and rewritten repeatedly, without producing multiple lines of output. It 34 can be used to produce effects like progress bars. 35 36 This package should only be called by the printing module in the layout_tests 37 package. 38 """ 34 39 35 40 36 LOG_HANDLER_NAME = 'MeteredStreamLogHandler' 41 class MeteredStream: 42 """This class is a wrapper around a stream that allows you to implement 43 meters (progress bars, etc.). 37 44 45 It can be used directly as a stream, by calling write(), but also provides 46 a method called update() that will overwite prior updates(). 47 """ 38 48 39 class MeteredStream(object): 40 """ 41 This class implements a stream wrapper that has 'meters' as well as 42 regular output. A 'meter' is a single line of text that can be erased 43 and rewritten repeatedly, without producing multiple lines of output. It 44 can be used to produce effects like progress bars. 45 """ 49 def __init__(self, stream): 50 """ 51 Args: 52 stream: output stream to write to 53 """ 54 self._stream = stream 55 self._dirty = False 56 self._last_update = "" 46 57 47 @staticmethod 48 def _erasure(txt): 49 num_chars = len(txt) 50 return '\b' * num_chars + ' ' * num_chars + '\b' * num_chars 58 def write(self, txt): 59 """Write to the stream, overwriting and resetting the meter.""" 51 60 52 @staticmethod 53 def _ensure_newline(txt): 54 return txt if txt.endswith('\n') else txt + '\n' 61 # This routine is called by the logging infrastructure, and 62 # must not call back into logging. It is not a public function. 63 self._overwrite(txt) 64 self._reset() 55 65 56 def __init__(self, stream=None, verbose=False, logger=None, time_fn=None, pid=None): 57 self._stream = stream or sys.stderr 58 self._verbose = verbose 59 self._time_fn = time_fn or time.time 60 self._pid = pid or os.getpid() 66 def update(self, txt): 67 """Write a message that will be overwritten by subsequent update() or write() calls.""" 68 self._overwrite(txt) 61 69 62 self._isatty = self._stream.isatty() 63 self._erasing = self._isatty and not verbose 64 self._last_partial_line = '' 65 self._last_write_time = 0.0 66 self._throttle_delay_in_secs = 0.066 if self._erasing else 10.0 70 def _overwrite(self, txt): 71 # Print the necessary number of backspaces to erase the previous 72 # message. 73 if len(self._last_update): 74 self._stream.write("\b" * len(self._last_update) + 75 " " * len(self._last_update) + 76 "\b" * len(self._last_update)) 77 self._stream.write(txt) 78 last_newline = txt.rfind("\n") 79 self._last_update = txt[(last_newline + 1):] 80 self._dirty = True 67 81 68 self._logger = logger 69 self._log_handler = None 70 if self._logger: 71 log_level = logging.DEBUG if verbose else logging.INFO 72 self._log_handler = _LogHandler(self) 73 self._log_handler.setLevel(log_level) 74 self._logger.addHandler(self._log_handler) 75 76 def __del__(self): 77 self.cleanup() 78 79 def cleanup(self): 80 if self._logger: 81 self._logger.removeHandler(self._log_handler) 82 self._log_handler = None 83 84 def write_throttled_update(self, txt): 85 now = self._time_fn() 86 if now - self._last_write_time >= self._throttle_delay_in_secs: 87 self.write_update(txt, now) 88 89 def write_update(self, txt, now=None): 90 self.write(txt, now) 91 if self._erasing: 92 self._last_partial_line = txt[txt.rfind('\n') + 1:] 93 94 def write(self, txt, now=None): 95 now = now or self._time_fn() 96 self._last_write_time = now 97 if self._last_partial_line: 98 self._erase_last_partial_line() 99 if self._verbose: 100 now_tuple = time.localtime(now) 101 msg = '%02d:%02d:%02d.%03d %d %s' % (now_tuple.tm_hour, now_tuple.tm_min, now_tuple.tm_sec, int((now * 1000) % 1000), self._pid, self._ensure_newline(txt)) 102 elif self._isatty: 103 msg = txt 104 else: 105 msg = self._ensure_newline(txt) 106 107 self._stream.write(msg) 108 109 def writeln(self, txt, now=None): 110 self.write(self._ensure_newline(txt), now) 111 112 def _erase_last_partial_line(self): 113 num_chars = len(self._last_partial_line) 114 self._stream.write(self._erasure(self._last_partial_line)) 115 self._last_partial_line = '' 116 117 118 class _LogHandler(logging.Handler): 119 def __init__(self, meter): 120 logging.Handler.__init__(self) 121 self._meter = meter 122 self._name = LOG_HANDLER_NAME 123 124 def emit(self, record): 125 self._meter.writeln(record.msg, record.created) 82 def _reset(self): 83 self._dirty = False 84 self._last_update = '' -
trunk/Tools/Scripts/webkitpy/layout_tests/views/metered_stream_unittest.py
r112014 r112019 1 1 #!/usr/bin/python 2 # Copyright (C) 2010 , 2012Google Inc. All rights reserved.2 # Copyright (C) 2010 Google Inc. All rights reserved. 3 3 # 4 4 # Redistribution and use in source and binary forms, with or without … … 28 28 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29 29 30 import logging31 import re32 30 import StringIO 33 31 import unittest … … 36 34 37 35 38 class RegularTest(unittest.TestCase): 39 verbose = False 40 isatty = False 36 class TestMeteredStream(unittest.TestCase): 37 def test_regular(self): 38 a = StringIO.StringIO() 39 m = MeteredStream(a) 40 self.assertFalse(a.getvalue()) 41 41 42 def setUp(self):43 self.stream = StringIO.StringIO()44 self.buflist = self.stream.buflist45 self. stream.isatty = lambda: self.isatty42 # basic test 43 m.write("foo") 44 exp = ['foo'] 45 self.assertEquals(a.buflist, exp) 46 46 47 # configure a logger to test that log calls do normally get included.48 self.logger = logging.getLogger(__name__)49 self.logger.setLevel(logging.DEBUG)50 self. logger.propagate = False47 # now check that a second write() does not overwrite the first. 48 m.write("bar") 49 exp.append('bar') 50 self.assertEquals(a.buflist, exp) 51 51 52 # add a dummy time counter for a default behavior. 53 self.times = range(10) 52 m.update("batter") 53 exp.append('batter') 54 self.assertEquals(a.buflist, exp) 54 55 55 self.meter = MeteredStream(self.stream, self.verbose, self.logger, self.time_fn, 8675) 56 # The next update() should overwrite the laste update() but not the 57 # other text. Note that the cursor is effectively positioned at the 58 # end of 'foo', even though we had to erase three more characters. 59 m.update("foo") 60 exp.append('\b\b\b\b\b\b \b\b\b\b\b\b') 61 exp.append('foo') 62 self.assertEquals(a.buflist, exp) 56 63 57 def tearDown(self): 58 if self.meter: 59 self.meter.cleanup() 60 self.meter = None 64 # now check that a write() does overwrite the update 65 m.write("foo") 66 exp.append('\b\b\b \b\b\b') 67 exp.append('foo') 68 self.assertEquals(a.buflist, exp) 61 69 62 def time_fn(self): 63 return self.times.pop(0) 70 # Now test that we only back up to the most recent newline. 64 71 65 def test_logging_not_included(self): 66 # This tests that if we don't hand a logger to the MeteredStream, 67 # nothing is logged. 68 logging_stream = StringIO.StringIO() 69 handler = logging.StreamHandler(logging_stream) 70 root_logger = logging.getLogger() 71 orig_level = root_logger.level 72 root_logger.addHandler(handler) 73 root_logger.setLevel(logging.DEBUG) 74 try: 75 self.meter = MeteredStream(self.stream, self.verbose, None, self.time_fn, 8675) 76 self.meter.write_throttled_update('foo') 77 self.meter.write_update('bar') 78 self.meter.write('baz') 79 self.assertEquals(logging_stream.buflist, []) 80 finally: 81 root_logger.removeHandler(handler) 82 root_logger.setLevel(orig_level) 83 84 def _basic(self, times): 85 self.times = times 86 self.meter.write_update('foo') 87 self.meter.write_update('bar') 88 self.meter.write_throttled_update('baz') 89 self.meter.write_throttled_update('baz 2') 90 self.meter.writeln('done') 91 self.assertEquals(self.times, []) 92 return self.buflist 93 94 def test_basic(self): 95 buflist = self._basic([0, 1, 2, 13, 14]) 96 self.assertEquals(buflist, ['foo\n', 'bar\n', 'baz 2\n', 'done\n']) 97 98 def _log_after_update(self): 99 self.meter.write_update('foo') 100 self.logger.info('bar') 101 return self.buflist 102 103 def test_log_after_update(self): 104 buflist = self._log_after_update() 105 self.assertEquals(buflist, ['foo\n', 'bar\n']) 106 107 108 class TtyTest(RegularTest): 109 verbose = False 110 isatty = True 111 112 def test_basic(self): 113 buflist = self._basic([0, 1, 1.05, 1.1, 2]) 114 self.assertEquals(buflist, ['foo', 115 MeteredStream._erasure('foo'), 'bar', 116 MeteredStream._erasure('bar'), 'baz 2', 117 MeteredStream._erasure('baz 2'), 'done\n']) 118 119 def test_log_after_update(self): 120 buflist = self._log_after_update() 121 self.assertEquals(buflist, ['foo', 122 MeteredStream._erasure('foo'), 'bar\n']) 123 124 125 class VerboseTest(RegularTest): 126 isatty = False 127 verbose = True 128 129 def test_basic(self): 130 buflist = self._basic([0, 1, 2.1, 13, 14.1234]) 131 self.assertEquals(buflist, ['16:00:00.000 8675 foo\n', '16:00:01.000 8675 bar\n', '16:00:13.000 8675 baz 2\n', '16:00:14.123 8675 done\n']) 132 133 def test_log_after_update(self): 134 buflist = self._log_after_update() 135 self.assertEquals(buflist[0], '16:00:00.000 8675 foo\n') 136 137 # The second argument should have a real timestamp and pid, so we just check the format. 138 self.assertEquals(len(buflist), 2) 139 self.assertTrue(re.match('\d\d:\d\d:\d\d.\d\d\d \d+ bar\n', buflist[1])) 72 # Note also that we do not back up to erase the most recent write(), 73 # i.e., write()s do not get erased. 74 a = StringIO.StringIO() 75 m = MeteredStream(a) 76 m.update("foo\nbar") 77 m.update("baz") 78 self.assertEquals(a.buflist, ['foo\nbar', '\b\b\b \b\b\b', 'baz']) 140 79 141 80 -
trunk/Tools/Scripts/webkitpy/layout_tests/views/printing.py
r112014 r112019 1 1 #!/usr/bin/env python 2 # Copyright (C) 2010 , 2012Google Inc. All rights reserved.2 # Copyright (C) 2010 Google Inc. All rights reserved. 3 3 # 4 4 # Redistribution and use in source and binary forms, with or without … … 30 30 """Package that handles non-debug, non-file output for run-webkit-tests.""" 31 31 32 import logging 32 33 import optparse 34 import time 33 35 34 36 from webkitpy.common.net import resultsjsonparser 37 from webkitpy.layout_tests.views.metered_stream import MeteredStream 35 38 from webkitpy.layout_tests.models.test_expectations import TestExpectations 36 from webkitpy.layout_tests.views.metered_stream import MeteredStream 39 40 41 _log = logging.getLogger(__name__) 42 37 43 38 44 NUM_SLOW_TESTS_TO_LOG = 10 45 FAST_UPDATES_SECONDS = 0.03 46 SLOW_UPDATES_SECONDS = 10.0 39 47 40 48 PRINT_DEFAULT = "misc,one-line-progress,one-line-summary,unexpected,unexpected-results,updates" … … 147 155 148 156 157 def _configure_logging(stream, verbose): 158 log_fmt = '%(message)s' 159 log_datefmt = '%y%m%d %H:%M:%S' 160 log_level = logging.INFO 161 if verbose: 162 log_fmt = '%(asctime)s %(process)d %(filename)s:%(lineno)d %(levelname)s %(message)s' 163 log_level = logging.DEBUG 164 165 root = logging.getLogger() 166 handler = logging.StreamHandler(stream) 167 handler.setFormatter(logging.Formatter(log_fmt, None)) 168 root.addHandler(handler) 169 root.setLevel(log_level) 170 return handler 171 172 173 def _restore_logging(handler_to_remove): 174 root = logging.getLogger() 175 root.handlers.remove(handler_to_remove) 176 177 149 178 class Printer(object): 150 179 """Class handling all non-debug-logging printing done by run-webkit-tests. … … 159 188 By default the buildbot-parsed code gets logged to stdout, and regular 160 189 output gets logged to stderr.""" 161 def __init__(self, port, options, regular_output, buildbot_output, logger=None):190 def __init__(self, port, options, regular_output, buildbot_output, configure_logging): 162 191 """ 163 192 Args … … 168 197 buildbot_output stream to which output intended to be read by 169 198 the buildbots (and humans) should be written 170 logger optional logger to integrate into the stream. 199 configure_loggign Whether a logging handler should be registered 200 171 201 """ 172 202 self._port = port 173 203 self._options = options 204 self._stream = regular_output 174 205 self._buildbot_stream = buildbot_output 175 self._meter = MeteredStream(regular_output, options.verbose, logger=logger) 206 self._meter = None 207 208 # These are used for --print one-line-progress 209 self._last_remaining = None 210 self._last_update_time = None 211 176 212 self.switches = parse_print_options(options.print_options, options.verbose) 177 213 214 self._logging_handler = None 215 if self._stream.isatty() and not options.verbose: 216 self._update_interval_seconds = FAST_UPDATES_SECONDS 217 self._meter = MeteredStream(self._stream) 218 if configure_logging: 219 self._logging_handler = _configure_logging(self._meter, options.verbose) 220 else: 221 self._update_interval_seconds = SLOW_UPDATES_SECONDS 222 if configure_logging: 223 self._logging_handler = _configure_logging(self._stream, options.verbose) 224 178 225 def cleanup(self): 179 self._meter.cleanup() 226 """Restore logging configuration to its initial settings.""" 227 if self._logging_handler: 228 _restore_logging(self._logging_handler) 229 self._logging_handler = None 180 230 181 231 def __del__(self): … … 301 351 return 302 352 303 if result_summary.remaining == 0: 304 self._meter.write_update('') 305 return 353 now = time.time() 354 if self._last_update_time is None: 355 self._last_update_time = now 356 357 time_since_last_update = now - self._last_update_time 358 if time_since_last_update <= self._update_interval_seconds: 359 return 360 361 self._last_update_time = now 306 362 307 363 percent_complete = 100 * (result_summary.expected + … … 310 366 if retrying: 311 367 action = "Retrying" 312 313 self._meter.write_throttled_update("%s (%d%%): %d ran as expected, %d didn't, %d left" % 314 (action, percent_complete, result_summary.expected, 315 result_summary.unexpected, result_summary.remaining)) 368 self._update("%s (%d%%): %d ran as expected, %d didn't, %d left" % 369 (action, percent_complete, result_summary.expected, 370 result_summary.unexpected, result_summary.remaining)) 371 372 if result_summary.remaining == 0: 373 self._update('') 316 374 317 375 def print_unexpected_results(self, unexpected_results): … … 401 459 if self.disabled('updates'): 402 460 return 403 self._ meter.write_update(msg)461 self._update(msg) 404 462 405 463 def write(self, msg, option="misc"): … … 409 467 410 468 def _write(self, msg): 411 self._meter.writeln(msg) 469 _log.info(msg) 470 471 def _update(self, msg): 472 if self._meter: 473 self._meter.update(msg) 474 else: 475 self._write(msg) -
trunk/Tools/Scripts/webkitpy/layout_tests/views/printing_unittest.py
r112014 r112019 1 1 #!/usr/bin/python 2 # Copyright (C) 2010 , 2012Google Inc. All rights reserved.2 # Copyright (C) 2010 Google Inc. All rights reserved. 3 3 # 4 4 # Redistribution and use in source and binary forms, with or without … … 30 30 """Unit tests for printing.py.""" 31 31 32 import logging 32 33 import optparse 33 34 import StringIO … … 54 55 55 56 class TestUtilityFunctions(unittest.TestCase): 57 def assertEmpty(self, stream): 58 self.assertFalse(stream.getvalue()) 59 60 def assertNotEmpty(self, stream): 61 self.assertTrue(stream.getvalue()) 62 63 def assertWritten(self, stream, contents): 64 self.assertEquals(stream.buflist, contents) 65 66 def test_configure_logging(self): 67 options, args = get_options([]) 68 stream = StringIO.StringIO() 69 handler = printing._configure_logging(stream, options.verbose) 70 logging.info("this should be logged") 71 self.assertNotEmpty(stream) 72 73 stream = StringIO.StringIO() 74 logging.debug("this should not be logged") 75 self.assertEmpty(stream) 76 77 printing._restore_logging(handler) 78 79 stream = StringIO.StringIO() 80 options, args = get_options(['--verbose']) 81 handler = printing._configure_logging(stream, options.verbose) 82 logging.debug("this should be logged") 83 self.assertNotEmpty(stream) 84 printing._restore_logging(handler) 85 56 86 def test_print_options(self): 57 87 options, args = get_options([]) … … 115 145 regular_output.isatty = lambda: tty 116 146 buildbot_output = StringIO.StringIO() 117 printer = printing.Printer(self._port, options, regular_output, buildbot_output) 147 printer = printing.Printer(self._port, options, regular_output, 148 buildbot_output, configure_logging=True) 118 149 return printer, regular_output, buildbot_output 119 150 … … 320 351 paths, rs, exp = self.get_result_summary(tests, expectations) 321 352 322 # First, test that we print nothing when we shouldn't print anything.353 # First, test that we print nothing. 323 354 printer.print_progress(rs, False, paths) 324 355 self.assertEmpty(out) … … 329 360 self.assertEmpty(err) 330 361 331 # Now test that we do print things. 332 printer, err, out = self.get_printer(['--print', 'one-line-progress']) 333 printer.print_progress(rs, False, paths) 334 self.assertEmpty(out) 335 self.assertNotEmpty(err) 336 337 printer, err, out = self.get_printer(['--print', 'one-line-progress']) 338 printer.print_progress(rs, True, paths) 339 self.assertEmpty(out) 340 self.assertNotEmpty(err) 341 342 printer, err, out = self.get_printer(['--print', 'one-line-progress']) 343 rs.remaining = 0 344 printer.print_progress(rs, False, paths) 345 self.assertEmpty(out) 346 self.assertNotEmpty(err) 347 348 printer.print_progress(rs, True, paths) 349 self.assertEmpty(out) 350 self.assertNotEmpty(err) 351 352 362 self.times = [1, 2, 12, 13, 14, 23, 33] 363 364 def mock_time(): 365 return self.times.pop(0) 366 367 orig_time = time.time 368 try: 369 time.time = mock_time 370 371 # Test printing progress updates to a file. 372 printer, err, out = self.get_printer(['--print', 'one-line-progress']) 373 printer.print_progress(rs, False, paths) 374 printer.print_progress(rs, False, paths) 375 self.assertEmpty(out) 376 self.assertEmpty(err) 377 378 printer.print_progress(rs, False, paths) 379 self.assertEmpty(out) 380 self.assertNotEmpty(err) 381 382 self.reset(err) 383 self.reset(out) 384 printer.print_progress(rs, True, paths) 385 self.assertEmpty(out) 386 self.assertEmpty(err) 387 388 printer.print_progress(rs, True, paths) 389 self.assertEmpty(out) 390 self.assertNotEmpty(err) 391 392 # Now reconfigure the printer to test printing to a TTY instead of a file. 393 self.times = [1, 1.01, 2, 3] 394 printer, err, out = self.get_printer(['--print', 'one-line-progress'], tty=True) 395 printer.print_progress(rs, False, paths) 396 printer.print_progress(rs, False, paths) 397 self.assertEmpty(out) 398 self.assertEmpty(err) 399 400 printer.print_progress(rs, False, paths) 401 self.assertEmpty(out) 402 self.assertNotEmpty(err) 403 404 self.reset(err) 405 self.reset(out) 406 printer.print_progress(rs, True, paths) 407 self.assertEmpty(out) 408 self.assertNotEmpty(err) 409 finally: 410 time.time = orig_time 353 411 354 412 def test_write_nothing(self): -
trunk/Tools/Scripts/webkitpy/performance_tests/perftestsrunner.py
r112014 r112019 63 63 self._port = self._host.port_factory.get(self._options.platform, self._options) 64 64 self._host._initialize_scm() 65 self._printer = printing.Printer(self._port, self._options, regular_output, buildbot_output )65 self._printer = printing.Printer(self._port, self._options, regular_output, buildbot_output, configure_logging=False) 66 66 self._webkit_base_dir_len = len(self._port.webkit_base()) 67 67 self._base_path = self._port.perf_tests_dir() -
trunk/Tools/Scripts/webkitpy/performance_tests/perftestsrunner_unittest.py
r112014 r112019 183 183 184 184 buildbot_output = StringIO.StringIO() 185 regular_output = StringIO.StringIO() 186 runner = self.create_runner(buildbot_output, args=["--pause-before-testing"], regular_output=regular_output, driver_class=TestDriverWithStartCount) 185 runner = self.create_runner(buildbot_output, args=["--pause-before-testing"], driver_class=TestDriverWithStartCount) 187 186 188 187 dirname = runner._base_path + '/inspector/' … … 195 194 self.assertEqual(TestDriverWithStartCount.start_count, 1) 196 195 finally: 197 _, stderr, _= output.restore_output()196 _, stderr, logs = output.restore_output() 198 197 self.assertEqual(stderr, "Ready to run test?\n") 199 self.assertTrue("Running inspector/pass.html (1 of 1)" in regular_output.getvalue())198 self.assertTrue("Running inspector/pass.html (1 of 1)" in logs) 200 199 201 200 def test_run_test_set_for_parser_tests(self):
Note: See TracChangeset
for help on using the changeset viewer.