[dotest] Remove results port

[JDevlieghere]

Summary

The results port was used by dosep to deal with test results coming form different processes. With dosep gone, I don't think we need this any longer.

[• BlackAngel35]

EnDing

[xiaobai]

LGTM

lldb/packages/Python/lldbsuite/test/configuration.py

 
 # The only directory to scan for tests. If multiple test directories are
 # specified, and an exclusive test subdirectory is specified, the latter option
 # takes precedence.
 exclusive_test_subdir = None
 
 # Test results handling globals
 results_filename = None
-results_port = None
 results_formatter_name = None
 results_formatter_object = None
 results_formatter_options = None
 test_result = None
 
 # Test rerun configuration vars
 rerun_all_issues = False
 rerun_max_file_threhold = 0

lldb/packages/Python/lldbsuite/test/dotest.py

def parseOptionsAndInitTestdirs():
     if args.curses:
         # Act as if the following args were set.
         args.results_formatter = "lldbsuite.test_event.formatter.curses.Curses"
         args.results_file = "stdout"
 
     if args.results_file:
         configuration.results_filename = args.results_file
 
-    if args.results_port:
-        configuration.results_port = args.results_port
-
-    if args.results_file and args.results_port:
-        sys.stderr.write(
-            "only one of --results-file and --results-port should "
-            "be specified\n")
-        usage(args)
-
     if args.results_formatter:
         configuration.results_formatter_name = args.results_formatter
     if args.results_formatter_options:
         configuration.results_formatter_options = args.results_formatter_options
 
     # Default to using the BasicResultsFormatter if no formatter is specified.
     if configuration.results_formatter_name is None:
         configuration.results_formatter_name = (

 def setupTestResults():
     """Sets up test results-related objects based on arg settings."""
     # Setup the results formatter configuration.
     formatter_config = formatter.FormatterConfig()
     formatter_config.filename = configuration.results_filename
     formatter_config.formatter_name = configuration.results_formatter_name
     formatter_config.formatter_options = (
         configuration.results_formatter_options)
-    formatter_config.port = configuration.results_port
 
     # Create the results formatter.
     formatter_spec = formatter.create_results_formatter(
         formatter_config)
     if formatter_spec is not None and formatter_spec.formatter is not None:
         configuration.results_formatter_object = formatter_spec.formatter
 
         # Send an initialize message to the formatter.

lldb/packages/Python/lldbsuite/test/dotest_args.py

group.add_argument(
         action='store_true',
         help='Shortcut for specifying test results using the curses formatter')
     group.add_argument(
         '--results-file',
         action='store',
         help=('Specifies the file where test results will be written '
               'according to the results-formatter class used'))
     group.add_argument(
-        '--results-port',
-        action='store',
-        type=int,
-        help=('Specifies the localhost port to which the results '
-              'formatted output should be sent'))
-    group.add_argument(
         '--results-formatter',
         action='store',
         help=('Specifies the full package/module/class name used to translate '
               'test events into some kind of meaningful report, written to '
               'the designated output results file-like object'))
     group.add_argument(
         '--results-formatter-option',
         '-O',

lldb/packages/Python/lldbsuite/test_event/formatter/__init__.py

 
 # Ignore method count on DTOs.
 # pylint: disable=too-few-public-methods
 class FormatterConfig(object):
     """Provides formatter configuration info to create_results_formatter()."""
 
     def __init__(self):
         self.filename = None
-        self.port = None
         self.formatter_name = None
         self.formatter_options = None
 
 
 # Ignore method count on DTOs.
 # pylint: disable=too-few-public-methods
 class CreatedFormatter(object):
     """Provides transfer object for returns from create_results_formatter()."""
 
     def __init__(self, formatter, cleanup_func):
         self.formatter = formatter
         self.cleanup_func = cleanup_func
 
 
 def create_results_formatter(config):
     """Sets up a test results formatter.
 
     @param config an instance of FormatterConfig
     that indicates how to setup the ResultsFormatter.
 
     @return an instance of CreatedFormatter.
     """
 
-    def create_socket(port):
-        """Creates a socket to the localhost on the given port.
-
-        @param port the port number of the listening port on
-        the localhost.
-
-        @return (socket object, socket closing function)
-        """
-
-        def socket_closer(open_sock):
-            """Close down an opened socket properly."""
-            open_sock.shutdown(socket.SHUT_RDWR)
-            open_sock.close()
-
-        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-        sock.connect(("localhost", port))
-
-        # Wait for the ack from the listener side.
-        # This is needed to prevent a race condition
-        # in the main dosep.py processing loop: we
-        # can't allow a worker queue thread to die
-        # that has outstanding messages to a listener
-        # socket before the listener socket asyncore
-        # listener socket gets spun up; otherwise,
-        # we lose the test result info.
-        read_bytes = sock.recv(1)
-        if read_bytes is None or (len(read_bytes) < 1) or (read_bytes != b'*'):
-            raise Exception(
-                "listening socket did not respond with ack byte: response={}".format(read_bytes))
-
-        return sock, lambda: socket_closer(sock)
-
     default_formatter_name = None
     results_file_object = None
     cleanup_func = None
 
-    file_is_stream = False
     if config.filename:
         # Open the results file for writing.
         if config.filename == 'stdout':
             results_file_object = sys.stdout
             cleanup_func = None
         elif config.filename == 'stderr':
             results_file_object = sys.stderr
             cleanup_func = None
         else:
             results_file_object = open(config.filename, "w")
             cleanup_func = results_file_object.close
         default_formatter_name = (
             "lldbsuite.test_event.formatter.xunit.XunitFormatter")
-    elif config.port:
-        # Connect to the specified localhost port.
-        results_file_object, cleanup_func = create_socket(config.port)
-        default_formatter_name = (
-            "lldbsuite.test_event.formatter.pickled.RawPickledFormatter")
-        file_is_stream = True
 
     # If we have a results formatter name specified and we didn't specify
     # a results file, we should use stdout.
     if config.formatter_name is not None and results_file_object is None:
         # Use stdout.
         results_file_object = sys.stdout
         cleanup_func = None
 
if results_file_object:
             command_line_options = []
 
         formatter_options = formatter_arg_parser.parse_args(
             command_line_options)
 
         # Create the TestResultsFormatter given the processed options.
         results_formatter_object = cls(
             results_file_object,
-            formatter_options,
-            file_is_stream)
+            formatter_options)
 
         def shutdown_formatter():
             """Shuts down the formatter when it is no longer needed."""
             # Tell the formatter to write out anything it may have
             # been saving until the very end (e.g. xUnit results
             # can't complete its output until this point).
             results_formatter_object.send_terminate_as_needed()
 

lldb/packages/Python/lldbsuite/test_event/formatter/curses.py

 
 from . import results_formatter
 from ..event_builder import EventBuilder
 
 
 class Curses(results_formatter.ResultsFormatter):
     """Receives live results from tests that are running and reports them to the terminal in a curses GUI"""
 
-    def __init__(self, out_file, options, file_is_stream):
+    def __init__(self, out_file, options):
         # Initialize the parent
-        super(Curses, self).__init__(out_file, options, file_is_stream)
+        super(Curses, self).__init__(out_file, options)
         self.using_terminal = True
         self.have_curses = True
         self.initialize_event = None
         self.jobs = [None] * 64
         self.job_tests = [None] * 64
         self.results = list()
         try:
             self.main_window = lldbcurses.intialize_curses()

lldb/packages/Python/lldbsuite/test_event/formatter/pickled.py

class StreamSerializer(object):
             out_file.send(packet)
 
     class BlockSerializer(object):
 
         @staticmethod
         def serialize(test_event, out_file):
             cPickle.dump(test_event, out_file)
 
-    def __init__(self, out_file, options, file_is_stream):
+    def __init__(self, out_file, options):
         super(
             RawPickledFormatter,
             self).__init__(
             out_file,
-            options,
-            file_is_stream)
+            options)
         self.pid = os.getpid()
