[lldb] Make sure all Python API tests are marked as NO_DEBUG_INFO_TESTCASE

[JDevlieghere]

Summary

I noticed a few Python API tests (test/API/python_api) were not marked as NO_DEBUG_INFO_TESTCASE causing them to be rerun needlessly with different debug info variants. Instead of adding NO_DEBUG_INFO_TESTCASE, I decided it would be less error prone to convert all of them to a new test case format (PythonAPITest) which has that property set.

[kastiglione]

this diff has made me wonder: should we have a NoDebugInfoTestCase that can be used by any test, and would replace assigning to NO_DEBUG_INFO_TESTCASE?

[JDevlieghere]

In D131539#3711488, @kastiglione wrote:

this diff has made me wonder: should we have a NoDebugInfoTestCase that can be used by any test, and would replace assigning to NO_DEBUG_INFO_TESTCASE?

I was wondering the same thing. I decided against it because we already have NO_DEBUG_INFO_TESTCASE (test level) and @no_debug_info_test (function level) and I didn't want to add yet another option. Additionally, there's a few other patters that are common for the Python API tests (e.g. the self.source and self.line) that could be moved up into the base class in a follow up patch.

[labath]

In D131539#3711518, @JDevlieghere wrote:

In D131539#3711488, @kastiglione wrote:

this diff has made me wonder: should we have a NoDebugInfoTestCase that can be used by any test, and would replace assigning to NO_DEBUG_INFO_TESTCASE?

I was wondering the same thing. I decided against it because we already have NO_DEBUG_INFO_TESTCASE (test level) and @no_debug_info_test (function level) and I didn't want to add yet another option. Additionally, there's a few other patters that are common for the Python API tests (e.g. the self.source and self.line) that could be moved up into the base class in a follow up patch.

Note that we already kind of have that. The Base test class is the base of all our tests and does not support automatic test replication. Tests which inherit directly from that (lldb-server and lldb-vscode tests) for instance, don't get the replication even though they don't use NO_DEBUG_INFO_TESTCASE. The TestBase class (which we use for the "normal" SB API tests) adds a bunch of SB utility functions *and* it adds the ability to replicate tests. I think that separating the two parts would be completely reasonable, and would remove the need for most/all of the uses of NO_DEBUG_INFO_TESTCASE and @no_debug_info_test.

[JDevlieghere]

In D131539#3711835, @labath wrote:

In D131539#3711518, @JDevlieghere wrote:

In D131539#3711488, @kastiglione wrote:

this diff has made me wonder: should we have a NoDebugInfoTestCase that can be used by any test, and would replace assigning to NO_DEBUG_INFO_TESTCASE?

I was wondering the same thing. I decided against it because we already have NO_DEBUG_INFO_TESTCASE (test level) and @no_debug_info_test (function level) and I didn't want to add yet another option. Additionally, there's a few other patters that are common for the Python API tests (e.g. the self.source and self.line) that could be moved up into the base class in a follow up patch.

Note that we already kind of have that. The Base test class is the base of all our tests and does not support automatic test replication. Tests which inherit directly from that (lldb-server and lldb-vscode tests) for instance, don't get the replication even though they don't use NO_DEBUG_INFO_TESTCASE. The TestBase class (which we use for the "normal" SB API tests) adds a bunch of SB utility functions *and* it adds the ability to replicate tests. I think that separating the two parts would be completely reasonable, and would remove the need for most/all of the uses of NO_DEBUG_INFO_TESTCASE and @no_debug_info_test.

The ability to replicate tests is not even part of TestBase I think. Except for the attribute, it's all handled by the LLDBTestCaseFactory. If you think it's better to go the test case route (in favor of NO_DEBUG_INFO_TESTCASE) we can pull up everything but the factory and property from TestBase into Base (as you outlined) or keep them separate and just move the factory and property down to a (third) child class. Either way we should rename those 2 (3) classes to something more meaningful.

@labath: was your comment meant as a suggestion (i.e. we should make this change) or just informative in reply to Dave's question (i.e. we could make this change if we needed it)?

[labath]

In D131539#3712675, @JDevlieghere wrote:

In D131539#3711835, @labath wrote:

In D131539#3711518, @JDevlieghere wrote:

In D131539#3711488, @kastiglione wrote:

this diff has made me wonder: should we have a NoDebugInfoTestCase that can be used by any test, and would replace assigning to NO_DEBUG_INFO_TESTCASE?

I was wondering the same thing. I decided against it because we already have NO_DEBUG_INFO_TESTCASE (test level) and @no_debug_info_test (function level) and I didn't want to add yet another option. Additionally, there's a few other patters that are common for the Python API tests (e.g. the self.source and self.line) that could be moved up into the base class in a follow up patch.

Note that we already kind of have that. The Base test class is the base of all our tests and does not support automatic test replication. Tests which inherit directly from that (lldb-server and lldb-vscode tests) for instance, don't get the replication even though they don't use NO_DEBUG_INFO_TESTCASE. The TestBase class (which we use for the "normal" SB API tests) adds a bunch of SB utility functions *and* it adds the ability to replicate tests. I think that separating the two parts would be completely reasonable, and would remove the need for most/all of the uses of NO_DEBUG_INFO_TESTCASE and @no_debug_info_test.

The ability to replicate tests is not even part of TestBase I think. Except for the attribute, it's all handled by the LLDBTestCaseFactory.

Well.. yes, the actual code lives there, but if you think about it from the POV of a test case author, then he has the choice of either inheriting from Base (and getting no replication), or from TestBase (and getting the replication unless he disables it). I would say that the LLDBTestCaseFactory is an implementation detail that should not be visible to the outside world.

If you think it's better to go the test case route (in favor of NO_DEBUG_INFO_TESTCASE) we can pull up everything but the factory and property from TestBase into Base (as you outlined) or keep them separate and just move the factory and property down to a (third) child class.

I wouldn't want to put everything into Base, precisely because we have these gdb-server, vscode, etc., which don't operate on the SB API, and that functionality makes no sense there.

Either way we should rename those 2 (3) classes to something more meaningful.

Oh yes.

@labath: was your comment meant as a suggestion (i.e. we should make this change) or just informative in reply to Dave's question (i.e. we could make this change if we needed it)?

