Update TestGdbRemoteAbort and TestGdbRemoteSegFault to use `get_signal_number`.

[ovyalov]

test/functionalities/process_group/TestChangeProcessGroup.py

75

Since it checks for local /proc directory it's ok to send local SIGKILL.

To make it work on any platform we may use sth like

self.dbg.GetSelectedPlatform().Kill(int(pid))

instead of

if lldb.remote_platform:
               lldb.remote_platform.Kill(int(pid))
           else:
               if os.path.exists("/proc/" + pid):
                   os.kill(int(pid), lldbutil.get_signal_number('SIGKILL'))

test/lldbtest.py

297

_LocalProcess handles only local processes - signal.SIGHUP should be ok.

1334

Fork should be only local.

[chaoren]

• Only use get_signal_number where it's possible to be a remote signal.

[ovyalov]

LGTM

test/dotest.py

o GDB_REMOTE_LOG: if defined, specifies the log file pathname for the
   'process.gdb-remote' subsystem with a default option of 'packets' if
   GDB_REMOTE_LOG_OPTION is not defined.
 
 """
     sys.exit(0)
 
 
 def unique_string_match(yourentry,list):
-  candidate = None
-  for item in list:
-    if item.startswith(yourentry):
-      if candidate:
-        return None
-      candidate = item
-  return candidate
+    candidate = None
+    for item in list:
+        if item.startswith(yourentry):
+            if candidate:
+                return None
+            candidate = item
+    return candidate
 
 def validate_categories(categories):
     """For each category in categories, ensure that it's a valid category (or a prefix thereof).
        If a category is invalid, print a message and quit.
        If all categories are valid, return the list of categories. Prefixes are expanded in the
        returned list.
     """
     global validCategories
if args.c:
             usage(parser)
         configFile = args.c
         if not os.path.isfile(configFile):
             print 'Config file:', configFile, 'does not exist!'
             usage(parser)
 
     if args.d:
         sys.stdout.write("Suspending the process %d to wait for debugger to attach...\n" % os.getpid())
-        sys.stdout.flush()    
-        os.kill(os.getpid(), signal.SIGSTOP)
+        sys.stdout.flush()
+        os.kill(os.getpid(), lldbutil.get_signal_number('SIGSTOP'))
 
     if args.e:
         if args.e.startswith('-'):
             usage(parser)
         bmExecutable = args.e
         if not is_exe(bmExecutable):
             usage(parser)
 
else:
             return
         
         # If our lldb supports the -P option, use it to find the python path:
         init_in_python_dir = os.path.join('lldb', '__init__.py')
 
         lldb_dash_p_result = subprocess.check_output([lldbtest_config.lldbExec, "-P"], stderr=subprocess.STDOUT)
 
         if lldb_dash_p_result and not lldb_dash_p_result.startswith(("<", "lldb: invalid option:")) \
-                and not lldb_dash_p_result.startswith("Traceback"):
+                              and not lldb_dash_p_result.startswith("Traceback"):
             lines = lldb_dash_p_result.splitlines()
 
             # Workaround for readline vs libedit issue on FreeBSD.  If stdout
             # is not a terminal Python executes
             #     rl_variable_bind ("enable-meta-key", "off");
             # This produces a warning with FreeBSD's libedit because the
             # enable-meta-key variable is unknown.  Not an issue on Apple
             # because cpython commit f0ab6f9f0603 added a #ifndef __APPLE__

test/functionalities/process_group/TestChangeProcessGroup.py

def setpgid(self):
         self.assertTrue(err.Success() and retcode == 0,
                 "Failed to read file %s: %s, retcode: %d" % (pid_file_path, err.GetCString(), retcode))
 
         # make sure we cleanup the forked child also
         def cleanupChild():
             if lldb.remote_platform:
                 lldb.remote_platform.Kill(int(pid))
             else:
                 if os.path.exists("/proc/" + pid):
-                    os.kill(int(pid), signal.SIGKILL)
+                    os.kill(int(pid), lldbutil.get_signal_number('SIGKILL'))
         self.addTearDownHook(cleanupChild)
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 
         listener = lldb.SBListener("my.attach.listener")
         error = lldb.SBError()

test/lldbtest.py

class _LocalProcess(_BaseProcess):
     def launch(self, executable, args):
         self._proc = Popen([executable] + args,
                            stdout = open(os.devnull) if not self._trace_on else None,
                            stdin = PIPE)
 
     def terminate(self):
         if self._proc.poll() == None:
             # Terminate _proc like it does the pexpect
-            self._proc.send_signal(signal.SIGHUP)
+            self._proc.send_signal(lldbutil.get_signal_number('SIGHUP'))
             time.sleep(self._delayafterterminate)
             if self._proc.poll() != None:
                 return
-            self._proc.send_signal(signal.SIGCONT)
+            self._proc.send_signal(lldbutil.get_signal_number('SIGCONT'))
             time.sleep(self._delayafterterminate)
             if self._proc.poll() != None:
                 return
-            self._proc.send_signal(signal.SIGINT)
+            self._proc.send_signal(lldbutil.get_signal_number('SIGINT'))
             time.sleep(self._delayafterterminate)
             if self._proc.poll() != None:
                 return
             self._proc.terminate()
             time.sleep(self._delayafterterminate)
             if self._proc.poll() != None:
                 return
             self._proc.kill()
def cleanupSubprocesses(self):
         # Ensure any subprocesses are cleaned up
         for p in self.subprocesses:
             p.terminate()
             del p
         del self.subprocesses[:]
         # Ensure any forked processes are cleaned up
         for pid in self.forkedProcessPids:
             if os.path.exists("/proc/" + str(pid)):
-                os.kill(pid, signal.SIGTERM)
+                os.kill(pid, lldbutil.get_signal_number('SIGTERM'))
 
     def spawnSubprocess(self, executable, args=[], install_remote=True):
         """ Creates a subprocess.Popen object with the specified executable and arguments,
             saves it in self.subprocesses, and returns the object.
             NOTE: if using this function, ensure you also call:
 
               self.addTearDownHook(self.cleanupSubprocesses)
 

