Use new get_signal_number utility function for tests.

[chaoren]

Summary

This fixes TestLldbGdbServer and TestSendSignal from Windows to Android.
This change depends on D10171.

[chaoren]

• Fix TestSignal as well.

[clayborg]

Looks good.

[ovyalov]

LGTM

lldb/trunk/test/functionalities/signal/TestSendSignal.py

def send_signal(self):
 
         # If running remote test, there should be a connected event
         if lldb.remote_platform:
             self.match_state(process_listener, lldb.eStateConnected)
 
         self.match_state(process_listener, lldb.eStateRunning)
 
         # Now signal the process, and make sure it stops:
-        process.Signal(signal.SIGUSR1)
+        process.Signal(lldbutil.get_signal_number('SIGUSR1'))
 
         self.match_state(process_listener, lldb.eStateStopped)
 
         # Now make sure the thread was stopped with a SIGUSR1:
         threads = lldbutil.get_stopped_threads(process, lldb.eStopReasonSignal)
         self.assertTrue(len(threads) == 1, "One thread stopped for a signal.")
         thread = threads[0]
 
         self.assertTrue(thread.GetStopReasonDataCount() >= 1, "There was data in the event.")
-        self.assertTrue(thread.GetStopReasonDataAtIndex(0) == signal.SIGUSR1, "The stop signal was SIGUSR1")
+        self.assertTrue(thread.GetStopReasonDataAtIndex(0) == lldbutil.get_signal_number('SIGUSR1'),
+                "The stop signal was SIGUSR1")
 
 if __name__ == '__main__':
     import atexit
     lldb.SBDebugger.Initialize()
     atexit.register(lambda: lldb.SBDebugger.Terminate())
     unittest2.main()

lldb/trunk/test/tools/lldb-server/TestLldbGdbServer.py

def Hc_then_Csignal_signals_correct_thread(self, segfault_signo):
                 [
                 # Set the continue thread.
                  "read packet: $Hc{0:x}#00".format(thread_id),  # Set current thread.
                  "send packet: $OK#00",
 
                  # Continue sending the signal number to the continue thread.
                  # The commented out packet is a way to do this same operation without using
                  # a $Hc (but this test is testing $Hc, so we'll stick with the former).
-                 "read packet: $C{0:x}#00".format(signal.SIGUSR1),
-                 # "read packet: $vCont;C{0:x}:{1:x};c#00".format(signal.SIGUSR1, thread_id),
+                 "read packet: $C{0:x}#00".format(lldbutil.get_signal_number('SIGUSR1')),
+                 # "read packet: $vCont;C{0:x}:{1:x};c#00".format(lldbutil.get_signal_number('SIGUSR1'), thread_id),
 
                  # FIXME: Linux does not report the thread stop on the delivered signal (SIGUSR1 here).  MacOSX debugserver does.
                  # But MacOSX debugserver isn't guaranteeing the thread the signal handler runs on, so currently its an XFAIL.
                  # Need to rectify behavior here.  The linux behavior is more intuitive to me since we're essentially swapping out
                  # an about-to-be-delivered signal (for which we already sent a stop packet) to a different signal.
                  # {"direction":"send", "regex":r"^\$T([0-9a-fA-F]{2})thread:([0-9a-fA-F]+);", "capture":{1:"stop_signo", 2:"stop_thread_id"} },
                  #  "read packet: $c#63",
                  { "type":"output_match", "regex":r"^received SIGUSR1 on thread id: ([0-9a-fA-F]+)\r\nthread ([0-9a-fA-F]+): past SIGSEGV\r\n", "capture":{ 1:"print_thread_id", 2:"post_handle_thread_id" } },
                 ],
                 True)
 
             # Run the sequence.
             context = self.expect_gdbremote_sequence(timeout_seconds=10)
             self.assertIsNotNone(context)
 
             # Ensure the stop signal is the signal we delivered.
             # stop_signo = context.get("stop_signo")
             # self.assertIsNotNone(stop_signo)
-            # self.assertEquals(int(stop_signo,16), signal.SIGUSR1)
-            
+            # self.assertEquals(int(stop_signo,16), lldbutil.get_signal_number('SIGUSR1'))
             # Ensure the stop thread is the thread to which we delivered the signal.
             # stop_thread_id = context.get("stop_thread_id")
             # self.assertIsNotNone(stop_thread_id)
             # self.assertEquals(int(stop_thread_id,16), thread_id)
 
             # Ensure we haven't seen this thread id yet.  The inferior's self-obtained thread ids are not guaranteed to match the stub tids (at least on MacOSX).
             print_thread_id = context.get("print_thread_id")
             self.assertIsNotNone(print_thread_id)
def test_Hc_then_Csignal_signals_correct_thread_launch_debugserver_dsym(self):
         self.Hc_then_Csignal_signals_correct_thread(self.TARGET_EXC_BAD_ACCESS)
 
     @llgs_test
     @dwarf_test
     def test_Hc_then_Csignal_signals_correct_thread_launch_llgs_dwarf(self):
         self.init_llgs_test()
         self.buildDwarf()
         self.set_inferior_startup_launch()
-        self.Hc_then_Csignal_signals_correct_thread(signal.SIGSEGV)
+        self.Hc_then_Csignal_signals_correct_thread(lldbutil.get_signal_number('SIGSEGV'))
 
     def m_packet_reads_memory(self):
         # This is the memory we will write into the inferior and then ensure we can read back with $m.
         MEMORY_CONTENTS = "Test contents 0123456789 ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz"
 
         # Start up the inferior.
         procs = self.prep_debug_monitor_and_inferior(
             inferior_args=["set-message:%s" % MEMORY_CONTENTS, "get-data-address-hex:g_message", "sleep:5"])
def software_breakpoint_set_and_remove_work(self):
 
         # Run the packet stream.
         context = self.expect_gdbremote_sequence()
         self.assertIsNotNone(context)
 
         # Verify the stop signal reported was the breakpoint signal number.
         stop_signo = context.get("stop_signo")
         self.assertIsNotNone(stop_signo)
-        self.assertEquals(int(stop_signo,16), signal.SIGTRAP)
+        self.assertEquals(int(stop_signo,16), lldbutil.get_signal_number('SIGTRAP'))
 
         # Ensure we did not receive any output.  If the breakpoint was not set, we would
         # see output (from a launched process with captured stdio) printing a hello, world message.
         # That would indicate the breakpoint didn't take.
         self.assertEquals(len(context["O_content"]), 0)
 
         # Verify that the PC for the main thread is where we expect it - right at the breakpoint address.
         # This acts as a another validation on the register reading code.

lldb/trunk/test/tools/lldb-server/gdbremote_testcase.py

def count_single_steps_until_true(self, thread_id, predicate, args, max_step_count=100, use_Hc_packet=True, step_instruction="s"):
                  step_packet,
                  # "read packet: $vCont;s:{0:x}#00".format(thread_id),
                  # Expect a breakpoint stop report.
                  {"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)
             self.assertIsNotNone(context.get("stop_signo"))
-            self.assertEquals(int(context.get("stop_signo"), 16), signal.SIGTRAP)
+            self.assertEquals(int(context.get("stop_signo"), 16),
+                    lldbutil.get_signal_number('SIGTRAP'))
 
             single_step_count += 1
 
             # See if the predicate is true.  If so, we're done.
             if predicate(args):
                 return (True, single_step_count)
 
         # The predicate didn't return true within the runaway step count.