[lldb] Use assertIn/NotIn over assertTrue/False (NFC)

[kastiglione]

Summary

For improved failure messages, use assertIn over assertTrue.

[JDevlieghere]

LGTM

lldb/test/API/commands/expression/dont_allow_jit/TestAllowJIT.py

def expr_options_test(self):
         # Now disallow JIT and make sure it fails:
         options.SetAllowJIT(False)
         # Check that we got the right value:
         self.assertEqual(options.GetAllowJIT(), False, "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.assertTrue("Can't evaluate the expression without a running target" in result.GetError().GetCString(), "Got right error")
+        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.assertEqual(options.GetAllowJIT(), True, "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.")
 

lldb/test/API/commands/frame/var/TestFrameVar.py

def do_test(self):
         frame = threads[0].GetFrameAtIndex(0)
         command_result = lldb.SBCommandReturnObject()
         interp = self.dbg.GetCommandInterpreter()
 
         # Just get args:
         result = interp.HandleCommand("frame var -l", command_result)
         self.assertEqual(result, lldb.eReturnStatusSuccessFinishResult, "frame var -a didn't succeed")
         output = command_result.GetOutput()
-        self.assertTrue("argc" in output, "Args didn't find argc")
-        self.assertTrue("argv" in output, "Args didn't find argv")
-        self.assertTrue("test_var" not in output, "Args found a local")
-        self.assertTrue("g_var" not in output, "Args found a global")
+        self.assertIn("argc", output, "Args didn't find argc")
+        self.assertIn("argv", output, "Args didn't find argv")
+        self.assertNotIn("test_var", output, "Args found a local")
+        self.assertNotIn("g_var", output, "Args found a global")
 
         # Just get locals:
         result = interp.HandleCommand("frame var -a", command_result)
         self.assertEqual(result, lldb.eReturnStatusSuccessFinishResult, "frame var -a didn't succeed")
         output = command_result.GetOutput()
-        self.assertTrue("argc" not in output, "Locals found argc")
-        self.assertTrue("argv" not in output, "Locals found argv")
-        self.assertTrue("test_var" in output, "Locals didn't find test_var")
-        self.assertTrue("g_var" not in output, "Locals found a global")
+        self.assertNotIn("argc", output, "Locals found argc")
+        self.assertNotIn("argv", output, "Locals found argv")
+        self.assertIn("test_var", output, "Locals didn't find test_var")
+        self.assertNotIn("g_var", output, "Locals found a global")
 
         # Get the file statics:
         result = interp.HandleCommand("frame var -l -a -g", command_result)
         self.assertEqual(result, lldb.eReturnStatusSuccessFinishResult, "frame var -a didn't succeed")
         output = command_result.GetOutput()
-        self.assertTrue("argc" not in output, "Globals found argc")
-        self.assertTrue("argv" not in output, "Globals found argv")
-        self.assertTrue("test_var" not in output, "Globals found test_var")
-        self.assertTrue("g_var" in output, "Globals didn't find g_var")
+        self.assertNotIn("argc", output, "Globals found argc")
+        self.assertNotIn("argv", output, "Globals found argv")
+        self.assertNotIn("test_var", output, "Globals found test_var")
+        self.assertIn("g_var", output, "Globals didn't find g_var")
 
 
 

lldb/test/API/functionalities/breakpoint/breakpoint_names/TestBreakpointNames.py

def do_check_configuring_names(self):
         new_help = "I do something even more interesting"
         cl_name.SetHelpString(new_help)
         self.assertEqual(new_help, cl_name.GetHelpString(), "SetHelpString didn't")
 
         # We should have three names now, make sure the target can list them:
         name_list = lldb.SBStringList()
         self.target.GetBreakpointNames(name_list)
         for name_string in [self.bp_name_string, other_bp_name_string, cl_bp_name_string]:
-            self.assertTrue(name_string in name_list, "Didn't find %s in names"%(name_string))
+            self.assertIn(name_string, name_list, "Didn't find %s in names"%(name_string))
 
         # Delete the name from the current target.  Make sure that works and deletes the
         # name from the breakpoint as well:
         self.target.DeleteBreakpointName(self.bp_name_string)
         name_list.Clear()
         self.target.GetBreakpointNames(name_list)
-        self.assertTrue(self.bp_name_string not in name_list, "Didn't delete %s from a real target"%(self.bp_name_string))
+        self.assertNotIn(self.bp_name_string, name_list, "Didn't delete %s from a real target"%(self.bp_name_string))
         # Also make sure the name got removed from breakpoints holding it:
         self.assertFalse(bkpt.MatchesName(self.bp_name_string), "Didn't remove the name from the breakpoint.")
 
         # Test that deleting the name we injected into the dummy target works (there's also a
         # cleanup that will do this, but that won't test the result...
         dummy_target = self.dbg.GetDummyTarget()
         dummy_target.DeleteBreakpointName(self.bp_name_string)
         name_list.Clear()
         dummy_target.GetBreakpointNames(name_list)
-        self.assertTrue(self.bp_name_string not in name_list, "Didn't delete %s from the dummy target"%(self.bp_name_string))
+        self.assertNotIn(self.bp_name_string, name_list, "Didn't delete %s from the dummy target"%(self.bp_name_string))
         # Also make sure the name got removed from breakpoints holding it:
         self.assertFalse(bkpt.MatchesName(self.bp_name_string), "Didn't remove the name from the breakpoint.")
 
     def check_permission_results(self, bp_name):
         self.assertEqual(bp_name.GetAllowDelete(), False, "Didn't set allow delete.")
         protected_bkpt = self.target.BreakpointCreateByLocation(self.main_file_spec, 10)
         protected_id = protected_bkpt.GetID()
 

lldb/test/API/functionalities/breakpoint/debugbreak/TestDebugBreak.py

def test_asm_int_3(self):
         thread = lldbutil.get_stopped_thread(process, stop_reason)
         self.assertIsNotNone(
             thread, "Unable to find thread stopped at the __debugbreak()")
         frame = thread.GetFrameAtIndex(0)
 
         # We should be in funciton 'bar'.
         self.assertTrue(frame.IsValid())
         function_name = frame.GetFunctionName()
-        self.assertTrue('bar' in function_name,
-                        "Unexpected function name {}".format(function_name))
+        self.assertIn('bar', function_name,
 
         # We should be able to evaluate the parameter foo.
         value = frame.EvaluateExpression('*foo')
         self.assertEqual(value.GetValueAsSigned(), 42)
 
         # The counter should be 1 at the first stop and increase by 2 for each
         # subsequent stop.
         counter = 1
         while counter < 20:
             value = frame.EvaluateExpression('count')
             self.assertEqual(value.GetValueAsSigned(), counter)
             counter += 2
             process.Continue()
 
         # The inferior should exit after the last iteration.
         self.assertEqual(process.GetState(), lldb.eStateExited)

lldb/test/API/functionalities/data-formatter/data-formatter-stl/libcxx/queue/TestDataFormatterLibcxxQueue.py

def setUp(self):
         TestBase.setUp(self)
         self.namespace = 'std'
 
     def check_variable(self, name):
         var = self.frame().FindVariable(name)
         self.assertTrue(var.IsValid())
 
         queue = self.namespace + '::queue'
-        self.assertTrue(queue in var.GetDisplayTypeName())
+        self.assertIn(queue, var.GetDisplayTypeName())
         self.assertEqual(var.GetNumChildren(), 5)
         for i in range(5):
             ch = var.GetChildAtIndex(i)
             self.assertTrue(ch.IsValid())
             self.assertEqual(ch.GetValueAsSigned(), i+1)
 
     @expectedFailureAll(bugnumber="llvm.org/pr36109", debug_info="gmodules", triple=".*-android")
     @add_test_categories(["libc++"])
     def test(self):
         """Test that std::queue is displayed correctly"""
         self.build()
         lldbutil.run_to_source_breakpoint(self, '// break here',
                 lldb.SBFileSpec("main.cpp", False))
 
         self.check_variable('q1')
         self.check_variable('q2')

lldb/test/API/functionalities/gdb_remote_client/TestGDBRemoteClient.py

class TestGDBRemoteClient(GDBRemoteTestBase):
     def test_read_registers_using_p_packets(self):
         """Test reading registers using 'p' packets"""
         self.dbg.HandleCommand(
                 "settings set plugin.process.gdb-remote.use-g-packet-for-reading false")
         target = self.createTarget("a.yaml")
         process = self.connect(target)
 
         self.read_registers(process)
-        self.assertFalse("g" in self.server.responder.packetLog)
+        self.assertNotIn("g", self.server.responder.packetLog)
         self.assertGreater(
                 len([p for p in self.server.responder.packetLog if p.startswith("p")]), 0)
 
     @skipIfReproducer # Packet log is not populated during replay.
     def test_write_registers_using_P_packets(self):
         """Test writing registers using 'P' packets (default behavior)"""
         self.server.responder = self.gPacketResponder()
         target = self.createTarget("a.yaml")

lldb/test/API/functionalities/history/TestHistoryRecall.py

class TestHistoryRecall(TestBase):
     def sample_test(self):
         interp = self.dbg.GetCommandInterpreter()
         result = lldb.SBCommandReturnObject()
         interp.HandleCommand("session history", result, True)
         interp.HandleCommand("platform list", result, True)
 
         interp.HandleCommand("!0", result, False)
         self.assertTrue(result.Succeeded(), "!0 command did not work: %s"%(result.GetError()))
-        self.assertTrue("session history" in result.GetOutput(), "!0 didn't rerun session history")
+        self.assertIn("session history", result.GetOutput(), "!0 didn't rerun session history")
 
         interp.HandleCommand("!-1", result, False)
         self.assertTrue(result.Succeeded(), "!-1 command did not work: %s"%(result.GetError()))
-        self.assertTrue("host:" in result.GetOutput(), "!-1 didn't rerun platform list.")
+        self.assertIn("host:", result.GetOutput(), "!-1 didn't rerun platform list.")

lldb/test/API/functionalities/plugins/python_os_plugin/stepping_plugin_threads/TestOSPluginStepping.py

def run_python_os_step_missing_thread(self, do_prune):
             self.assertEqual(self.process.GetState(), lldb.eStateExited, "We exited.")
         else:
             # Now we are going to continue, and when we hit the step-out breakpoint, we will
             # put the OS plugin thread back, lldb will recover its ThreadPlanStack, and
             # we will stop with a "step-out" reason.
             self.process.Continue()
             os_thread = self.get_os_thread()
             self.assertTrue(os_thread.IsValid(), "The OS thread is back after continue")
-            self.assertTrue("step out" in os_thread.GetStopDescription(100), "Completed step out plan")
+            self.assertIn("step out", os_thread.GetStopDescription(100), "Completed step out plan")
         
         

lldb/test/API/functionalities/postmortem/minidump-new/TestMiniDumpNew.py

def test_memory_region_name(self):
             ("0x40169000", "/system/lib/libc.so"),
         ]
         ci = self.dbg.GetCommandInterpreter()
         for (addr, region_name) in addr_region_name_pairs:
             command = 'memory region ' + addr
             ci.HandleCommand(command, result, False)
             message = 'Ensure memory "%s" shows up in output for "%s"' % (
                 region_name, command)
-            self.assertTrue(region_name in result.GetOutput(), message)
+            self.assertIn(region_name, result.GetOutput(), message)
 
     def test_thread_info_in_minidump(self):
         """Test that lldb can read the thread information from the Minidump."""
         self.process_from_yaml("linux-x86_64.yaml")
         self.check_state()
         # This process crashed due to a segmentation fault in its
         # one and only thread.
         self.assertEqual(self.process.GetNumThreads(), 1)
         thread = self.process.GetThreadAtIndex(0)
         self.assertEqual(thread.GetStopReason(), lldb.eStopReasonSignal)
         stop_description = thread.GetStopDescription(256)
-        self.assertTrue("SIGSEGV" in stop_description)
+        self.assertIn("SIGSEGV", stop_description)
 
     def test_stack_info_in_minidump(self):
         """Test that we can see a trivial stack in a breakpad-generated Minidump."""
         # target create linux-x86_64 -c linux-x86_64.dmp
         self.dbg.CreateTarget("linux-x86_64")
         self.target = self.dbg.GetSelectedTarget()
         self.process = self.target.LoadCore("linux-x86_64.dmp")
         self.check_state()
def do_test_deeper_stack(self, binary, core, pid):
         self.assertEqual(process.GetProcessID(), pid)
 
         expected_stack = {1: 'bar', 2: 'foo', 3: '_start'}
         self.assertGreaterEqual(thread.GetNumFrames(), len(expected_stack))
         for index, name in iteritems(expected_stack):
             frame = thread.GetFrameAtIndex(index)
             self.assertTrue(frame.IsValid())
             function_name = frame.GetFunctionName()
-            self.assertTrue(name in function_name)
+            self.assertIn(name, function_name)
 
     @skipIfLLVMTargetMissing("X86")
     def test_deeper_stack_in_minidump(self):
         """Test that we can examine a more interesting stack in a Minidump."""
         # Launch with the Minidump, and inspect the stack.
         # target create linux-x86_64_not_crashed -c linux-x86_64_not_crashed.dmp
         self.do_test_deeper_stack("linux-x86_64_not_crashed",
                                   "linux-x86_64_not_crashed.dmp",

lldb/test/API/functionalities/postmortem/minidump/TestMiniDump.py

def test_thread_info_in_mini_dump(self):
         self.target = self.dbg.GetSelectedTarget()
         self.process = self.target.LoadCore("fizzbuzz_no_heap.dmp")
         # This process crashed due to an access violation (0xc0000005) in its
         # one and only thread.
         self.assertEqual(self.process.GetNumThreads(), 1)
         thread = self.process.GetThreadAtIndex(0)
         self.assertEqual(thread.GetStopReason(), lldb.eStopReasonException)
         stop_description = thread.GetStopDescription(256)
-        self.assertTrue("0xc0000005" in stop_description)
+        self.assertIn("0xc0000005", stop_description)
 
     def test_modules_in_mini_dump(self):
         """Test that lldb can read the list of modules from the minidump."""
         # target create -c fizzbuzz_no_heap.dmp
         self.dbg.CreateTarget("")
         self.target = self.dbg.GetSelectedTarget()
         self.process = self.target.LoadCore("fizzbuzz_no_heap.dmp")
         self.assertTrue(self.process, PROCESS_IS_VALID)
def test_deeper_stack_in_mini_dump(self):
             thread = process.GetThreadAtIndex(0)
 
             expected_stack = {0: 'bar', 1: 'foo', 2: 'main'}
             self.assertGreaterEqual(thread.GetNumFrames(), len(expected_stack))
             for index, name in iteritems(expected_stack):
                 frame = thread.GetFrameAtIndex(index)
                 self.assertTrue(frame.IsValid())
                 function_name = frame.GetFunctionName()
-                self.assertTrue(name in function_name)
+                self.assertIn(name, function_name)
 
         finally:
             # Clean up the mini dump file.
             self.assertTrue(self.dbg.DeleteTarget(target))
             if (os.path.isfile(core)):
                 os.unlink(core)
 
     @skipUnlessWindows # Minidump saving works only on windows

lldb/test/API/functionalities/process_save_core/TestProcessSaveCore.py

def test_save_windows_mini_dump(self):
             process = target.LoadCore(core)
             files = [
                 target.GetModuleAtIndex(i).GetFileSpec() for i in range(
                     0, target.GetNumModules())]
             paths = [
                 os.path.join(
                     f.GetDirectory(),
                     f.GetFilename()) for f in files]
-            self.assertTrue(exe in paths)
+            self.assertIn(exe, paths)
 
         finally:
             # Clean up the mini dump file.
             self.assertTrue(self.dbg.DeleteTarget(target))
             if (os.path.isfile(core)):
                 os.unlink(core)

lldb/test/API/functionalities/source-map/TestTargetSourceMap.py

def test_source_map(self):
                             "make sure breakpoint was resolved with map")
 
             # Now make sure that we can actually FIND the source file using this
             # remapping:
             retval = lldb.SBCommandReturnObject()
             self.dbg.GetCommandInterpreter().HandleCommand("source list -f main.c -l 2", retval)
             self.assertTrue(retval.Succeeded(), "source list didn't succeed.")
             self.assertNotEqual(retval.GetOutput(), None, "We got no ouput from source list")
-            self.assertTrue("return" in retval.GetOutput(), "We didn't find the source file...")
+            self.assertIn("return", retval.GetOutput(), "We didn't find the source file...")
 
         # Set the target soure map to map "./" to the current test directory
         src_dir = self.getSourceDir()
         src_path = os.path.join(src_dir, "main.c")
         yaml_path = os.path.join(src_dir, "a.yaml")
         yaml_base, ext = os.path.splitext(yaml_path)
         obj_path = self.getBuildArtifact("main.o")
         self.yaml2obj(yaml_path, obj_path)

lldb/test/API/functionalities/stats_api/TestStatisticsAPI.py

def test_stats_api(self):
         self.assertFalse(target.GetCollectingStats())
 
         # Test the function to get the statistics in JSON'ish.
         stats = target.GetStatistics()
         stream = lldb.SBStream()
         res = stats.GetAsJSON(stream)
         stats_json = sorted(json.loads(stream.GetData()))
         self.assertEqual(len(stats_json), 4)
-        self.assertTrue("Number of expr evaluation failures" in stats_json)
-        self.assertTrue("Number of expr evaluation successes" in stats_json)
-        self.assertTrue("Number of frame var failures" in stats_json)
-        self.assertTrue("Number of frame var successes" in stats_json)
+        self.assertIn("Number of expr evaluation failures", stats_json)
+        self.assertIn("Number of expr evaluation successes", stats_json)
+        self.assertIn("Number of frame var failures", stats_json)
+        self.assertIn("Number of frame var successes", stats_json)

lldb/test/API/functionalities/step_scripted/TestStepScripted.py

def test_misspelled_plan_name(self):
                                                                             self.main_source_file)
         stop_id = process.GetStopID()
         # Pass a non-existent class for the plan class:
         err = thread.StepUsingScriptedThreadPlan("NoSuchModule.NoSuchPlan")
         
         # Make sure we got a good error:
         self.assertTrue(err.Fail(), "We got a failure state")
         msg = err.GetCString()
