Attachment 339025 Details for Bug 185090 – Patch

[patch] Patch

bug-185090-20180427141123.patch (text/plain), 7.91 KB, created by Jonathan Bedard on 2018-04-27 14:11:24 PDT

(hide)

Description:

Filename:

MIME Type:

Creator: Jonathan Bedard

Created: 2018-04-27 14:11:24 PDT

Size: 7.91 KB

patch

obsolete

>Index: Tools/ChangeLog
>===================================================================
>--- Tools/ChangeLog	(revision 231110)
>+++ Tools/ChangeLog	(working copy)
>@@ -1,3 +1,25 @@
>+2018-04-27  Jonathan Bedard  <jbedard@apple.com>
>+
>+        REGRESSION (r230998): Cannot stream API test output
>+        https://bugs.webkit.org/show_bug.cgi?id=185090
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        Change run-api-tests so that the stdout and stderr of a test will be printed
>+        before it's result. If -v is passed, the output of single test runs will be
>+        streamed. 
>+
>+        * Scripts/webkitpy/api_tests/runner.py:
>+        (Runner.__init__): Add number of workers and a flag to detect if a newline
>+        is needed at the beginning of a log line.
>+        (Runner.run): Turn off most logging coming from server process since it is
>+        not constructive for API tests.
>+        (Runner.handle): Add new log message to stream stdout and stderr instead of
>+        caching values until the test run finished.
>+        (_Worker._run_single_test): Log stdout and stderr in real time.
>+        (_Worker._run_shard_with_binary): Log stderr and stdout buffer before ending
>+        the test.
>+
> 2018-04-27  Wenson Hsieh  <wenson_hsieh@apple.com>
> 
>         [Extra zoom mode] Add a mechanism to override default viewport behaviors in extra zoom mode
>Index: Tools/Scripts/webkitpy/api_tests/runner.py
>===================================================================
>--- Tools/Scripts/webkitpy/api_tests/runner.py	(revision 231071)
>+++ Tools/Scripts/webkitpy/api_tests/runner.py	(working copy)
>@@ -21,10 +21,11 @@
> # SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
> 
> import os
>+import logging
> import time
> 
> from webkitpy.common import message_pool
>-from webkitpy.port.server_process import ServerProcess
>+from webkitpy.port.server_process import ServerProcess, _log as server_process_logger
> from webkitpy.xcode.simulated_device import SimulatedDeviceManager
> 
> 
>@@ -47,6 +48,8 @@ class Runner(object):
>         self.port = port
>         self.printer = printer
>         self.tests_run = 0
>+        self._num_workers = 1
>+        self._has_logged_for_test = True
>         self.results = {}
> 
>     @staticmethod
>@@ -78,24 +81,47 @@ class Runner(object):
>         self.printer.write_update('Sharding tests ...')
>         shards = Runner._shard_tests(tests)
> 
>-        with message_pool.get(self, lambda caller: _Worker(caller, self.port, shards), min(num_workers, len(shards))) as pool:
>-            pool.run(('test', shard) for shard, _ in shards.iteritems())
>+        original_level = server_process_logger.level
>+        server_process_logger.setLevel(logging.CRITICAL)
>+
>+        try:
>+            self._num_workers = min(num_workers, len(shards))
>+            with message_pool.get(self, lambda caller: _Worker(caller, self.port, shards), self._num_workers) as pool:
>+                pool.run(('test', shard) for shard, _ in shards.iteritems())
>+        finally:
>+            server_process_logger.setLevel(original_level)
>+
> 
>     def handle(self, message_name, source, test_name=None, status=0, output=''):
>         if message_name == 'did_spawn_worker':
>             return
>+
>+        will_stream_logs = self._num_workers == 1 and self.port.get_option('verbose')
>         if message_name == 'ended_test':
>             update = '{} {} {}'.format(source, test_name, Runner.NAME_FOR_STATUS[status])
> 
>             # Don't print test output if --quiet.
>             if status != Runner.STATUS_PASSED or (output and not self.port.get_option('quiet')):
>+                if not will_stream_logs:
>+                    if not self._has_logged_for_test:
>+                        self._has_logged_for_test = True
>+                        self.printer.writeln(source)
>+                    for line in output.splitlines():
>+                        self.printer.writeln('{}    {}'.format(source, line))
>                 self.printer.writeln(update)
>-                for line in output.splitlines():
>-                    self.printer.writeln('    {}'.format(line))
>             else:
>                 self.printer.write_update(update)
>             self.tests_run += 1
>             self.results[test_name] = (status, output)
>+            self._has_logged_for_test = False
>+
>+        if message_name == 'log' and will_stream_logs:
>+            if not self._has_logged_for_test:
>+                self._has_logged_for_test = True
>+                self.printer.writeln(source)
>+            for line in output.splitlines():
>+                self.printer.writeln('(log) {}    {}'.format(source, line))
>+
> 
>     def result_map_by_status(self, status=None):
>         map = {}
>@@ -130,28 +156,44 @@ class _Worker(object):
>             Runner.command_for_port(self._port, [self._port._build_path(binary_name), '--gtest_filter={}'.format(test)]),
>             env=self._port.environment_for_api_tests())
> 
>+        status = Runner.STATUS_FAILED
>+        if test.split('.')[1].startswith('DISABLED_'):
>+            status = Runner.STATUS_DISABLED
>+
>         try:
>             deadline = time.time() + self._timeout
>-            server_process.start()
>+            if status != Runner.STATUS_DISABLED:
>+                server_process.start()
> 
>-            if not test.split('.')[1].startswith('DISABLED_'):
>-                stdout_line = server_process.read_stdout_line(deadline)
>-            else:
>-                stdout_line = None
>+            stdout_buffer = ''
>+            stderr_buffer = ''
>+            while status == Runner.STATUS_FAILED:
>+                stdout_line, stderr_line = server_process.read_either_stdout_or_stderr_line(deadline)
>+                if not stderr_line and not stdout_line:
>+                    break
> 
>-            if not stdout_line and server_process.timed_out:
>+                if stderr_line:
>+                    stderr_buffer += stderr_line
>+                    self._caller.post('log', None, None, stderr_line[:-1])
>+                if stdout_line:
>+                    if '**PASS**' in stdout_line:
>+                        status = Runner.STATUS_PASSED
>+                    elif '**FAIL**' not in stdout_line:
>+                        stdout_buffer += stdout_line
>+                        self._caller.post('log', None, None, stdout_line[:-1])
>+
>+            if status == Runner.STATUS_DISABLED:
>+                pass
>+            elif server_process.timed_out:
>                 status = Runner.STATUS_TIMEOUT
>-            elif not stdout_line and server_process.has_crashed():
>+            elif server_process.has_crashed():
>                 status = Runner.STATUS_CRASHED
>-            elif not stdout_line:
>-                status = Runner.STATUS_DISABLED
>-            elif '**PASS**' in stdout_line:
>-                status = Runner.STATUS_PASSED
>-            else:
>-                status = Runner.STATUS_FAILED
> 
>         finally:
>-            output_buffer = server_process.pop_all_buffered_stdout() + server_process.pop_all_buffered_stderr()
>+            remaining_stderr = server_process.pop_all_buffered_stderr()
>+            remaining_stdout = server_process.pop_all_buffered_stdout()
>+            self._caller.post('log', None, None, remaining_stderr + remaining_stdout)
>+            output_buffer = stderr_buffer + stdout_buffer + remaining_stderr + remaining_stdout
>             server_process.stop()
> 
>         self._caller.post('ended_test', '{}.{}'.format(binary_name, test), status, self._filter_noisy_output(output_buffer))
>@@ -211,6 +253,7 @@ class _Worker(object):
>                     remaining_tests.remove(last_test)
>                     stdout_buffer += server_process.pop_all_buffered_stdout()
>                     stderr_buffer = server_process.pop_all_buffered_stderr() if last_status == Runner.STATUS_CRASHED else ''
>+                    self._caller.post('log', None, None, stdout_buffer + stderr_buffer)
>                     self._caller.post('ended_test', '{}.{}'.format(binary_name, last_test), last_status, self._filter_noisy_output(stdout_buffer + stderr_buffer))
> 
>                 if server_process.timed_out:

Actions: View | Formatted Diff | Diff

Attachments on bug 185090: 339025 | 339123 | 340142