Something in between, I guess. I would like it to work that way, but I'm not going to make anyone do that right now. It's also a part of a larger discussion of whether the debug info replication should be opt-in or opt-out. A separate class makes more sense for an opt-in world, whereas the status quo is kind of geared towards an opt-out mechanism.

lldb/packages/Python/lldbsuite/test/lldbtest.py

def DebugPExpect(self, child):
 
         print(child)
 
     @classmethod
     def RemoveTempFile(cls, file):
         if os.path.exists(file):
             remove_file(file)
 
+
+class PythonAPITest(TestBase):
+
+    NO_DEBUG_INFO_TESTCASE = True
+
+
 # On Windows, the first attempt to delete a recently-touched file can fail
 # because of a race with antimalware scanners.  This function will detect a
 # failure and retry.
 
 
 def remove_file(file, num_retries=1, sleep_duration=0.5):
     for i in range(num_retries + 1):
         try:
             os.remove(file)
             return True
         except:
             time.sleep(sleep_duration)
             continue
     return False

lldb/test/API/python_api/breakpoint/TestBreakpointAPI.py

 """
 Test SBBreakpoint APIs.
 """
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
-class BreakpointAPITestCase(TestBase):
-    NO_DEBUG_INFO_TESTCASE = True
+class BreakpointAPITestCase(PythonAPITest):
 
     def test_breakpoint_is_valid(self):
         """Make sure that if an SBBreakpoint gets deleted its IsValid returns false."""
         self.build()
         exe = self.getBuildArtifact("a.out")
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)

lldb/test/API/python_api/class_members/TestSBTypeClassMembers.py

 """
 Test SBType APIs to fetch member function types.
 """
 
 
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
-class SBTypeMemberFunctionsTest(TestBase):
+class SBTypeMemberFunctionsTest(PythonAPITest):
 
     def setUp(self):
         # Call super's setUp().
-        TestBase.setUp(self)
+        PythonAPITest.setUp(self)
         # We'll use the test method name as the exe_name.
         self.exe_name = self.testMethodName
         # Find the line number to break at.
         self.source = 'main.mm'
         self.line = line_number(self.source, '// set breakpoint here')
 
     @skipUnlessDarwin
     def test(self):

lldb/test/API/python_api/compile_unit/TestCompileUnitAPI.py

 """
 Test SBCompileUnit APIs.
 """
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
-class CompileUnitAPITestCase(TestBase):
+class CompileUnitAPITestCase(PythonAPITest):
 
     def setUp(self):
-        TestBase.setUp(self)
+        PythonAPITest.setUp(self)
 
     def test(self):
         """Exercise some SBCompileUnit APIs."""
         self.build()
 
         (target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(self, 'break here', lldb.SBFileSpec('main.c'))
         self.assertTrue(target, VALID_TARGET)
         self.assertTrue(process, PROCESS_IS_VALID)

lldb/test/API/python_api/debugger/TestDebuggerAPI.py

 """
 Test Debugger APIs.
 """
 
 import lldb
 
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
-class DebuggerAPITestCase(TestBase):
-    NO_DEBUG_INFO_TESTCASE = True
+class DebuggerAPITestCase(PythonAPITest):
 
     def test_debugger_api_boundary_condition(self):
         """Exercise SBDebugger APIs with boundary conditions."""
         self.dbg.HandleCommand(None)
         self.dbg.SetDefaultArchitecture(None)
         self.dbg.GetScriptingLanguage(None)
         self.dbg.CreateTarget(None)
         self.dbg.CreateTarget(None, None, None, True, lldb.SBError())

lldb/test/API/python_api/default-constructor/TestDefaultConstructorForAPIObjects.py

 
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
-class APIDefaultConstructorTestCase(TestBase):
-    NO_DEBUG_INFO_TESTCASE = True
+class APIDefaultConstructorTestCase(PythonAPITest):
 
     def test_SBAddress(self):
         obj = lldb.SBAddress()
         if self.TraceOn():
             print(obj)
         self.assertFalse(obj)
         # Do fuzz testing on the invalid obj, it should not crash lldb.
         import sb_address

lldb/test/API/python_api/disassemble-raw-data/TestDisassembleRawData.py

 """
 Use lldb Python API to disassemble raw machine code bytes
 """
 
 from __future__ import print_function
 
 
 import re
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
-class DisassembleRawDataTestCase(TestBase):
+class DisassembleRawDataTestCase(PythonAPITest):
 
     @no_debug_info_test
     @skipIfRemote
     def test_disassemble_raw_data(self):
         """Test disassembling raw bytes with the API."""
         # Create a target from the debugger.
         arch = self.getArchitecture()
         if re.match("mips*el", arch):

lldb/test/API/python_api/disassemble-raw-data/TestDisassemble_VST1_64.py

 """
 Use lldb Python API to disassemble raw machine code bytes
 """
 
 from __future__ import print_function
 
 from io import StringIO
 import sys
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
-class Disassemble_VST1_64(TestBase):
+class Disassemble_VST1_64(PythonAPITest):
 
     @no_debug_info_test
     @skipIfLLVMTargetMissing("ARM")
     def test_disassemble_invalid_vst_1_64_raw_data(self):
         """Test disassembling invalid vst1.64 raw bytes with the API."""
         # Create a target from the debugger.
         target = self.dbg.CreateTargetWithFileAndTargetTriple("", "thumbv7-apple-macosx")
         self.assertTrue(target, VALID_TARGET)

lldb/test/API/python_api/event/TestEvents.py

 """
 Test lldb Python event APIs.
 """
 
 from __future__ import print_function
 
 
 import re
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 @skipIfLinux   # llvm.org/pr25924, sometimes generating SIGSEGV
-class EventAPITestCase(TestBase):
-    NO_DEBUG_INFO_TESTCASE = True
+class EventAPITestCase(PythonAPITest):
 
     def setUp(self):
         # Call super's setUp().
-        TestBase.setUp(self)
+        PythonAPITest.setUp(self)
         # Find the line number to of function 'c'.
         self.line = line_number(
             'main.c', '// Find the line number of function "c" here.')
 
     @expectedFailureAll(
         oslist=["linux"],
         bugnumber="llvm.org/pr23730 Flaky, fails ~1/10 cases")
     @skipIfWindows # This is flakey on Windows AND when it fails, it hangs: llvm.org/pr38373

lldb/test/API/python_api/file_handle/TestFileHandle.py

def readStrippedLines(f):
     def i():
         for line in f:
             line = line.strip()
             if line:
                 yield line
     return list(i())
 
 
-class FileHandleTestCase(lldbtest.TestBase):
+class FileHandleTestCase(lldbtest.PythonAPITest):
 
-    NO_DEBUG_INFO_TESTCASE = True
 
     # The way normal tests evaluate debugger commands is
     # by using a SBCommandInterpreter directly, which captures
     # the output in a result object.   For many of tests tests
     # we want the debugger to write the  output directly to
     # its I/O streams like it would have done interactively.
     #
     # For this reason we also define handleCmd() here, even though

lldb/test/API/python_api/findvalue_duplist/TestSBFrameFindValue.py

 """Test that SBFrame::FindValue finds things but does not duplicate the entire variables list"""
 
 
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
-class SBFrameFindValueTestCase(TestBase):
-    NO_DEBUG_INFO_TESTCASE = True
+class SBFrameFindValueTestCase(PythonAPITest):
 
     def test_formatters_api(self):
         """Test that SBFrame::FindValue finds things but does not duplicate the entire variables list"""
         self.build()
         self.setTearDownCleanup()
 
         exe = self.getBuildArtifact("a.out")
 

lldb/test/API/python_api/formatters/TestFormattersSBAPI.py

 """Test Python APIs for working with formatters"""
 
 from __future__ import print_function
 
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
-class SBFormattersAPITestCase(TestBase):
-    NO_DEBUG_INFO_TESTCASE = True
+class SBFormattersAPITestCase(PythonAPITest):
 
     def setUp(self):
         # Call super's setUp().
-        TestBase.setUp(self)
+        PythonAPITest.setUp(self)
         self.line = line_number('main.cpp', '// Set break point at this line.')
 
     def test_formatters_api(self):
         """Test Python APIs for working with formatters"""
         self.build()
         self.setTearDownCleanup()
 
         """Test Python APIs for working with formatters"""

lldb/test/API/python_api/frame/TestFrames.py

 """
 Use lldb Python SBFrame API to get the argument values of the call stacks.
 And other SBFrame API tests.
 """
 
 from __future__ import print_function
 
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
-class FrameAPITestCase(TestBase):
+class FrameAPITestCase(PythonAPITest):
 
     def test_get_arg_vals_for_call_stack(self):
         """Exercise SBFrame.GetVariables() API to get argument vals."""
         self.build()
         exe = self.getBuildArtifact("a.out")
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)