-        self.assertTrue("NoSuchModule.NoSuchPlan" in msg, "Mentioned missing class")
+        self.assertIn("NoSuchModule.NoSuchPlan", msg, "Mentioned missing class")
         
         # Make sure we didn't let the process run:
         self.assertEqual(stop_id, process.GetStopID(), "Process didn't run")
         
     def test_checking_variable(self):
         """Test that we can call SBValue API's from a scripted thread plan - using SBAPI's to step"""
         self.do_test_checking_variable(False)
         

lldb/test/API/functionalities/tail_call_frames/cross_dso/TestCrossDSOTailCalls.py

def test_cross_dso_tail_calls(self):
                 ("tail_called_in_b_from_a", True),
                 ("helper_in_a", True),
                 ("tail_called_in_a_from_main", False),
                 ("helper", True),
                 ("main", False)
         ]
         for idx, (name, is_artificial) in enumerate(expected_frames):
             frame = thread.GetFrameAtIndex(idx)
-            self.assertTrue(name in frame.GetDisplayFunctionName())
+            self.assertIn(name, frame.GetDisplayFunctionName())
             self.assertEqual(frame.IsArtificial(), is_artificial)

lldb/test/API/functionalities/tail_call_frames/cross_object/TestCrossObjectTailCalls.py

