1eeeab82c6
Any time we see the pattern `assertEqual(value, bool)`, we can replace
that with `assert<bool>(value)`. Likewise for `assertNotEqual`.
Technically this relaxes the test a bit, as we may want to make sure
`value` is either `True` or `False`, and not something that implicitly
converts to a bool. For example, `assertEqual("foo", True)` will fail,
but `assertTrue("foo")` will not. In most cases, this distinction is not
important.
There are two such places that this patch does **not** transform, since
it seems intentional that we want the result to be a bool:
*
5daf2001a1/lldb/test/API/python_api/sbstructureddata/TestStructuredDataAPI.py (L90)
*
5daf2001a1/lldb/test/API/commands/settings/TestSettings.py (L940)
Followup to 9c2468821e. I patched `teyit`
with a `visit_assertEqual` node handler to generate this.
107 lines
4.0 KiB
Python
107 lines
4.0 KiB
Python
"""
|
|
Test that --allow-jit=false does disallow JITting:
|
|
"""
|
|
|
|
|
|
import lldb
|
|
import lldbsuite.test.lldbutil as lldbutil
|
|
from lldbsuite.test.lldbtest import *
|
|
from lldbsuite.test.decorators import *
|
|
|
|
|
|
class TestAllowJIT(TestBase):
|
|
# If your test case doesn't stress debug info, then
|
|
# set this to true. That way it won't be run once for
|
|
# each debug info format.
|
|
NO_DEBUG_INFO_TESTCASE = True
|
|
|
|
def test_allow_jit_expr_command(self):
|
|
"""Test the --allow-jit command line flag"""
|
|
self.build()
|
|
self.main_source_file = lldb.SBFileSpec("main.c")
|
|
self.expr_cmd_test()
|
|
|
|
def test_allow_jit_options(self):
|
|
"""Test the SetAllowJIT SBExpressionOption setting"""
|
|
self.build()
|
|
self.main_source_file = lldb.SBFileSpec("main.c")
|
|
self.expr_options_test()
|
|
|
|
def expr_cmd_test(self):
|
|
(target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(
|
|
self, "Set a breakpoint here", self.main_source_file
|
|
)
|
|
|
|
frame = thread.GetFrameAtIndex(0)
|
|
|
|
# First make sure we can call the function with
|
|
interp = self.dbg.GetCommandInterpreter()
|
|
self.expect("expr --allow-jit 1 -- call_me(10)", substrs=["(int) $", "= 18"])
|
|
# Now make sure it fails with the "can't IR interpret message" if allow-jit is false:
|
|
self.expect(
|
|
"expr --allow-jit 0 -- call_me(10)",
|
|
error=True,
|
|
substrs=["Can't evaluate the expression without a running target"],
|
|
)
|
|
|
|
def expr_options_test(self):
|
|
(target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(
|
|
self, "Set a breakpoint here", self.main_source_file
|
|
)
|
|
|
|
frame = thread.GetFrameAtIndex(0)
|
|
|
|
# First make sure we can call the function with the default option set.
|
|
options = lldb.SBExpressionOptions()
|
|
# Check that the default is to allow JIT:
|
|
self.assertTrue(options.GetAllowJIT(), "Default is true")
|
|
|
|
# Now use the options:
|
|
result = frame.EvaluateExpression("call_me(10)", options)
|
|
self.assertSuccess(result.GetError())
|
|
self.assertEqual(result.GetValueAsSigned(), 18, "got the right value.")
|
|
|
|
# Now disallow JIT and make sure it fails:
|
|
options.SetAllowJIT(False)
|
|
# Check that we got the right value:
|
|
self.assertFalse(options.GetAllowJIT(), "Got False after setting to False")
|
|
|
|
# Again use it and ensure we fail:
|
|
result = frame.EvaluateExpression("call_me(10)", options)
|
|
self.assertTrue(result.GetError().Fail(), "expression failed with no JIT")
|
|
self.assertIn(
|
|
"Can't evaluate the expression without a running target",
|
|
result.GetError().GetCString(),
|
|
"Got right error",
|
|
)
|
|
|
|
# Finally set the allow JIT value back to true and make sure that works:
|
|
options.SetAllowJIT(True)
|
|
self.assertTrue(options.GetAllowJIT(), "Set back to True correctly")
|
|
|
|
# And again, make sure this works:
|
|
result = frame.EvaluateExpression("call_me(10)", options)
|
|
self.assertSuccess(result.GetError())
|
|
self.assertEqual(result.GetValueAsSigned(), 18, "got the right value.")
|
|
|
|
def test_allow_jit_with_top_level(self):
|
|
"""Test combined --allow-jit and --top-level flags"""
|
|
# Can't force interpreting for top-level expressions which are always
|
|
# injected.
|
|
self.expect(
|
|
"expr --allow-jit false --top-level -- int i;",
|
|
error=True,
|
|
substrs=["Can't disable JIT compilation for top-level expressions."],
|
|
)
|
|
|
|
self.build()
|
|
lldbutil.run_to_source_breakpoint(
|
|
self, "Set a breakpoint here", lldb.SBFileSpec("main.c")
|
|
)
|
|
# Allowing JITing for top-level expressions is redundant but should work.
|
|
self.expect(
|
|
"expr --allow-jit true --top-level -- int top_level_f() { return 2; }"
|
|
)
|
|
# Make sure we actually declared a working top-level function.
|
|
self.expect_expr("top_level_f()", result_value="2")
|