lldb/test/API/python_api/frame/get-variables/TestGetVariables.py

 
 def get_names_from_value_list(value_list):
     names = list()
     for value in value_list:
         names.append(value.GetName())
     return names
 
 
-class TestGetVariables(TestBase):
+class TestGetVariables(PythonAPITest):
 
     def setUp(self):
         # Call super's setUp().
-        TestBase.setUp(self)
+        PythonAPITest.setUp(self)
         self.source = 'main.c'
 
     def verify_variable_names(self, description, value_list, names):
         copy_names = list(names)
         actual_names = get_names_from_value_list(value_list)
         for name in actual_names:
             if name in copy_names:
                 copy_names.remove(name)

lldb/test/API/python_api/frame/inlines/TestInlinedFrame.py

 """
 Testlldb Python SBFrame APIs IsInlined() and GetFunctionName().
 """
 
 from __future__ import print_function
 
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
-class InlinedFrameAPITestCase(TestBase):
+class InlinedFrameAPITestCase(PythonAPITest):
 
     def setUp(self):
         # Call super's setUp().
-        TestBase.setUp(self)
+        PythonAPITest.setUp(self)
         # Find the line number to of function 'c'.
         self.source = 'inlines.c'
         self.first_stop = line_number(
             self.source, '// This should correspond to the first break stop.')
         self.second_stop = line_number(
             self.source, '// This should correspond to the second break stop.')
 
     def test_stop_at_outer_inline(self):

lldb/test/API/python_api/function_symbol/TestDisasmAPI.py

 """
 Test retrieval of SBAddress from function/symbol, disassembly, and SBAddress APIs.
 """
 
 from __future__ import print_function
 
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
-class DisasmAPITestCase(TestBase):
+class DisasmAPITestCase(PythonAPITest):
 
     def setUp(self):
         # Call super's setUp().
-        TestBase.setUp(self)
+        PythonAPITest.setUp(self)
         # Find the line number to of function 'c'.
         self.line1 = line_number(
             'main.c', '// Find the line number for breakpoint 1 here.')
         self.line2 = line_number(
             'main.c', '// Find the line number for breakpoint 2 here.')
 
     @expectedFailureAll(oslist=["windows"], bugnumber='llvm.org/pr21765')
     def test(self):

lldb/test/API/python_api/function_symbol/TestSymbolAPI.py

 """
 Test newly added SBSymbol and SBAddress APIs.
 """
 
 from __future__ import print_function
 
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
-class SymbolAPITestCase(TestBase):
+class SymbolAPITestCase(PythonAPITest):
 
     def setUp(self):
         # Call super's setUp().
-        TestBase.setUp(self)
+        PythonAPITest.setUp(self)
         # Find the line number to of function 'c'.
         self.line1 = line_number(
             'main.c', '// Find the line number for breakpoint 1 here.')
         self.line2 = line_number(
             'main.c', '// Find the line number for breakpoint 2 here.')
 
     @expectedFailureAll(oslist=["windows"], bugnumber='llvm.org/pr21765')
     def test(self):

lldb/test/API/python_api/get-value-32bit-int/TestGetValue32BitInt.py

 """
 Check that SBValue.GetValueAsSigned() does the right thing for a 32-bit -1.
 """
 
 import lldb
 from lldbsuite.test.lldbtest import *
 import lldbsuite.test.lldbutil as lldbutil
 
-class TestCase(TestBase):
-    NO_DEBUG_INFO_TESTCASE = True
+class TestCase(PythonAPITest):
 
     def test_with_run_command(self):
         self.build()
         lldbutil.run_to_source_breakpoint(self,"// break here", lldb.SBFileSpec("main.cpp"))
 
         self.assertEqual(self.frame().FindVariable("myvar").GetValueAsSigned(), -1)
         self.assertEqual(self.frame().FindVariable("myvar").GetValueAsUnsigned(), 0xFFFFFFFF)