def test_cross_object_tail_calls(self):
                 ("tail_called_in_b_from_a", True),
                 ("helper_in_a", True),
                 ("tail_called_in_a_from_main", False),
                 ("helper", True),
                 ("main", False)
         ]
         for idx, (name, is_artificial) in enumerate(expected_frames):
             frame = thread.GetFrameAtIndex(idx)
-            self.assertTrue(name in frame.GetDisplayFunctionName())
+            self.assertIn(name, frame.GetDisplayFunctionName())
             self.assertEqual(frame.IsArtificial(), is_artificial)

lldb/test/API/functionalities/tail_call_frames/sbapi_support/TestTailCallFrameSBAPI.py

def do_test(self):
         artificiality = [False, True, False, True, False]
         for idx, (name, is_artificial) in enumerate(zip(names, artificiality)):
             frame = thread.GetFrameAtIndex(idx)
 
             # Use a relaxed substring check because function dislpay names are
             # platform-dependent. E.g we see "void sink(void)" on Windows, but
             # "sink()" on Darwin. This seems like a bug -- just work around it
             # for now.
-            self.assertTrue(name in frame.GetDisplayFunctionName())
+            self.assertIn(name, frame.GetDisplayFunctionName())
             self.assertEqual(frame.IsArtificial(), is_artificial)