test/tools/lldb-server/inferior-crash/TestGdbRemoteAbort.py

def inferior_abort_received(self):
             {"direction":"send", "regex":r"^\$T([0-9a-fA-F]{2}).*#[0-9a-fA-F]{2}$", "capture":{ 1:"hex_exit_code"} },
             ], True)
 
         context = self.expect_gdbremote_sequence()
         self.assertIsNotNone(context)
 
         hex_exit_code = context.get("hex_exit_code")
         self.assertIsNotNone(hex_exit_code)
-        self.assertEquals(int(hex_exit_code, 16), signal.SIGABRT)
+        self.assertEquals(int(hex_exit_code, 16),
+                          lldbutil.get_signal_number('SIGABRT'))
 
     @debugserver_test
     @dsym_test
     def test_inferior_abort_received_debugserver_dsym(self):
         self.init_debugserver_test()
         self.buildDsym()
         self.inferior_abort_received()
 
     @llgs_test
     @dwarf_test
     @skipIfTargetAndroid(api_levels=[16]) # abort() on API 16 raises SIGSEGV!
     def test_inferior_abort_received_llgs_dwarf(self):
         self.init_llgs_test()
         self.buildDwarf()
         self.inferior_abort_received()
 

test/tools/lldb-server/inferior-crash/TestGdbRemoteSegFault.py

def test_inferior_seg_fault_received_debugserver_dsym(self):
         self.buildDsym()
         self.inferior_seg_fault_received(self.GDB_REMOTE_STOP_CODE_BAD_ACCESS)
 
     @llgs_test
     @dwarf_test
     def test_inferior_seg_fault_received_llgs_dwarf(self):
         self.init_llgs_test()
         self.buildDwarf()
-        self.inferior_seg_fault_received(signal.SIGSEGV)
+        self.inferior_seg_fault_received(lldbutil.get_signal_number('SIGSEGV'))