[test] Relax stderr expectations on targets with chatty output

[labath]

Summary

On some android targets, a binary can produce additional garbage (e.g. warning messages from the
dynamic linker) on the standard error, which confuses some tests. This relaxes the stderr
expectations for targets known for their chattyness.

[tberghammer]

Looks good

[srhines]

packages/Python/lldbsuite/test/lldbplatformutil.py

142 ↗

(On Diff #53718)

I know it isn't ideal, but the stderr output isn't actually "garbage". It is just not a warning that lldb cares about, but it is perfectly valid to notify developers of an incorrect linking behavior.

lldb/trunk/packages/Python/lldbsuite/test/lldbplatformutil.py

 
 def createPlatformContext():
     if platformIsDarwin():
         return _PlatformContext('DYLD_LIBRARY_PATH', 'lib', 'dylib')
     elif getPlatform() in ("freebsd", "linux", "netbsd"):
         return _PlatformContext('LD_LIBRARY_PATH', 'lib', 'so')
     else:
         return None
+
+def hasChattyStderr(test_case):
+    """Some targets produce garbage on the standard error output. This utility function
+    determines whether the tests can be strict about the expected stderr contents."""
+    if match_android_device(test_case.getArchitecture(), ['aarch64'], [22]):
+        return True # The dynamic linker on the device will complain about unknown DT entries
+    return False

lldb/trunk/packages/Python/lldbsuite/test/settings/TestSettings.py

def test_set_error_output_path(self):
         # The 'stderr.txt' file should now exist.
         self.assertTrue(os.path.isfile("stderr.txt"),
                         "'stderr.txt' exists due to target.error-path.")
 
         # Read the output file produced by running the program.
         with open('stderr.txt', 'r') as f:
             output = f.read()
 
-        self.expect(output, exe=False,
-            startstr = "This message should go to standard error.")
+        message = "This message should go to standard error."
+        if lldbplatformutil.hasChattyStderr(self):
+            self.expect(output, exe=False, substrs = [message])
+        else:
+            self.expect(output, exe=False, startstr = message)
 
         # The 'stdout.txt' file should now exist.
         self.assertTrue(os.path.isfile("stdout.txt"),
                         "'stdout.txt' exists due to target.output-path.")
 
         # Read the output file produced by running the program.
         with open('stdout.txt', 'r') as f:
             output = f.read()

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-server/TestGdbRemoteAuxvSupport.py

def has_auxv_support(self):
         # Don't do anything until we match the launched inferior main entry output.
         # Then immediately interrupt the process.
         # This prevents auxv data being asked for before it's ready and leaves
         # us in a stopped state.
         self.test_sequence.add_log_lines([
             # Start the inferior...
             "read packet: $c#63",
             # ... match output....
-            { "type":"output_match", "regex":r"^message:main entered\r\n$" },
+            { "type":"output_match", "regex":self.maybe_strict_output_regex(r"message:main entered\r\n") },
             ], True)
         # ... then interrupt.
         self.add_interrupt_packets()
         self.add_qSupported_packets()
 
         context = self.expect_gdbremote_sequence()
         self.assertIsNotNone(context)
 

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-server/TestGdbRemoteRegisterState.py

def grp_register_save_restore_works(self, with_suffix):
         self.add_register_info_collection_packets()
         if with_suffix:
             self.add_thread_suffix_request_packets()
         self.add_threadinfo_collection_packets()
         self.test_sequence.add_log_lines([
             # Start the inferior...
             "read packet: $c#63",
             # ... match output....
-            { "type":"output_match", "regex":r"^message:main entered\r\n$" },
+            { "type":"output_match", "regex":self.maybe_strict_output_regex(r"message:main entered\r\n") },
             ], True)
         # ... then interrupt.
         self.add_interrupt_packets()
 
         context = self.expect_gdbremote_sequence()
         self.assertIsNotNone(context)
 
         # Gather process info.

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-server/TestLldbGdbServer.py

def inferior_print_exit(self):
 
         # build launch args
         launch_args += ["hello, world"]
 
         self.add_no_ack_remote_stream()
         self.add_verified_launch_packets(launch_args)
         self.test_sequence.add_log_lines(
             ["read packet: $vCont;c#a8",
-             {"type":"output_match", "regex":r"^hello, world\r\n$" },
+             {"type":"output_match", "regex": self.maybe_strict_output_regex(r"hello, world\r\n")},
              "send packet: $W00#00"],
             True)
 
         context = self.expect_gdbremote_sequence()
         self.assertIsNotNone(context)
 
     @debugserver_test
     def test_inferior_print_exit_debugserver(self):
def m_packet_reads_memory(self):
 
         # Run the process
         self.test_sequence.add_log_lines(
             [
              # Start running after initial stop.
              "read packet: $c#63",
              # Match output line that prints the memory address of the message buffer within the inferior. 
              # Note we require launch-only testing so we can get inferior otuput.
-             { "type":"output_match", "regex":r"^data address: 0x([0-9a-fA-F]+)\r\n$", "capture":{ 1:"message_address"} },
+             { "type":"output_match", "regex":self.maybe_strict_output_regex(r"data address: 0x([0-9a-fA-F]+)\r\n"),
+               "capture":{ 1:"message_address"} },
              # Now stop the inferior.
              "read packet: {}".format(chr(3)),
              # And wait for the stop notification.
              {"direction":"send", "regex":r"^\$T([0-9a-fA-F]{2})thread:([0-9a-fA-F]+);", "capture":{1:"stop_signo", 2:"stop_thread_id"} }],
             True)
 
         # Run the packet stream.
         context = self.expect_gdbremote_sequence()
def qMemoryRegionInfo_reports_code_address_as_executable(self):
 
         # Run the process
         self.test_sequence.add_log_lines(
             [
              # Start running after initial stop.
              "read packet: $c#63",
              # Match output line that prints the memory address of the message buffer within the inferior. 
              # Note we require launch-only testing so we can get inferior otuput.
-             { "type":"output_match", "regex":r"^code address: 0x([0-9a-fA-F]+)\r\n$", "capture":{ 1:"code_address"} },
+             { "type":"output_match", "regex":self.maybe_strict_output_regex(r"code address: 0x([0-9a-fA-F]+)\r\n"),
+               "capture":{ 1:"code_address"} },
              # Now stop the inferior.
              "read packet: {}".format(chr(3)),
              # And wait for the stop notification.
              {"direction":"send", "regex":r"^\$T([0-9a-fA-F]{2})thread:([0-9a-fA-F]+);", "capture":{1:"stop_signo", 2:"stop_thread_id"} }],
             True)
 
         # Run the packet stream.
         context = self.expect_gdbremote_sequence()
def qMemoryRegionInfo_reports_stack_address_as_readable_writeable(self):
 
         # Run the process
         self.test_sequence.add_log_lines(
             [
              # Start running after initial stop.
              "read packet: $c#63",
              # Match output line that prints the memory address of the message buffer within the inferior. 
              # Note we require launch-only testing so we can get inferior otuput.
-             { "type":"output_match", "regex":r"^stack address: 0x([0-9a-fA-F]+)\r\n$", "capture":{ 1:"stack_address"} },
+             { "type":"output_match", "regex":self.maybe_strict_output_regex(r"stack address: 0x([0-9a-fA-F]+)\r\n"),
+               "capture":{ 1:"stack_address"} },
              # Now stop the inferior.
              "read packet: {}".format(chr(3)),
              # And wait for the stop notification.
              {"direction":"send", "regex":r"^\$T([0-9a-fA-F]{2})thread:([0-9a-fA-F]+);", "capture":{1:"stop_signo", 2:"stop_thread_id"} }],
             True)
 
         # Run the packet stream.
         context = self.expect_gdbremote_sequence()
def qMemoryRegionInfo_reports_heap_address_as_readable_writeable(self):
 
         # Run the process
         self.test_sequence.add_log_lines(
             [
              # Start running after initial stop.
              "read packet: $c#63",
              # Match output line that prints the memory address of the message buffer within the inferior. 
              # Note we require launch-only testing so we can get inferior otuput.
-             { "type":"output_match", "regex":r"^heap address: 0x([0-9a-fA-F]+)\r\n$", "capture":{ 1:"heap_address"} },
+             { "type":"output_match", "regex":self.maybe_strict_output_regex(r"heap address: 0x([0-9a-fA-F]+)\r\n"),
+               "capture":{ 1:"heap_address"} },
              # Now stop the inferior.
              "read packet: {}".format(chr(3)),
              # And wait for the stop notification.
              {"direction":"send", "regex":r"^\$T([0-9a-fA-F]{2})thread:([0-9a-fA-F]+);", "capture":{1:"stop_signo", 2:"stop_thread_id"} }],
             True)
 
         # Run the packet stream.
         context = self.expect_gdbremote_sequence()
def software_breakpoint_set_and_remove_work(self):
         # Run the process
         self.add_register_info_collection_packets()
         self.add_process_info_collection_packets()
         self.test_sequence.add_log_lines(
             [# Start running after initial stop.
              "read packet: $c#63",
              # Match output line that prints the memory address of the function call entry point.
              # Note we require launch-only testing so we can get inferior otuput.
-             { "type":"output_match", "regex":r"^code address: 0x([0-9a-fA-F]+)\r\n$", "capture":{ 1:"function_address"} },
+             { "type":"output_match", "regex":self.maybe_strict_output_regex(r"code address: 0x([0-9a-fA-F]+)\r\n"),
+               "capture":{ 1:"function_address"} },
              # Now stop the inferior.
              "read packet: {}".format(chr(3)),
              # And wait for the stop notification.
              {"direction":"send", "regex":r"^\$T([0-9a-fA-F]{2})thread:([0-9a-fA-F]+);", "capture":{1:"stop_signo", 2:"stop_thread_id"} }],
             True)
 
         # Run the packet stream.
         context = self.expect_gdbremote_sequence()
def written_M_content_reads_back_correctly(self):
         # Start up the stub and start/prep the inferior.
         procs = self.prep_debug_monitor_and_inferior(inferior_args=["set-message:xxxxxxxxxxxxxX", "get-data-address-hex:g_message", "sleep:1", "print-message:"])
         self.test_sequence.add_log_lines(
             [
              # Start running after initial stop.
              "read packet: $c#63",
              # Match output line that prints the memory address of the message buffer within the inferior. 
              # Note we require launch-only testing so we can get inferior otuput.
-             { "type":"output_match", "regex":r"^data address: 0x([0-9a-fA-F]+)\r\n$", "capture":{ 1:"message_address"} },
+             { "type":"output_match", "regex":self.maybe_strict_output_regex(r"data address: 0x([0-9a-fA-F]+)\r\n"),
+               "capture":{ 1:"message_address"} },
              # Now stop the inferior.
              "read packet: {}".format(chr(3)),
              # And wait for the stop notification.
              {"direction":"send", "regex":r"^\$T([0-9a-fA-F]{2})thread:([0-9a-fA-F]+);", "capture":{1:"stop_signo", 2:"stop_thread_id"} }],
             True)
         context = self.expect_gdbremote_sequence()
         self.assertIsNotNone(context)
 

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-server/gdbremote_testcase.py

def single_step_only_steps_one_instruction(self, use_Hc_packet=True, step_instruction="s"):
 
         # Verify we hit the next state.
         args["expected_g_c1"] = "0"
         args["expected_g_c2"] = "1"
         (state_reached, step_count) = self.count_single_steps_until_true(main_thread_id, self.g_c1_c2_contents_are, args, max_step_count=5, use_Hc_packet=use_Hc_packet, step_instruction=step_instruction)
         self.assertTrue(state_reached)
         self.assertEqual(step_count, expected_step_count)
 
+    def maybe_strict_output_regex(self, regex):
+        return '.*'+regex+'.*' if lldbplatformutil.hasChattyStderr(self) else '^'+regex+'$'
+

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-server/lldbgdbserverutils.py

def add_log_lines(self, log_lines, remote_input_is_read):
                         self.entries.append(GdbRemoteEntry(is_send_to_remote=False, regex=regex, capture=capture, expect_captures=expect_captures))
                 elif entry_type == "multi_response":
                     self.entries.append(MultiResponseGdbRemoteEntry(line))
                 elif entry_type == "output_match":
 
                     regex = line.get("regex", None)
                     # Compile the regex.
                     if regex and (type(regex) == str):
-                        regex = re.compile(regex)
+                        regex = re.compile(regex, re.DOTALL)
 
                     regex_mode = line.get("regex_mode", "match")
                     capture = line.get("capture", None)
                     self.entries.append(MatchRemoteOutputEntry(regex=regex, regex_mode=regex_mode, capture=capture))
                 else:
                     raise Exception("unknown entry type \"%s\"" % entry_type)
 
 def process_is_running(pid, unknown_value=True):