lldb/test/API/functionalities/tsan/basic/TestTsanBasic.py

def tsan_tests(self):
             "image lookup -n __tsan_get_current_report",
             "__tsan_get_current_report should be present",
             substrs=['1 match found'])
 
         # We should be stopped in __tsan_on_report
         process = self.dbg.GetSelectedTarget().process
         thread = process.GetSelectedThread()
         frame = thread.GetSelectedFrame()
-        self.assertTrue("__tsan_on_report" in frame.GetFunctionName())
+        self.assertIn("__tsan_on_report", frame.GetFunctionName())
 
         # The stopped thread backtrace should contain either line1 or line2
         # from main.c.
         found = False
         for i in range(0, thread.GetNumFrames()):
             frame = thread.GetFrameAtIndex(i)
             if frame.GetLineEntry().GetFileSpec().GetFilename() == "main.c":
                 if frame.GetLineEntry().GetLine() == self.line_thread1:

lldb/test/API/functionalities/ubsan/basic/TestUbsanBasic.py

def ubsan_tests(self):
 
         # test that the UBSan dylib is present
         self.expect(
             "image lookup -n __ubsan_on_report",
             "__ubsan_on_report should be present",
             substrs=['1 match found'])
 
         # We should be stopped in __ubsan_on_report
-        self.assertTrue("__ubsan_on_report" in frame.GetFunctionName())
+        self.assertIn("__ubsan_on_report", frame.GetFunctionName())
 
         # The stopped thread backtrace should contain either 'align line'
         found = False
         for i in range(thread.GetNumFrames()):
             frame = thread.GetFrameAtIndex(i)
             if frame.GetLineEntry().GetFileSpec().GetFilename() == "main.c":
                 if frame.GetLineEntry().GetLine() == self.line_align:
                     found = True

lldb/test/API/lang/c/vla/TestVLA.py

def test_variable_list(self):
         var_opts.SetIncludeArguments(False)
         var_opts.SetIncludeLocals(True)
         var_opts.SetInScopeOnly(True)
         var_opts.SetIncludeStatics(False)
         var_opts.SetIncludeRuntimeSupportValues(False)
         var_opts.SetUseDynamic(lldb.eDynamicCanRunTarget)
         all_locals = self.frame().GetVariables(var_opts)
         for value in all_locals:
-            self.assertFalse("vla_expr" in value.name)
+            self.assertNotIn("vla_expr", value.name)
 
     @decorators.skipIf(compiler="clang", compiler_version=['<', '8.0'])
     def test_vla(self):
         self.build()
         _, process, _, _ = lldbutil.run_to_source_breakpoint(
             self, "break here", lldb.SBFileSpec('main.c'))
 
         def test(a, array):

lldb/test/API/lang/cpp/accelerator-table/TestCPPAccelerator.py

def test(self):
         # Pick one from the middle of the list to have a high chance
         # of it not being in the first file looked at.
         self.expect('frame variable inner_d')
 
         log = open(logfile, 'r')
         n = 0
         for line in log:
             if re.findall(r'[abcdefg]\.o: FindByNameAndTag\(\)', line):
-                self.assertTrue("d.o" in line)
+                self.assertIn("d.o", line)
                 n += 1
 
         self.assertEqual(n, 1, log)

lldb/test/API/lang/cpp/class_static/TestStaticVariables.py

def test_with_python_api(self):
         # locals =>        False
         # statics =>       True
         # in_scope_only => False
         valList = frame.GetVariables(False, False, True, False)
 
         for val in valList:
             self.DebugSBValue(val)
             name = val.GetName()
-            self.assertTrue(name in ['g_points', 'A::g_points'])
+            self.assertIn(name, ['g_points', 'A::g_points'])
             if name == 'g_points':
                 self.assertEqual(
                     val.GetValueType(), lldb.eValueTypeVariableStatic)
                 self.assertEqual(val.GetNumChildren(), 2)
             elif name == 'A::g_points':
                 self.assertEqual(
                     val.GetValueType(), lldb.eValueTypeVariableGlobal)
                 self.assertEqual(val.GetNumChildren(), 2)

lldb/test/API/lang/cpp/class_types/TestClassTypes.py

def test_with_constructor_name(self):
         # The stop reason of the thread should be breakpoint.
         thread = lldbutil.get_stopped_thread(
             process, lldb.eStopReasonBreakpoint)
         self.assertIsNotNone(thread)
 
         frame = thread.frames[0]
         self.assertTrue(frame.IsValid(), "Got a valid frame.")
 