lldb/test/API/python_api/hello_world/TestHelloWorld.py

 """Test Python APIs for target (launch and attach), breakpoint, and process."""
 
 
 
 import os
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 import lldbsuite.test.lldbutil as lldbutil
 
-class HelloWorldTestCase(TestBase):
-    NO_DEBUG_INFO_TESTCASE = True
+class HelloWorldTestCase(PythonAPITest):
 
     def setUp(self):
         # Call super's setUp().
-        TestBase.setUp(self)
+        PythonAPITest.setUp(self)
         # Find a couple of the line numbers within main.c.
         self.line1 = line_number('main.c', '// Set break point at this line.')
         self.line2 = line_number('main.c', '// Waiting to be attached...')
 
     def tearDown(self):
-        # Destroy process before TestBase.tearDown()
+        # Destroy process before PythonAPITest.tearDown()
         self.dbg.GetSelectedTarget().GetProcess().Destroy()
         # Call super's tearDown().
-        TestBase.tearDown(self)
+        PythonAPITest.tearDown(self)
 
     @skipIfiOSSimulator
     def test_with_process_launch_api(self):
         """Create target, breakpoint, launch a process, and then kill it."""
         # Get the full path to our executable to be attached/debugged.
         exe = '%s_%d'%(self.getBuildArtifact(self.testMethodName), os.getpid())
         d = {'EXE': exe}
         self.build(dictionary=d)

lldb/test/API/python_api/interpreter/TestCommandInterpreterAPI.py

 """Test the SBCommandInterpreter APIs."""
 
 from __future__ import print_function
 
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
-class CommandInterpreterAPICase(TestBase):
-    NO_DEBUG_INFO_TESTCASE = True
+class CommandInterpreterAPICase(PythonAPITest):
 
     def setUp(self):
         # Call super's setUp().
-        TestBase.setUp(self)
+        PythonAPITest.setUp(self)
         # Find the line number to break on inside main.cpp.
         self.line = line_number('main.c', 'Hello world.')
 
     def test_with_process_launch_api(self):
         """Test the SBCommandInterpreter APIs."""
         self.build()
         exe = self.getBuildArtifact("a.out")
 

lldb/test/API/python_api/interpreter/TestRunCommandInterpreterAPI.py

 """Test the RunCommandInterpreter API."""
 
 import os
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 
-class CommandRunInterpreterLegacyAPICase(TestBase):
+class CommandRunInterpreterLegacyAPICase(PythonAPITest):
 
-    NO_DEBUG_INFO_TESTCASE = True
 
     def setUp(self):
-        TestBase.setUp(self)
+        PythonAPITest.setUp(self)
 
         self.stdin_path = self.getBuildArtifact("stdin.txt")
 
         with open(self.stdin_path, 'w') as input_handle:
             input_handle.write("nonexistingcommand\nquit")
 
         # Python will close the file descriptor if all references
         # to the filehandle object lapse, so we need to keep one
def test_run_session_with_error_and_quit_legacy(self):
                 True, False, lldb.SBCommandInterpreterRunOptions(), 0, False,
                 False)
 
         self.assertGreater(n_errors, 0)
         self.assertTrue(quit_requested)
         self.assertFalse(has_crashed)
 
 
-class CommandRunInterpreterAPICase(TestBase):
+class CommandRunInterpreterAPICase(PythonAPITest):
 
-    NO_DEBUG_INFO_TESTCASE = True
 
     def setUp(self):
-        TestBase.setUp(self)
+        PythonAPITest.setUp(self)
 
         self.stdin_path = self.getBuildArtifact("stdin.txt")
 
         with open(self.stdin_path, 'w') as input_handle:
             input_handle.write("nonexistingcommand\nquit")
 
         self.dbg.SetInputFile(open(self.stdin_path, 'r'))
 
         # No need to track the output
         devnull = open(os.devnull, 'w')
         self.dbg.SetOutputFile(devnull)
         self.dbg.SetErrorFile(devnull)
 
     def test_run_session_with_error_and_quit(self):
         """Run non-existing and quit command returns appropriate values"""
 
         n_errors, quit_requested, has_crashed = self.dbg.RunCommandInterpreter(
                 True, False, lldb.SBCommandInterpreterRunOptions(), 0, False,
                 False)
 
         self.assertGreater(n_errors, 0)
         self.assertTrue(quit_requested)
         self.assertFalse(has_crashed)
 
-class SBCommandInterpreterRunOptionsCase(TestBase):
+class SBCommandInterpreterRunOptionsCase(PythonAPITest):
 
-    NO_DEBUG_INFO_TESTCASE = True
 
     def test_command_interpreter_run_options(self):
         """Test SBCommandInterpreterRunOptions default values, getters & setters """
 
         opts = lldb.SBCommandInterpreterRunOptions()
 
         # Check getters with default values
         self.assertEqual(opts.GetStopOnContinue(), False)

lldb/test/API/python_api/lldbutil/TestSwigVersion.py

 """
 Test that we embed the swig version into the lldb module
 """
 
 
 """
 import os
 import time
 import re
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test import lldbutil
 """
 from lldbsuite.test.lldbtest import *
 
-class SwigVersionTestCase(TestBase):
-    NO_DEBUG_INFO_TESTCASE = True
+class SwigVersionTestCase(PythonAPITest):
 
     def test(self):
         self.assertTrue(getattr(lldb, "swig_version"))
         self.assertIsInstance(lldb.swig_version, tuple)
         self.assertEqual(len(lldb.swig_version), 3)
         self.assertGreaterEqual(lldb.swig_version[0], 1)
         for v in lldb.swig_version:
             self.assertGreaterEqual(v, 0)

lldb/test/API/python_api/lldbutil/frame/TestFrameUtils.py

 """
 Test utility functions for the frame object.
 """
 
 from __future__ import print_function
 
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
-class FrameUtilsTestCase(TestBase):
+class FrameUtilsTestCase(PythonAPITest):
 
     def setUp(self):
         # Call super's setUp().
-        TestBase.setUp(self)
+        PythonAPITest.setUp(self)
         # Find the line number to break inside main().
         self.line = line_number('main.c',
                                 "// Find the line number here.")
 
     def test_frame_utils(self):
         """Test utility functions for the frame object."""
         self.build()
         exe = self.getBuildArtifact("a.out")