-        if file_is_stream:
-            self.serializer = self.StreamSerializer()
-        else:
-            self.serializer = self.BlockSerializer()
 
     def handle_event(self, test_event):
         super(RawPickledFormatter, self).handle_event(test_event)
 
         # Convert initialize/terminate events into job_begin/job_end events.
         event_type = test_event["event"]
         if event_type is None:
             return

lldb/packages/Python/lldbsuite/test_event/formatter/results_formatter.py

def arg_parser(cls):
                    '"--option1 value1 [--option2 value2 [...]]"'))
         parser.add_argument(
             "--dump-results",
             action="store_true",
             help=('dump the raw results data after printing '
                   'the summary output.'))
         return parser
 
-    def __init__(self, out_file, options, file_is_stream):
+    def __init__(self, out_file, options):
         super(ResultsFormatter, self).__init__()
         self.out_file = out_file
         self.options = options
         self.using_terminal = False
         if not self.out_file:
             raise Exception("ResultsFormatter created with no file object")
         self.start_time_by_test = {}
         self.terminate_called = False
-        self.file_is_stream = file_is_stream
 
         # Track the most recent test start event by worker index.
         # We'll use this to assign TIMEOUT and exceptional
         # exits to the most recent test started on a given
         # worker index.
         self.started_tests_by_worker = {}
 
         # Store the most recent test_method/job status.

lldb/packages/Python/lldbsuite/test_event/formatter/xunit.py

def _build_regex_list_from_patterns(patterns):
         patterns provided.
         """
         regex_list = []
         if patterns is not None:
             for pattern in patterns:
                 regex_list.append(re.compile(pattern))
         return regex_list
 
-    def __init__(self, out_file, options, file_is_stream):
+    def __init__(self, out_file, options):
         """Initializes the XunitFormatter instance.
         @param out_file file-like object where formatted output is written.
         @param options specifies a dictionary of options for the
         formatter.
         """
         # Initialize the parent
-        super(XunitFormatter, self).__init__(out_file, options, file_is_stream)
+        super(XunitFormatter, self).__init__(out_file, options)
         self.text_encoding = "UTF-8"
         self.invalid_xml_re = XunitFormatter._build_illegal_xml_regex()
         self.total_test_count = 0
         self.ignore_skip_name_regexes = (
             XunitFormatter._build_regex_list_from_patterns(
                 options.ignore_skip_name_patterns))
         self.ignore_skip_reason_regexes = (
             XunitFormatter._build_regex_list_from_patterns(