-        self.assertTrue("C::C" in frame.name,
-                        "Constructor name includes class name.")
+        self.assertIn("C::C", frame.name,

lldb/test/API/lang/objc/direct-dispatch-step/TestObjCDirectDispatchStepping.py

def test_with_python_api(self):
         stop_bkpt = target.BreakpointCreateBySourceRegex("// Stop Location [0-9]+", self.main_source)
         self.assertEqual(stop_bkpt.GetNumLocations(), 15)
                                                          
         # Here we step through all the overridden methods of OverridesALot
         # The last continue will get us to the call ot OverridesInit.
         for idx in range(2,16):
             thread.StepInto()
             func_name = thread.GetFrameAtIndex(0).GetFunctionName()
-            self.assertTrue("OverridesALot" in func_name, "%d'th step did not match name: %s"%(idx, func_name))
+            self.assertIn("OverridesALot", func_name, "%d'th step did not match name: %s"%(idx, func_name))
             stop_threads = lldbutil.continue_to_breakpoint(process, stop_bkpt)
             self.assertEqual(len(stop_threads), 1)
             self.assertEqual(stop_threads[0], thread)
 
         thread.StepInto()
         func_name = thread.GetFrameAtIndex(0).GetFunctionName()
         self.assertEqual(func_name, "-[OverridesInit init]", "Stopped in [OverridesInit init]")
         
 
             

lldb/test/API/lang/objc/exceptions/TestObjCExceptions.py

def test_objc_exceptions_at_throw(self):
         self.assertGreater(reserved.num_children, 0)
         callStackReturnAddresses = [reserved.GetChildAtIndex(i).GetChildAtIndex(1) for i in range(0, reserved.GetNumChildren())
                 if reserved.GetChildAtIndex(i).GetChildAtIndex(0).description == "callStackReturnAddresses"][0].dynamic
         children = [callStackReturnAddresses.GetChildAtIndex(i) for i in range(0, callStackReturnAddresses.num_children)]
 
         pcs = [i.unsigned for i in children]
         names = [target.ResolveSymbolContextForAddress(lldb.SBAddress(pc, target), lldb.eSymbolContextSymbol).GetSymbol().name for pc in pcs]
         for n in ["objc_exception_throw", "foo(int)", "main"]:
-            self.assertTrue(n in names, "%s is in the exception backtrace (%s)" % (n, names))
+            self.assertIn(n, names, "%s is in the exception backtrace (%s)" % (n, names))
 
     def test_objc_exceptions_at_abort(self):
         self.build()
 
         target = self.dbg.CreateTarget(self.getBuildArtifact("a.out"))
         self.assertTrue(target, VALID_TARGET)
 
         self.runCmd("run 0")

lldb/test/API/lang/objc/objc-checker/TestObjCCheckers.py

def test_objc_checker(self):
         self.assertTrue(expr_error.Fail())
 
         # Make sure the call produced no NSLog stdout.
         stdout = process.GetSTDOUT(100)
         self.assertTrue(stdout is None or (len(stdout) == 0))
 
         # Make sure the error is helpful:
         err_string = expr_error.GetCString()
-        self.assertTrue("selector" in err_string)
+        self.assertIn("selector", err_string)
 
         #
         # Check that we correctly insert the checker for an
         # ObjC method with the struct return convention.
         # Getting this wrong would cause us to call the checker
         # with the wrong arguments, and the checker would crash
         # So I'm just checking "expression runs successfully" here:
         #
         expr_value = frame.EvaluateExpression("[my_simple getBigStruct]", False)
         expr_error = expr_value.GetError()
         
         self.assertTrue(expr_error.Success())
         

lldb/test/API/macosx/macCatalyst/TestMacCatalyst.py

def test_macabi(self):
                               r'.*-apple-ios.*-macabi a\.out'])
         self.expect("fr v s", substrs=["Hello macCatalyst"])
         self.expect("p s", substrs=["Hello macCatalyst"])
         self.check_debugserver(log)
 
     def check_debugserver(self, log):
         """scan the debugserver packet log"""
         process_info = lldbutil.packetlog_get_process_info(log)
-        self.assertTrue('ostype' in process_info)
+        self.assertIn('ostype', process_info)
         self.assertEquals(process_info['ostype'], 'maccatalyst')
 
         aout_info = None
         dylib_info = lldbutil.packetlog_get_dylib_info(log)
         for image in dylib_info['images']:
             if image['pathname'].endswith('a.out'):
                 aout_info = image
         self.assertTrue(aout_info)
         self.assertEquals(aout_info['min_version_os_name'], 'maccatalyst')

lldb/test/API/macosx/macCatalystAppMacOSFramework/TestMacCatalystAppWithMacOSFramework.py

def test(self):
                               arch + r'.*-apple-macosx.* libfoo.dylib[^(]'])
         self.expect("fr v s", "Hello macCatalyst")
         self.expect("p s", "Hello macCatalyst")
         self.check_debugserver(log)
 
     def check_debugserver(self, log):
         """scan the debugserver packet log"""
         process_info = lldbutil.packetlog_get_process_info(log)
-        self.assertTrue('ostype' in process_info)
+        self.assertIn('ostype', process_info)
         self.assertEquals(process_info['ostype'], 'maccatalyst')
 
         aout_info = None
         libfoo_info = None
         dylib_info = lldbutil.packetlog_get_dylib_info(log)
         for image in dylib_info['images']:
             if image['pathname'].endswith('a.out'):
                 aout_info = image
             if image['pathname'].endswith('libfoo.dylib'):
                 libfoo_info = image
         self.assertTrue(aout_info)
         self.assertTrue(libfoo_info)
         self.assertEquals(aout_info['min_version_os_name'], 'maccatalyst')
         self.assertEquals(libfoo_info['min_version_os_name'], 'macosx')

lldb/test/API/macosx/simulator/TestSimulatorPlatform.py

def check_load_commands(self, expected_load_command):
         self.assertEquals(
             found, 1, "wrong number of load commands for {}".format(
                 expected_load_command))
 
 
     def check_debugserver(self, log, expected_platform, expected_version):
         """scan the debugserver packet log"""
         process_info = lldbutil.packetlog_get_process_info(log)
-        self.assertTrue('ostype' in process_info)
+        self.assertIn('ostype', process_info)
         self.assertEquals(process_info['ostype'], expected_platform)
         dylib_info = lldbutil.packetlog_get_dylib_info(log)
         self.assertTrue(dylib_info)
         aout_info = None
         for image in dylib_info['images']:
             if image['pathname'].endswith('a.out'):
                 aout_info = image
         self.assertTrue(aout_info)

lldb/test/API/tools/lldb-server/TestGdbRemoteAuxvSupport.py

def get_raw_auxv_data(self):
         self.reset_test_sequence()
         self.add_process_info_collection_packets()
 
         context = self.expect_gdbremote_sequence()
         self.assertIsNotNone(context)
 
         proc_info = self.parse_process_info_response(context)
         self.assertIsNotNone(proc_info)
-        self.assertTrue("ptrsize" in proc_info)
+        self.assertIn("ptrsize", proc_info)
         word_size = int(proc_info["ptrsize"])
 
         OFFSET = 0
         LENGTH = 0x400
 
         # Grab the auxv data.
         self.reset_test_sequence()
         self.test_sequence.add_log_lines(

lldb/test/API/tools/lldb-server/TestGdbRemoteExpeditedRegisters.py

def stop_notification_contains_generic_register(
         reg_infos = self.gather_register_infos()
 
         # Find the generic register.
         reg_info = self.find_generic_register_with_name(
             reg_infos, generic_register_name)
         self.assertIsNotNone(reg_info)
 
         # Ensure the expedited registers contained it.
-        self.assertTrue(reg_info["lldb_register_index"] in expedited_registers)
+        self.assertIn(reg_info["lldb_register_index"], expedited_registers)
         self.trace("{} reg_info:{}".format(generic_register_name, reg_info))
 
     def test_stop_notification_contains_any_registers(self):
         self.build()
         self.set_inferior_startup_launch()
 
         # Generate a stop reply, parse out expedited registers from stop
         # notification.
def test_stop_notification_contains_vg_register(self):
         reg_infos = self.gather_register_infos()
 
         # Find the vg register.
         reg_info = self.find_register_with_name_and_dwarf_regnum(
             reg_infos, 'vg', '46')
         self.assertIsNotNone(reg_info)
 
         # Ensure the expedited registers contained it.
-        self.assertTrue(reg_info["lldb_register_index"] in expedited_registers)
+        self.assertIn(reg_info["lldb_register_index"], expedited_registers)
         self.trace("{} reg_info:{}".format('vg', reg_info))

lldb/test/API/tools/lldb-server/TestGdbRemoteHostInfo.py

def parse_host_info_response(self, context):
                                                    host_info_raw)}
 
         import pprint
         print("\nqHostInfo response:")
         pprint.pprint(host_info_dict)
 
         # Validate keys are known.
         for (key, val) in list(host_info_dict.items()):