lldb/test/API/python_api/lldbutil/iter/TestLLDBIterator.py

 """
 Test the iteration protocol for some lldb container objects.
 """
 
 from __future__ import print_function
 
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
-class LLDBIteratorTestCase(TestBase):
+class LLDBIteratorTestCase(PythonAPITest):
 
     def setUp(self):
         # Call super's setUp().
-        TestBase.setUp(self)
+        PythonAPITest.setUp(self)
         # Find the line numbers to break inside main().
         self.line1 = line_number(
             'main.cpp', '// Set break point at this line.')
         self.line2 = line_number('main.cpp', '// And that line.')
 
     def test_lldb_iter_module(self):
         """Test module_iter works correctly for SBTarget -> SBModule."""
         self.build()

lldb/test/API/python_api/lldbutil/iter/TestRegistersIterator.py

 """
 Test the iteration protocol for frame registers.
 """
 
 from __future__ import print_function
 
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
-class RegistersIteratorTestCase(TestBase):
+class RegistersIteratorTestCase(PythonAPITest):
 
     def setUp(self):
         # Call super's setUp().
-        TestBase.setUp(self)
+        PythonAPITest.setUp(self)
         # Find the line number to break inside main().
         self.line1 = line_number(
             'main.cpp', '// Set break point at this line.')
 
     def test_iter_registers(self):
         """Test iterator works correctly for lldbutil.iter_registers()."""
         self.build()
         exe = self.getBuildArtifact("a.out")

lldb/test/API/python_api/lldbutil/process/TestPrintStackTraces.py

 """
 Test SBprocess and SBThread APIs with printing of the stack traces using lldbutil.
 """
 
 
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
-class ThreadsStackTracesTestCase(TestBase):
+class ThreadsStackTracesTestCase(PythonAPITest):
 
     def test_stack_traces(self):
         """Test SBprocess and SBThread APIs with printing of the stack traces."""
         self.build()
         (_, process, _, _) = lldbutil.run_to_source_breakpoint(self,
                 "// BREAK HERE", lldb.SBFileSpec("main.cpp"))
         stacktraces = lldbutil.print_stacktraces(process, string_buffer=True)
         self.expect(stacktraces, exe=False,
                     substrs=['(int)x=4', '(int)y=6', '(int)x=3', '(int)argc=1'])

lldb/test/API/python_api/module_section/TestModuleAndSection.py

 """
 Test some SBModule and SBSection APIs.
 """
 
 from __future__ import print_function
 
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 from lldbsuite.test.lldbutil import symbol_type_to_str
 
 
-class ModuleAndSectionAPIsTestCase(TestBase):
+class ModuleAndSectionAPIsTestCase(PythonAPITest):
 
     # Py3 asserts due to a bug in SWIG.  A fix for this was upstreamed into
     # SWIG 3.0.8.
     @skipIf(py_version=['>=', (3, 0)], swig_version=['<', (3, 0, 8)])
     def test_module_and_section(self):
         """Test module and section APIs."""
         self.build()
         exe = self.getBuildArtifact("a.out")

