135 lines
6.9 KiB
Python
135 lines
6.9 KiB
Python
import lldb
|
|
from lldbsuite.test.lldbtest import *
|
|
from lldbsuite.test import lldbutil
|
|
from lldbsuite.test.decorators import *
|
|
|
|
class TestProcessHandle(TestBase):
|
|
|
|
@no_debug_info_test
|
|
@skipIfWindows
|
|
def test_process_handle(self):
|
|
"""Test that calling process handle before we have a target, and before we
|
|
have a process will affect the process. Also that the signal settings
|
|
are preserved on rerun."""
|
|
self.build()
|
|
|
|
# Make sure we don't accept signal values by signo with no process - we don't know what the
|
|
# mapping will be so we can't do the right thing with bare numbers:
|
|
lldbutil.set_actions_for_signal(self, "9", "true", None, None, expect_success=False)
|
|
|
|
# First, I need a reference value so I can see whether changes actually took:
|
|
(target, process, _, bkpt) = lldbutil.run_to_source_breakpoint(self, '// break here', lldb.SBFileSpec("main.cpp"))
|
|
(default_pass, default_stop, default_notify) = lldbutil.get_actions_for_signal(self, "SIGSEGV")
|
|
|
|
# Let's change the value here, then exit and make sure the changed value sticks:
|
|
new_value = "false"
|
|
if default_pass == "true":
|
|
new_value = "false"
|
|
|
|
# First make sure we get an error for bogus values when running:
|
|
lldbutil.set_actions_for_signal(self, "NOTSIGSEGV", new_value, None, None, expect_success=False)
|
|
|
|
# Then set the one we intend to change.
|
|
lldbutil.set_actions_for_signal(self, "SIGSEGV", new_value, None, None)
|
|
|
|
process.Continue()
|
|
|
|
self.assertState(process.GetState(), lldb.eStateExited)
|
|
self.assertEqual(process.GetExitStatus(), 0)
|
|
|
|
# Check that we preserved the setting:
|
|
(curr_pass, curr_stop, curr_notify) = lldbutil.get_actions_for_signal(self, "SIGSEGV",from_target=True)
|
|
self.assertEqual(curr_pass, new_value, "Pass was set correctly")
|
|
self.assertEqual(curr_stop, "not set", "Stop was not set by us")
|
|
self.assertEqual(curr_notify, "not set", "Notify was not set by us")
|
|
|
|
# Run again and make sure that we prime the new process with these settings:
|
|
process = lldbutil.run_to_breakpoint_do_run(self, target, bkpt)
|
|
|
|
# We check the process settings now, to see what got copied into the process:
|
|
(curr_pass, curr_stop, curr_notify) = lldbutil.get_actions_for_signal(self, "SIGSEGV")
|
|
self.assertEqual(curr_pass, new_value, "Pass was set correctly")
|
|
self.assertEqual(curr_stop, default_stop, "Stop was its default value")
|
|
self.assertEqual(curr_notify, default_notify, "Notify was its default value")
|
|
|
|
# Now kill this target, set the handling and make sure the values get copied from the dummy into the new target.
|
|
success = self.dbg.DeleteTarget(target)
|
|
self.assertTrue(success, "Deleted the target")
|
|
self.assertEqual(self.dbg.GetNumTargets(), 0, "We did delete all the targets.")
|
|
|
|
# The signal settings should be back at their default - we were only setting this on the target:
|
|
lldbutil.get_actions_for_signal(self, "SIGSEGV", from_target=True, expected_absent=True)
|
|
# Set a valid one:
|
|
lldbutil.set_actions_for_signal(self, "SIGSEGV", new_value, None, None)
|
|
# Set a bogus one - we don't have a way to check pre-run so this is allowed
|
|
# but we should get an error message when launching:
|
|
lldbutil.set_actions_for_signal(self, "SIGNOTSIG", new_value, None, None)
|
|
|
|
out_filename = self.getBuildArtifact('output')
|
|
success = True
|
|
try:
|
|
f = open(out_filename, 'w')
|
|
except:
|
|
success = False
|
|
|
|
if not success:
|
|
self.fail("Couldn't open error output file for writing.")
|
|
|
|
self.dbg.SetErrorFileHandle(f, False)
|
|
# Now make a new process and make sure the right values got copied into the new target
|
|
(target, process, _, bkpt) = lldbutil.run_to_source_breakpoint(self, '// break here', lldb.SBFileSpec("main.cpp"))
|
|
f.write("TESTPATTERN\n")
|
|
f.flush()
|
|
f.close()
|
|
|
|
try:
|
|
f = open(out_filename, 'r')
|
|
except:
|
|
success = False
|
|
|
|
if not success:
|
|
self.fail("Couldn't open error output file for reading")
|
|
errors = f.read()
|
|
f.close()
|
|
|
|
self.assertIn("SIGNOTSIG", errors, "We warned about the unset signal")
|
|
# Also make sure we didn't accidentally add this bogus setting to the process.
|
|
lldbutil.set_actions_for_signal(self, "SIGNOTSIG", "true", "true", "true", expect_success=False)
|
|
|
|
# Check that they went into the target:
|
|
(curr_pass, curr_stop, curr_notify) = lldbutil.get_actions_for_signal(self, "SIGSEGV",from_target=True)
|
|
self.assertEqual(curr_pass, new_value, "Pass was set correctly")
|
|
self.assertEqual(curr_stop, "not set", "Stop was not set by us")
|
|
self.assertEqual(curr_notify, "not set", "Notify was not set by us")
|
|
|
|
# And the process:
|
|
# Check that they went into the target:
|
|
(curr_pass, curr_stop, curr_notify) = lldbutil.get_actions_for_signal(self, "SIGSEGV")
|
|
self.assertEqual(curr_pass, new_value, "Pass was set correctly")
|
|
self.assertEqual(curr_stop, default_stop, "Stop was its default value")
|
|
self.assertEqual(curr_notify, default_notify, "Notify was its default value")
|
|
|
|
# Now clear the handling, and make sure that we get the right signal values again:
|
|
self.runCmd("process handle -c SIGSEGV")
|
|
# Check that there is no longer configuration for SIGSEGV in the target:
|
|
lldbutil.get_actions_for_signal(self, "SIGSEGV",from_target=True, expected_absent=True)
|
|
# Make a new process, to make sure we did indeed reset the values:
|
|
(target, process, _, bkpt) = lldbutil.run_to_source_breakpoint(self, '// break here', lldb.SBFileSpec("main.cpp"))
|
|
(curr_pass, curr_stop, curr_notify) = lldbutil.get_actions_for_signal(self, "SIGSEGV")
|
|
self.assertEqual(curr_pass, new_value, "Pass was set correctly")
|
|
self.assertEqual(curr_stop, default_stop, "Stop was its default value")
|
|
self.assertEqual(curr_notify, default_notify, "Notify was its default value")
|
|
|
|
# Finally remove this from the dummy target as well, and make sure it was cleared from there:
|
|
self.runCmd("process handle -c -d SIGSEGV")
|
|
error = process.Kill()
|
|
self.assertSuccess(error, "Killed the process")
|
|
success = self.dbg.DeleteTarget(target)
|
|
self.assertTrue(success, "Destroyed the target.")
|
|
|
|
(target, process, _, bkpt) = lldbutil.run_to_source_breakpoint(self, '// break here', lldb.SBFileSpec("main.cpp"))
|
|
(curr_pass, curr_stop, curr_notify) = lldbutil.get_actions_for_signal(self, "SIGSEGV")
|
|
self.assertEqual(curr_pass, default_pass, "Pass was set correctly")
|
|
self.assertEqual(curr_stop, default_stop, "Stop was its default value")
|
|
self.assertEqual(curr_notify, default_notify, "Notify was its default value")
|