-            self.assertTrue(key in self.KNOWN_HOST_INFO_KEYS,
-                            "unknown qHostInfo key: " + key)
+            self.assertIn(key, self.KNOWN_HOST_INFO_KEYS,
             self.assertIsNotNone(val)
 
         # Return the key:val pairs.
         return host_info_dict
 
     def get_qHostInfo_response(self):
         # Launch the debug monitor stub, attaching to the inferior.
         server = self.connect_to_debug_monitor()

lldb/test/API/tools/lldb-server/TestGdbRemote_vCont.py

def vCont_supports_mode(self, mode, inferior_args=None):
         context = self.expect_gdbremote_sequence()
         self.assertIsNotNone(context)
 
         # Pull out supported modes.
         supported_vCont_modes = self.parse_vCont_query_response(context)
         self.assertIsNotNone(supported_vCont_modes)
 
         # Verify we support the given mode.
-        self.assertTrue(mode in supported_vCont_modes)
+        self.assertIn(mode, supported_vCont_modes)
 
 
     def test_vCont_supports_c(self):
         self.build()
         self.vCont_supports_mode("c")
 
     def test_vCont_supports_C(self):
         self.build()

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

def test_qRegisterInfo_contains_required_generics_debugserver(self):
         # Gather register info entries.
         reg_infos = self.parse_register_info_packets(context)
 
         # Collect all generic registers found.
         generic_regs = {
             reg_info['generic']: 1 for reg_info in reg_infos if 'generic' in reg_info}
 
         # Ensure we have a program counter register.
-        self.assertTrue('pc' in generic_regs)
+        self.assertIn('pc', generic_regs)
 
         # Ensure we have a frame pointer register. PPC64le's FP is the same as SP
         if self.getArchitecture() != 'powerpc64le':
-            self.assertTrue('fp' in generic_regs)
+            self.assertIn('fp', generic_regs)
 
         # Ensure we have a stack pointer register.
-        self.assertTrue('sp' in generic_regs)
+        self.assertIn('sp', generic_regs)
 
         # Ensure we have a flags register.
-        self.assertTrue('flags' in generic_regs)
+        self.assertIn('flags', generic_regs)
 
     def test_qRegisterInfo_contains_at_least_one_register_set(self):
         self.build()
         self.prep_debug_monitor_and_inferior()
         self.add_register_info_collection_packets()
 
         # Run the packet stream.
         context = self.expect_gdbremote_sequence()
def Hc_then_Csignal_signals_correct_thread(self, segfault_signo):
 
             context = self.expect_gdbremote_sequence()
             self.assertIsNotNone(context)
             signo = context.get("signo")
             self.assertEqual(int(signo, 16), segfault_signo)
 
             # Ensure we haven't seen this tid yet.
             thread_id = int(context.get("thread_id"), 16)
-            self.assertFalse(thread_id in signaled_tids)
+            self.assertNotIn(thread_id, signaled_tids)
             signaled_tids[thread_id] = 1
 
             # Send SIGUSR1 to the thread that signaled the SIGSEGV.
             self.reset_test_sequence()
             self.test_sequence.add_log_lines(
                 [
                     # Set the continue thread.
                     # Set current thread.
def Hc_then_Csignal_signals_correct_thread(self, segfault_signo):
             # 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)
             print_thread_id = int(print_thread_id, 16)
-            self.assertFalse(print_thread_id in print_thread_ids)
+            self.assertNotIn(print_thread_id, print_thread_ids)
 
             # Now remember this print (i.e. inferior-reflected) thread id and
             # ensure we don't hit it again.
             print_thread_ids[print_thread_id] = 1
 
             # Ensure post signal-handle thread id matches the thread that
             # initially raised the SIGSEGV.
             post_handle_thread_id = context.get("post_handle_thread_id")
def test_qMemoryRegionInfo_reports_code_address_as_executable(self):
         self.add_query_memory_region_packets(code_address)
 
         # Run the packet stream.
         context = self.expect_gdbremote_sequence()
         self.assertIsNotNone(context)
         mem_region_dict = self.parse_memory_region_packet(context)
 
         # Ensure there are no errors reported.
-        self.assertFalse("error" in mem_region_dict)
+        self.assertNotIn("error", mem_region_dict)
 
         # Ensure code address is readable and executable.
-        self.assertTrue("permissions" in mem_region_dict)
-        self.assertTrue("r" in mem_region_dict["permissions"])
-        self.assertTrue("x" in mem_region_dict["permissions"])
+        self.assertIn("permissions", mem_region_dict)
+        self.assertIn("r", mem_region_dict["permissions"])
+        self.assertIn("x", mem_region_dict["permissions"])
 
         # Ensure the start address and size encompass the address we queried.
         self.assert_address_within_memory_region(code_address, mem_region_dict)
 
     @skipIfWindows # No pty support to test any inferior output
     def test_qMemoryRegionInfo_reports_stack_address_as_rw(self):
         self.build()
         self.set_inferior_startup_launch()
def test_qMemoryRegionInfo_reports_stack_address_as_rw(self):
         self.add_query_memory_region_packets(stack_address)
 
         # Run the packet stream.
         context = self.expect_gdbremote_sequence()
         self.assertIsNotNone(context)
         mem_region_dict = self.parse_memory_region_packet(context)
 
         # Ensure there are no errors reported.
-        self.assertFalse("error" in mem_region_dict)
+        self.assertNotIn("error", mem_region_dict)
 
         # Ensure address is readable and executable.
-        self.assertTrue("permissions" in mem_region_dict)
-        self.assertTrue("r" in mem_region_dict["permissions"])
-        self.assertTrue("w" in mem_region_dict["permissions"])
+        self.assertIn("permissions", mem_region_dict)
+        self.assertIn("r", mem_region_dict["permissions"])
+        self.assertIn("w", mem_region_dict["permissions"])
 
         # Ensure the start address and size encompass the address we queried.
         self.assert_address_within_memory_region(
             stack_address, mem_region_dict)
 
     @skipIfWindows # No pty support to test any inferior output
     def test_qMemoryRegionInfo_reports_heap_address_as_rw(self):
         self.build()
def test_qMemoryRegionInfo_reports_heap_address_as_rw(self):
         self.add_query_memory_region_packets(heap_address)
 
         # Run the packet stream.
         context = self.expect_gdbremote_sequence()
         self.assertIsNotNone(context)
         mem_region_dict = self.parse_memory_region_packet(context)
 
         # Ensure there are no errors reported.
-        self.assertFalse("error" in mem_region_dict)
+        self.assertNotIn("error", mem_region_dict)
 
         # Ensure address is readable and executable.
-        self.assertTrue("permissions" in mem_region_dict)
-        self.assertTrue("r" in mem_region_dict["permissions"])
-        self.assertTrue("w" in mem_region_dict["permissions"])
+        self.assertIn("permissions", mem_region_dict)
+        self.assertIn("r", mem_region_dict["permissions"])
+        self.assertIn("w", mem_region_dict["permissions"])
 
         # Ensure the start address and size encompass the address we queried.
         self.assert_address_within_memory_region(heap_address, mem_region_dict)
 
     def breakpoint_set_and_remove_work(self, want_hardware):
         # Start up the inferior.
         procs = self.prep_debug_monitor_and_inferior(
             inferior_args=[

lldb/test/API/tools/lldb-vscode/breakpoint/TestVSCode_setBreakpoints.py

def test_set_and_clear(self):
             breakpoints = response['body']['breakpoints']
             self.assertEquals(len(breakpoints), len(lines),
                             "expect %u source breakpoints" % (len(lines)))
             for (breakpoint, index) in zip(breakpoints, range(len(lines))):
                 line = breakpoint['line']
                 self.assertTrue(line, lines[index])
                 # Store the "id" of the breakpoint that was set for later
                 line_to_id[line] = breakpoint['id']
-                self.assertTrue(line in lines, "line expected in lines array")
+                self.assertIn(line, lines, "line expected in lines array")
                 self.assertTrue(breakpoint['verified'],
                                 "expect breakpoint verified")
 
         # There is no breakpoint delete packet, clients just send another
         # setBreakpoints packet with the same source file with fewer lines.
         # Below we remove the second line entry and call the setBreakpoints
         # function again. We want to verify that any breakpoints that were set
         # before still have the same "id". This means we didn't clear the
def test_set_and_clear(self):
                             "expect %u source breakpoints" % (len(lines)))
             for (breakpoint, index) in zip(breakpoints, range(len(lines))):
                 line = breakpoint['line']
                 self.assertTrue(line, lines[index])
                 # Verify the same breakpoints are still set within LLDB by
                 # making sure the breakpoint ID didn't change
                 self.assertEquals(line_to_id[line], breakpoint['id'],
                                 "verify previous breakpoints stayed the same")
-                self.assertTrue(line in lines, "line expected in lines array")
+                self.assertIn(line, lines, "line expected in lines array")
                 self.assertTrue(breakpoint['verified'],
                                 "expect breakpoint still verified")
 
         # Now get the full list of breakpoints set in the target and verify
         # we have only 2 breakpoints set. The response above could have told
         # us about 2 breakpoints, but we want to make sure we don't have the
         # third one still set in the target
         response = self.vscode.request_testGetTargetBreakpoints()
         if response:
             breakpoints = response['body']['breakpoints']
             self.assertEquals(len(breakpoints), len(lines),
                             "expect %u source breakpoints" % (len(lines)))
             for breakpoint in breakpoints:
                 line = breakpoint['line']
                 # Verify the same breakpoints are still set within LLDB by
                 # making sure the breakpoint ID didn't change
                 self.assertEquals(line_to_id[line], breakpoint['id'],
                                 "verify previous breakpoints stayed the same")
-                self.assertTrue(line in lines, "line expected in lines array")
+                self.assertIn(line, lines, "line expected in lines array")
                 self.assertTrue(breakpoint['verified'],
                                 "expect breakpoint still verified")
 
         # Now clear all breakpoints for the source file by passing down an
         # empty lines array
         lines = []
         response = self.vscode.request_setBreakpoints(self.main_path, lines)
         if response:
def test_set_and_clear(self):
         lines = [second_line]
         response = self.vscode.request_setBreakpoints(self.main_path, lines)
         if response:
             breakpoints = response['body']['breakpoints']
             self.assertEquals(len(breakpoints), len(lines),
                             "expect %u source breakpoints" % (len(lines)))
             for breakpoint in breakpoints:
                 line = breakpoint['line']
-                self.assertTrue(line in lines, "line expected in lines array")
+                self.assertIn(line, lines, "line expected in lines array")
                 self.assertTrue(breakpoint['verified'],
                                 "expect breakpoint still verified")
 
         # Now get the full list of breakpoints set in the target and verify
         # we have only 2 breakpoints set. The response above could have told
         # us about 2 breakpoints, but we want to make sure we don't have the
         # third one still set in the target
         response = self.vscode.request_testGetTargetBreakpoints()
         if response:
             breakpoints = response['body']['breakpoints']
             self.assertEquals(len(breakpoints), len(lines),
                             "expect %u source breakpoints" % (len(lines)))
             for breakpoint in breakpoints:
                 line = breakpoint['line']
-                self.assertTrue(line in lines, "line expected in lines array")
+                self.assertIn(line, lines, "line expected in lines array")
                 self.assertTrue(breakpoint['verified'],
                                 "expect breakpoint still verified")
 
     @skipIfWindows
     @skipIfRemote
     @expectedFailureAll(oslist=["freebsd"], bugnumber="llvm.org/pr48421")
     def test_clear_breakpoints_unset_breakpoints(self):
         '''Test clearing breakpoints like test_set_and_clear, but clear
def test_clear_breakpoints_unset_breakpoints(self):
         breakpoints = response['body']['breakpoints']
         self.assertEquals(len(breakpoints), len(lines),
                         "expect %u source breakpoints" % (len(lines)))
         for (breakpoint, index) in zip(breakpoints, range(len(lines))):
             line = breakpoint['line']
             self.assertTrue(line, lines[index])
             # Store the "id" of the breakpoint that was set for later
             line_to_id[line] = breakpoint['id']
-            self.assertTrue(line in lines, "line expected in lines array")
+            self.assertIn(line, lines, "line expected in lines array")
             self.assertTrue(breakpoint['verified'],
                             "expect breakpoint verified")
 
         # Now clear all breakpoints for the source file by not setting the
         # lines array.
         lines = None
         response = self.vscode.request_setBreakpoints(self.main_path, lines)
         breakpoints = response['body']['breakpoints']

lldb/test/API/tools/lldb-vscode/console/TestVSCode_console.py

 
 class TestVSCode_console(lldbvscode_testcase.VSCodeTestCaseBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     def check_lldb_command(self, lldb_command, contains_string, assert_msg):
         response = self.vscode.request_evaluate('`%s' % (lldb_command))
         output = response['body']['result']
-        self.assertTrue(contains_string in output,
-                        ("""Verify %s by checking the command output:\n"""
-                         """'''\n%s'''\nfor the string: "%s" """ % (
-                         assert_msg, output, contains_string)))
+        self.assertIn(contains_string, output,
 
     @skipIfWindows
     @skipIfRemote
     def test_scopes_variables_setVariable_evaluate(self):
         '''
             Tests that the "scopes" request causes the currently selected
             thread and frame to be updated. There are no DAP packets that tell
             lldb-vscode which thread and frame are selected other than the

lldb/test/API/tools/lldb-vscode/launch/TestVSCode_launch.py

def test_default(self):
         program = self.getBuildArtifact("a.out")
         self.build_and_launch(program)
         self.continue_to_exit()
         # Now get the STDOUT and verify our program argument is correct
         output = self.get_stdout()
         self.assertTrue(output and len(output) > 0,
                         "expect program output")
         lines = output.splitlines()
-        self.assertTrue(program in lines[0],
-                        "make sure program path is in first argument")
+        self.assertIn(program, lines[0],
 
     @skipIfWindows
     @skipIfRemote
     def test_termination(self):
         '''
             Tests the correct termination of lldb-vscode upon a 'disconnect'
             request.
         '''
def test_cwd(self):
         self.assertTrue(output and len(output) > 0,
                         "expect program output")
         lines = output.splitlines()
         found = False
         for line in lines:
             if line.startswith('cwd = \"'):
                 quote_path = '"%s"' % (program_parent_dir)
                 found = True
-                self.assertTrue(quote_path in line,
-                                "working directory '%s' not in '%s'" % (
-                                    program_parent_dir, line))
+                self.assertIn(quote_path, line,
         self.assertTrue(found, "verified program working directory")
 
     @skipIfWindows
     @skipIfRemote
     def test_debuggerRoot(self):
         '''
             Tests the "debuggerRoot" will change the working directory of
             the lldb-vscode debug adaptor.
def test_shellExpandArguments_enabled(self):
         # Now get the STDOUT and verify our program argument is correct
         output = self.get_stdout()
         self.assertTrue(output and len(output) > 0,
                         "expect no program output")
         lines = output.splitlines()
         for line in lines:
             quote_path = '"%s"' % (program)
             if line.startswith("arg[1] ="):
-                self.assertTrue(quote_path in line,
-                                'verify "%s" expanded to "%s"' % (
-                                    glob, program))
+                self.assertIn(quote_path, line,
 
     @skipIfWindows
     @skipIfRemote
     def test_shellExpandArguments_disabled(self):
         '''
             Tests the default launch of a simple program with shell expansion
             disabled.
         '''
         program = self.getBuildArtifact("a.out")
         program_dir = os.path.dirname(program)
         glob = os.path.join(program_dir, '*.out')
         self.build_and_launch(program,
                               args=[glob],
                               shellExpandArguments=False)
         self.continue_to_exit()
         # Now get the STDOUT and verify our program argument is correct
         output = self.get_stdout()
         self.assertTrue(output and len(output) > 0,
                         "expect no program output")
         lines = output.splitlines()
         for line in lines:
             quote_path = '"%s"' % (glob)
             if line.startswith("arg[1] ="):
-                self.assertTrue(quote_path in line,
-                                'verify "%s" stayed to "%s"' % (
-                                    glob, glob))
+                self.assertIn(quote_path, line,
 
     @skipIfWindows
     @skipIfRemote
     def test_args(self):
         '''
             Tests launch of a simple program with arguments
         '''
         program = self.getBuildArtifact("a.out")
         args = ["one", "with space", "'with single quotes'",
                 '"with double quotes"']
         self.build_and_launch(program,
                               args=args)
         self.continue_to_exit()
 
         # Now get the STDOUT and verify our arguments got passed correctly
         output = self.get_stdout()
         self.assertTrue(output and len(output) > 0,
                         "expect program output")
         lines = output.splitlines()
         # Skip the first argument that contains the program name
         lines.pop(0)
         # Make sure arguments we specified are correct
         for (i, arg) in enumerate(args):
             quoted_arg = '"%s"' % (arg)
-            self.assertTrue(quoted_arg in lines[i],
-                            'arg[%i] "%s" not in "%s"' % (i+1, quoted_arg, lines[i]))
+            self.assertIn(quoted_arg, lines[i],
 
     @skipIfWindows
     @skipIfRemote
     def test_environment(self):
         '''
             Tests launch of a simple program with environment variables
         '''
         program = self.getBuildArtifact("a.out")

lldb/test/API/tools/lldb-vscode/module/TestVSCode_module.py

def run_test(self, symbol_basename, expect_debug_info_size):
         self.continue_to_breakpoints(breakpoint_ids)
         active_modules = self.vscode.get_modules()
         program_module = active_modules[program_basename]
         self.assertIn(program_basename, active_modules, '%s module is in active modules' % (program_basename))
         self.assertIn('name', program_module, 'make sure name is in module')
         self.assertEqual(program_basename, program_module['name'])
         self.assertIn('path', program_module, 'make sure path is in module')
         self.assertEqual(program, program_module['path'])
-        self.assertTrue('symbolFilePath' not in program_module, 'Make sure a.out.stripped has no debug info')
+        self.assertNotIn('symbolFilePath', program_module, 'Make sure a.out.stripped has no debug info')
         symbols_path = self.getBuildArtifact(symbol_basename)
         self.vscode.request_evaluate('`%s' % ('target symbols add -s "%s" "%s"' % (program, symbols_path)))
 
         def checkSymbolsLoadedWithSize():
             active_modules = self.vscode.get_modules()
             program_module = active_modules[program_basename]
             self.assertIn('symbolFilePath', program_module)
             self.assertIn(symbols_path, program_module['symbolFilePath'])

lldb/test/API/tools/lldb-vscode/variables/TestVSCode_variables.py

def verify_values(self, verify_dict, actual, varref_dict=None):
             response = self.vscode.request_variables(varRef)
             self.verify_variables(verify_dict['children'],
                                   response['body']['variables'],
                                   varref_dict)
 
     def verify_variables(self, verify_dict, variables, varref_dict=None):
         for variable in variables:
             name = variable['name']
-            self.assertTrue(name in verify_dict,
-                            'variable "%s" in verify dictionary' % (name))
+            self.assertIn(name, verify_dict,
             self.verify_values(verify_dict[name], variable, varref_dict)
 
     @skipIfWindows
     @skipIfRemote
     def test_scopes_variables_setVariable_evaluate(self):
         '''
             Tests the "scopes", "variables", "setVariable", and "evaluate"
             packets.