lldb/test/API/python_api/name_lookup/TestNameLookup.py

 """
 Test SBTarget APIs.
 """
 
 
 
 import unittest2
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
-class TestNameLookup(TestBase):
+class TestNameLookup(PythonAPITest):
 
     @expectedFailureAll(oslist=["windows"], bugnumber='llvm.org/pr21765')
     def test_target(self):
         """Exercise SBTarget.FindFunctions() with various name masks.
 
         A previous regression caused mangled names to not be able to be looked up.
         This test verifies that using a mangled name with eFunctionNameTypeFull works
         and that using a function basename with eFunctionNameTypeFull works for all

lldb/test/API/python_api/objc_type/TestObjCType.py

 """
 Test SBType for ObjC classes.
 """
 
 
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
-class ObjCSBTypeTestCase(TestBase):
+class ObjCSBTypeTestCase(PythonAPITest):
 
     def setUp(self):
         # Call super's setUp().
-        TestBase.setUp(self)
+        PythonAPITest.setUp(self)
         self.line = line_number("main.m", '// Break at this line')
 
     @add_test_categories(['objc', 'pyapi'])
     def test(self):
         """Test SBType for ObjC classes."""
         self.build()
         exe = self.getBuildArtifact("a.out")
 

lldb/test/API/python_api/process/TestProcessAPI.py

 """
 Test SBProcess APIs, including ReadMemory(), WriteMemory(), and others.
 """
 
 from __future__ import print_function
 
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test.lldbutil import get_stopped_thread, state_type_to_str
 
 
-class ProcessAPITestCase(TestBase):
+class ProcessAPITestCase(PythonAPITest):
 
     def setUp(self):
         # Call super's setUp().
-        TestBase.setUp(self)
+        PythonAPITest.setUp(self)
         # Find the line number to break inside main().
         self.line = line_number(
             "main.cpp",
             "// Set break point at this line and check variable 'my_char'.")
 
     def test_read_memory(self):
         """Test Python SBProcess.ReadMemory() API."""
         self.build()

lldb/test/API/python_api/process/io/TestProcessIO.py

 """Test Python APIs for process IO."""
 
 from __future__ import print_function
 
 
 import os
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
-class ProcessIOTestCase(TestBase):
-    NO_DEBUG_INFO_TESTCASE = True
+class ProcessIOTestCase(PythonAPITest):
 
     def setup_test(self):
         # Get the full path to our executable to be debugged.
         self.exe = self.getBuildArtifact("process_io")
         self.local_input_file = self.getBuildArtifact("input.txt")
         self.local_output_file = self.getBuildArtifact("output.txt")
         self.local_error_file = self.getBuildArtifact("error.txt")
 

lldb/test/API/python_api/process/read-mem-cstring/TestReadMemCString.py

 """Test reading c-strings from memory via SB API."""
 
 
 import os
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
-class TestReadMemCString(TestBase):
-    NO_DEBUG_INFO_TESTCASE = True
+class TestReadMemCString(PythonAPITest):
 
     def test_read_memory_c_string(self):
         """Test corner case behavior of SBProcess::ReadCStringFromMemory"""
         self.build()
         self.dbg.SetAsync(False)
 
         self.main_source = "main.c"
         self.main_source_path = os.path.join(self.getSourceDir(),

lldb/test/API/python_api/sbdata/TestSBData.py

 """Test the SBData APIs."""
 
 
 
 from math import fabs
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
-class SBDataAPICase(TestBase):
-    NO_DEBUG_INFO_TESTCASE = True
+class SBDataAPICase(PythonAPITest):
 
     def setUp(self):
         # Call super's setUp().
-        TestBase.setUp(self)
+        PythonAPITest.setUp(self)
         # Find the line number to break on inside main.cpp.
         self.line = line_number('main.cpp', '// set breakpoint here')
 
     def test_byte_order_and_address_byte_size(self):
         """Test the SBData::SetData() to ensure the byte order and address
         byte size are obeyed"""
         addr_data = b'\x11\x22\x33\x44\x55\x66\x77\x88'
         error = lldb.SBError()

lldb/test/API/python_api/sbenvironment/TestSBEnvironment.py

 """Test the SBEnvironment APIs."""
 
 
 
 from math import fabs
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
-class SBEnvironmentAPICase(TestBase):
-    NO_DEBUG_INFO_TESTCASE = True
+class SBEnvironmentAPICase(PythonAPITest):
 
     # We use this function to test both kind of accessors:
     # .  Get*AtIndex and GetEntries
     def assertEqualEntries(self, env, entries):
         self.assertEqual(env.GetNumValues(), len(entries))
         for i in range(env.GetNumValues()):
             name = env.GetNameAtIndex(i)
             value = env.GetValueAtIndex(i)

lldb/test/API/python_api/sberror/TestSBError.py

 """Test the SBError APIs."""
 
 from lldbsuite.test.lldbtest import *
 
-class TestSBError(TestBase):
-    NO_DEBUG_INFO_TESTCASE = True
+class TestSBError(PythonAPITest):
 
     def test_generic_error(self):
         error = lldb.SBError()
         error.SetErrorToGenericError()
         self.assertEqual(error.GetType(), lldb.eErrorTypeGeneric)

lldb/test/API/python_api/sblaunchinfo/TestSBLaunchInfo.py

 def lookup(info, key):
     for i in range(info.GetNumEnvironmentEntries()):
         KeyEqValue = info.GetEnvironmentEntryAtIndex(i)
         Key, Value = KeyEqValue.split("=")
         if Key == key:
             return Value
     return ""
 
-class TestSBLaunchInfo(TestBase):
-    NO_DEBUG_INFO_TESTCASE = True
+class TestSBLaunchInfo(PythonAPITest):
 
     def test_environment_getset(self):
         info = lldb.SBLaunchInfo(None)
         info.SetEnvironmentEntries(["FOO=BAR"], False)
         self.assertEquals(1, info.GetNumEnvironmentEntries())
         info.SetEnvironmentEntries(["BAR=BAZ"], True)
         self.assertEquals(2, info.GetNumEnvironmentEntries())
         self.assertEquals("BAR", lookup(info, "FOO"))
         self.assertEquals("BAZ", lookup(info, "BAR"))

lldb/test/API/python_api/sbmodule/TestSBModule.py

 """Test the SBDModule APIs."""
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 import os, signal, subprocess
 
-class SBModuleAPICase(TestBase):
+class SBModuleAPICase(PythonAPITest):
 
     def setUp(self):
-        TestBase.setUp(self)
+        PythonAPITest.setUp(self)
         self.background_pid = None
 
     def tearDown(self):
-        TestBase.tearDown(self)
+        PythonAPITest.tearDown(self)
         if self.background_pid:
             os.kill(self.background_pid, signal.SIGKILL)
 
     @skipUnlessDarwin
     @skipIfRemote
     def test_module_is_file_backed(self):
         """Test the SBModule::IsFileBacked() method"""
         self.build()

lldb/test/API/python_api/sbplatform/TestSBPlatform.py

 """Test the SBPlatform APIs."""
 
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 
-class SBPlatformAPICase(TestBase):
-    NO_DEBUG_INFO_TESTCASE = True
+class SBPlatformAPICase(PythonAPITest):
 
     @skipIfRemote # Remote environment not supported.
     def test_run(self):
         self.build()
         plat = lldb.SBPlatform.GetHostPlatform()
 
         os.environ["MY_TEST_ENV_VAR"]="SBPlatformAPICase.test_run"
         def cleanup():

lldb/test/API/python_api/sbstructureddata/TestStructuredDataAPI.py

 """
 Test some SBStructuredData API.
 """
 
 
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
-class TestStructuredDataAPI(TestBase):
-    NO_DEBUG_INFO_TESTCASE = True
+class TestStructuredDataAPI(PythonAPITest):
 
     def test(self):
         self.structured_data_api_test()
 
     def structured_data_api_test(self):
         error = lldb.SBError()
         s = lldb.SBStream()
         s.Print(

lldb/test/API/python_api/sbvalue_persist/TestSBValuePersist.py

 """Test SBValue::Persist"""
 
 
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
-class SBValuePersistTestCase(TestBase):
-    NO_DEBUG_INFO_TESTCASE = True
+class SBValuePersistTestCase(PythonAPITest):
 
     @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24772")
     def test(self):
         """Test SBValue::Persist"""
         self.build()
         self.setTearDownCleanup()
         self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
 

lldb/test/API/python_api/section/TestSectionAPI.py

 """
 Test SBSection APIs.
 """
 
 
 
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
-class SectionAPITestCase(TestBase):
+class SectionAPITestCase(PythonAPITest):
 
     def test_get_target_byte_size(self):
         d = {'EXE': 'b.out'}
         self.build(dictionary=d)
         self.setTearDownCleanup(dictionary=d)
         exe = self.getBuildArtifact('b.out')
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)

lldb/test/API/python_api/signals/TestSignalsAPI.py

 """
 Test SBProcess APIs, including ReadMemory(), WriteMemory(), and others.
 """
 
 
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 from lldbsuite.test.lldbutil import get_stopped_thread, state_type_to_str
 
 
-class SignalsAPITestCase(TestBase):
-    NO_DEBUG_INFO_TESTCASE = True
+class SignalsAPITestCase(PythonAPITest):
 
     @skipIfWindows  # Windows doesn't have signals
     def test_ignore_signal(self):
         """Test Python SBUnixSignals.Suppress/Stop/Notify() API."""
         self.build()
         exe = self.getBuildArtifact("a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 

lldb/test/API/python_api/symbol-context/TestSymbolContext.py

 """
 Test SBSymbolContext APIs.
 """
 
 from __future__ import print_function
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
-class SymbolContextAPITestCase(TestBase):
+class SymbolContextAPITestCase(PythonAPITest):
 
     def setUp(self):
         # Call super's setUp().
-        TestBase.setUp(self)
+        PythonAPITest.setUp(self)
         # Find the line number to of function 'c'.
         self.line = line_number(
             'main.c', '// Find the line number of function "c" here.')
 
     @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778")
     def test(self):
         """Exercise SBSymbolContext API extensively."""
         self.build()

lldb/test/API/python_api/symbol-context/two-files/TestSymbolContextTwoFiles.py

 """
 Test SBSymbolContext APIs.
 """
 
 
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
-class SymbolContextTwoFilesTestCase(TestBase):
+class SymbolContextTwoFilesTestCase(PythonAPITest):
 
     @expectedFailureAll(oslist=["windows"])
     def test_lookup_by_address(self):
         """Test lookup by address in a module with multiple compilation units"""
         self.build()
         exe = self.getBuildArtifact("a.out")
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)

lldb/test/API/python_api/target/TestTargetAPI.py

 """
 Test SBTarget APIs.
 """
 
 from __future__ import print_function
 
 
 import unittest2
 import os
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
-class TargetAPITestCase(TestBase):
+class TargetAPITestCase(PythonAPITest):
 
     def setUp(self):
         # Call super's setUp().
-        TestBase.setUp(self)
+        PythonAPITest.setUp(self)
         # Find the line number to of function 'c'.
         self.line1 = line_number(
             'main.c', '// Find the line number for breakpoint 1 here.')
         self.line2 = line_number(
             'main.c', '// Find the line number for breakpoint 2 here.')
         self.line_main = line_number(
             "main.c", "// Set a break at entry to main.")
 

lldb/test/API/python_api/thread/TestThreadAPI.py

 """
 Test SBThread APIs.
 """
 
 from __future__ import print_function
 
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 from lldbsuite.test.lldbutil import get_stopped_thread, get_caller_symbol
 
 
-class ThreadAPITestCase(TestBase):
+class ThreadAPITestCase(PythonAPITest):
 
     def test_get_process(self):
         """Test Python SBThread.GetProcess() API."""
         self.build()
         self.get_process()
 
     def test_get_stop_description(self):
         """Test Python SBThread.GetStopDescription() API."""
def test_step_over_3_times(self):
         # We build a different executable than the default build() does.
         d = {'CXX_SOURCES': 'main2.cpp', 'EXE': self.exe_name}
         self.build(dictionary=d)
         self.setTearDownCleanup(dictionary=d)
         self.step_over_3_times(self.exe_name)
 
     def setUp(self):
         # Call super's setUp().
-        TestBase.setUp(self)
+        PythonAPITest.setUp(self)
         # Find the line number within main.cpp to break inside main().
         self.break_line = line_number(
             "main.cpp", "// Set break point at this line and check variable 'my_char'.")
         # Find the line numbers within main2.cpp for
         # step_out_of_malloc_into_function_b() and step_over_3_times().
         self.step_out_of_malloc = line_number(
             "main2.cpp", "// thread step-out of malloc into function b.")
         self.after_3_step_overs = line_number(

lldb/test/API/python_api/type/TestTypeList.py

 """
 Test SBType and SBTypeList API.
 """
 
 from __future__ import print_function
 
 
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
-class TypeAndTypeListTestCase(TestBase):
+class TypeAndTypeListTestCase(PythonAPITest):
 
     def setUp(self):
         # Call super's setUp().
-        TestBase.setUp(self)
+        PythonAPITest.setUp(self)
         # We'll use the test method name as the exe_name.
         self.exe_name = self.testMethodName
         # Find the line number to break at.
         self.source = 'main.cpp'
         self.line = line_number(self.source, '// Break at this line')
 
     def test(self):
         """Exercise SBType and SBTypeList API."""

lldb/test/API/python_api/value/TestValueAPI.py

 """
 Test some SBValue APIs.
 """
 
 from __future__ import print_function
 
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
-class ValueAPITestCase(TestBase):
+class ValueAPITestCase(PythonAPITest):
 
     def setUp(self):
         # Call super's setUp().
-        TestBase.setUp(self)
+        PythonAPITest.setUp(self)
         # We'll use the test method name as the exe_name.
         self.exe_name = self.testMethodName
         # Find the line number to of function 'c'.
         self.line = line_number('main.c', '// Break at this line')
 
     @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24772")
     def test(self):
         """Exercise some SBValue APIs."""

lldb/test/API/python_api/value/change_values/TestChangeValueAPI.py

 """
 Test some SBValue APIs.
 """
 
 
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
-class ChangeValueAPITestCase(TestBase):
+class ChangeValueAPITestCase(PythonAPITest):
 
     def setUp(self):
         # Call super's setUp().
-        TestBase.setUp(self)
+        PythonAPITest.setUp(self)
         # We'll use the test method name as the exe_name.
         self.exe_name = self.testMethodName
         # Find the line number to of function 'c'.
         self.line = line_number('main.c', '// Stop here and set values')
         self.check_line = line_number(
             'main.c', '// Stop here and check values')
         self.end_line = line_number(
             'main.c', '// Set a breakpoint here at the end')

lldb/test/API/python_api/value/empty_class/TestValueAPIEmptyClass.py

 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
-class ValueAPIEmptyClassTestCase(TestBase):
+class ValueAPIEmptyClassTestCase(PythonAPITest):
 
     def test(self):
         self.build()
         exe = self.getBuildArtifact("a.out")
         line = line_number('main.cpp', '// Break at this line')
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)

lldb/test/API/python_api/value/linked_list/TestValueAPILinkedList.py

 """
 Test SBValue API linked_list_iter which treats the SBValue as a linked list and
 supports iteration till the end of list is reached.
 """
 
 from __future__ import print_function
 
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
-class ValueAsLinkedListTestCase(TestBase):
-    NO_DEBUG_INFO_TESTCASE = True
+class ValueAsLinkedListTestCase(PythonAPITest):
 
     def setUp(self):
         # Call super's setUp().
-        TestBase.setUp(self)
+        PythonAPITest.setUp(self)
         # We'll use the test method name as the exe_name.
         self.exe_name = self.testMethodName
         # Find the line number to break at.
         self.line = line_number('main.cpp', '// Break at this line')
 
     # Py3 asserts due to a bug in SWIG.  A fix for this was upstreamed into
     # SWIG 3.0.8.
     @skipIf(py_version=['>=', (3, 0)], swig_version=['<', (3, 0, 8)])

lldb/test/API/python_api/value_var_update/TestValueVarUpdate.py

 """Test SBValue::GetValueDidChange"""
 
 
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
-class ValueVarUpdateTestCase(TestBase):
+class ValueVarUpdateTestCase(PythonAPITest):
 
     def test_with_process_launch_api(self):
         """Test SBValue::GetValueDidChange"""
         # Get the full path to our executable to be attached/debugged.
         exe = self.getBuildArtifact(self.testMethodName)
         d = {'EXE': exe}
         self.build(dictionary=d)
         self.setTearDownCleanup(dictionary=d)

lldb/test/API/python_api/watchpoint/TestSetWatchpoint.py

 """
 Use lldb Python SBValue API to create a watchpoint for read_write of 'globl' var.
 """
 
 from __future__ import print_function
 
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
-class SetWatchpointAPITestCase(TestBase):
-    NO_DEBUG_INFO_TESTCASE = True
+class SetWatchpointAPITestCase(PythonAPITest):
 
     def setUp(self):
         # Call super's setUp().
-        TestBase.setUp(self)
+        PythonAPITest.setUp(self)
         # Our simple source filename.
         self.source = 'main.c'
         # Find the line number to break inside main().
         self.line = line_number(
             self.source, '// Set break point at this line.')
 
     # Read-write watchpoints not supported on SystemZ
     @expectedFailureAll(archs=['s390x'])

lldb/test/API/python_api/watchpoint/TestWatchpointIgnoreCount.py

 """
 Use lldb Python SBWatchpoint API to set the ignore count.
 """
 
 from __future__ import print_function
 
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
-class WatchpointIgnoreCountTestCase(TestBase):
-    NO_DEBUG_INFO_TESTCASE = True
+class WatchpointIgnoreCountTestCase(PythonAPITest):
 
     def setUp(self):
         # Call super's setUp().
-        TestBase.setUp(self)
+        PythonAPITest.setUp(self)
         # Our simple source filename.
         self.source = 'main.c'
         # Find the line number to break inside main().
         self.line = line_number(
             self.source, '// Set break point at this line.')
 
     # on arm64 targets, lldb has incorrect hit-count / ignore-counts
     # for watchpoints when they are hit with multiple threads at

lldb/test/API/python_api/watchpoint/TestWatchpointIter.py

 """
 Use lldb Python SBTarget API to iterate on the watchpoint(s) for the target.
 """
 
 from __future__ import print_function
 
 
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
-class WatchpointIteratorTestCase(TestBase):
-    NO_DEBUG_INFO_TESTCASE = True
+class WatchpointIteratorTestCase(PythonAPITest):
 
     # hardware watchpoints are not reported with a hardware index # on armv7 on ios devices
     def affected_by_radar_34564183(self):
         return (self.getArchitecture() in ['armv7', 'armv7k', 'arm64_32']) and self.platformIsDarwin()
 
     def setUp(self):
         # Call super's setUp().
-        TestBase.setUp(self)
+        PythonAPITest.setUp(self)
         # Our simple source filename.
         self.source = 'main.c'
         # Find the line number to break inside main().
         self.line = line_number(
             self.source, '// Set break point at this line.')
 
     def test_watch_iter(self):
         """Exercise SBTarget.watchpoint_iter() API to iterate on the available watchpoints."""

lldb/test/API/python_api/watchpoint/condition/TestWatchpointConditionAPI.py

 """
 Test watchpoint condition API.
 """
 
 from __future__ import print_function
 
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
-class WatchpointConditionAPITestCase(TestBase):
-    NO_DEBUG_INFO_TESTCASE = True
+class WatchpointConditionAPITestCase(PythonAPITest):
 
     def setUp(self):
         # Call super's setUp().
-        TestBase.setUp(self)
+        PythonAPITest.setUp(self)
         # Our simple source filename.
         self.source = 'main.cpp'
         # Find the line number to break inside main().
         self.line = line_number(
             self.source, '// Set break point at this line.')
         # And the watchpoint variable declaration line number.
         self.decl = line_number(self.source,
                                 '// Watchpoint variable declaration.')

lldb/test/API/python_api/watchpoint/watchlocation/TestSetWatchlocation.py

 """
 Use lldb Python SBValue.WatchPointee() API to create a watchpoint for write of '*g_char_ptr'.
 """
 
 from __future__ import print_function
 
 
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
-class SetWatchlocationAPITestCase(TestBase):
-    NO_DEBUG_INFO_TESTCASE = True
+class SetWatchlocationAPITestCase(PythonAPITest):
 
     def setUp(self):
         # Call super's setUp().
-        TestBase.setUp(self)
+        PythonAPITest.setUp(self)
         # Our simple source filename.
         self.source = 'main.cpp'
         # Find the line number to break inside main().
         self.line = line_number(
             self.source, '// Set break point at this line.')
         # This is for verifying that watch location works.
         self.violating_func = "do_bad_thing_with_location"
 

lldb/test/API/python_api/watchpoint/watchlocation/TestTargetWatchAddress.py

 """
 Use lldb Python SBtarget.WatchAddress() API to create a watchpoint for write of '*g_char_ptr'.
 """
 
 from __future__ import print_function
 
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
-class TargetWatchAddressAPITestCase(TestBase):
-    NO_DEBUG_INFO_TESTCASE = True
+class TargetWatchAddressAPITestCase(PythonAPITest):
 
     def setUp(self):
         # Call super's setUp().
-        TestBase.setUp(self)
+        PythonAPITest.setUp(self)
         # Our simple source filename.
         self.source = 'main.cpp'
         # Find the line number to break inside main().
         self.line = line_number(
             self.source, '// Set break point at this line.')
         # This is for verifying that watch location works.
         self.violating_func = "do_bad_thing_with_location"