[lldb][NFC] Remove all `setUp` overrides that only call the parent implementation

[teemperor]

Summary

A lot of our tests copied the setUp code from our TestSampleTest.py:

def setUp(self):
    # Call super's setUp().
    TestBase.setUp(self)

This code does nothing unless we actually do any setUp work in there, so let's remove all these method definitions.

[labath]

Yes, these are really annoying. Maybe it would be also good to add some language to TestSampleTest to say that you should only define this method if you actually want to do some work there..

lldb/packages/Python/lldbsuite/test/api/listeners/TestListener.py

 
 import six
 
 
 class ListenToModuleLoadedEvents (TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    def setUp(self):
-        # Call super's setUp().
-        TestBase.setUp(self)
-
     def test_receiving_breakpoint_added(self):
         """Test that we get breakpoint added events, waiting on event classes on the debugger"""
         self.build()
 
         my_listener = lldb.SBListener("test_listener")
 
         my_listener.StartListeningForEventClass(
             self.dbg,

lldb/packages/Python/lldbsuite/test/commands/apropos/basic/TestApropos.py

 import lldb
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test.decorators import *
 
 class AproposTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    def setUp(self):
-        TestBase.setUp(self)
-
     @no_debug_info_test
     def test_apropos(self):
         self.expect("apropos", error=True,
                     substrs=[' must be called with exactly one argument'])
         self.expect("apropos a b", error=True,
                     substrs=[' must be called with exactly one argument'])
         self.expect("apropos ''", error=True,
                     substrs=['\'\' is not a valid search word'])

lldb/packages/Python/lldbsuite/test/commands/command/script/import/TestImport.py

class ImportTestCase(TestBase):
     mydir = TestBase.compute_mydir(__file__)
 
     @add_test_categories(['pyapi'])
     @no_debug_info_test
     def test_import_command(self):
         """Import some Python scripts by path and test them"""
         self.run_test()
 
-    def setUp(self):
-        # Call super's setUp().
-        TestBase.setUp(self)
-
     def run_test(self):
         """Import some Python scripts by path and test them."""
 
         # This is the function to remove the custom commands in order to have a
         # clean slate for the next test case.
         def cleanup():
             self.runCmd('command script delete foo2cmd', check=False)
             self.runCmd('command script delete foocmd', check=False)

lldb/packages/Python/lldbsuite/test/commands/command/script/import/rdar-12586188/TestRdar12586188.py

class Rdar12586188TestCase(TestBase):
     mydir = TestBase.compute_mydir(__file__)
 
     @add_test_categories(['pyapi'])
     @no_debug_info_test
     def test_rdar12586188_command(self):
         """Check that we handle an ImportError in a special way when command script importing files."""
         self.run_test()
 
-    def setUp(self):
-        # Call super's setUp().
-        TestBase.setUp(self)
-
     def run_test(self):
         """Check that we handle an ImportError in a special way when command script importing files."""
 
         self.expect(
             "command script import ./fail12586188.py --allow-reload",
             error=True,
             substrs=['raise ImportError("I do not want to be imported")'])
         self.expect(
             "command script import ./fail212586188.py --allow-reload",
             error=True,
             substrs=['raise ValueError("I do not want to be imported")'])

lldb/packages/Python/lldbsuite/test/commands/disassemble/basic/TestFrameDisassemble.py

class FrameDisassembleTestCase(TestBase):
 
     NO_DEBUG_INFO_TESTCASE = True
 
     def test_frame_disassemble(self):
         """Sample test to ensure SBFrame::Disassemble produces SOME output."""
         self.build()
         self.frame_disassemble_test()
 
-    def setUp(self):
-        # Call super's setUp().
-        TestBase.setUp(self)
-
     def frame_disassemble_test(self):
         """Sample test to ensure SBFrame::Disassemble produces SOME output"""
         exe = self.getBuildArtifact("a.out")
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 

lldb/packages/Python/lldbsuite/test/commands/expression/calculator_mode/TestCalculatorMode.py

 """
 Test calling an expression without a target.
 """
 
 
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class TestCalculatorMode(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    def setUp(self):
-        # Call super's setUp().
-        TestBase.setUp(self)
-
     def test__calculator_mode(self):
         """Test calling expressions in the dummy target."""
         self.expect("expression 11 + 22", "11 + 22 didn't get the expected result", substrs=["33"])
         # Now try it with a specific language:
         self.expect("expression -l c -- 11 + 22", "11 + 22 didn't get the expected result", substrs=["33"])
 

lldb/packages/Python/lldbsuite/test/commands/expression/dont_allow_jit/TestAllowJIT.py

def test_allow_jit_expr_command(self):
         self.expr_cmd_test()
 
     def test_allow_jit_options(self):
         """Test the SetAllowJIT SBExpressionOption setting"""
         self.build()
         self.main_source_file = lldb.SBFileSpec("main.c")
         self.expr_options_test()
 
-    def setUp(self):
-        # Call super's setUp().
-        TestBase.setUp(self)
-
     def expr_cmd_test(self):
         (target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(self,
                                    "Set a breakpoint here", self.main_source_file)
 
         frame = thread.GetFrameAtIndex(0)
         
         # First make sure we can call the function with 
         interp = self.dbg.GetCommandInterpreter()

lldb/packages/Python/lldbsuite/test/commands/expression/entry-bp/TestExprEntryBP.py

def test_expr_entry_bp(self):
 
         entry_bp = target.BreakpointCreateBySBAddress(entry)
         self.assertTrue(entry_bp.IsValid(), "Can't set a breakpoint on the module entry point")
 
         result = target.EvaluateExpression("sum(7, 1)")
         self.assertTrue(result.IsValid(), "Can't evaluate expression")
         self.assertEqual(8, result.GetValueAsSigned())
 
-    def setUp(self):
-        TestBase.setUp(self)

lldb/packages/Python/lldbsuite/test/commands/expression/persistent_ptr_update/TestPersistentPtrUpdate.py

 """
 Test that we can have persistent pointer variables
 """
 
 
 
 import lldb
 import lldbsuite.test.lldbutil as lldbutil
 from lldbsuite.test.lldbtest import *
 
 
 class PersistentPtrUpdateTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    def setUp(self):
-        # Call super's setUp().
-        TestBase.setUp(self)
-
     def test(self):
         """Test that we can have persistent pointer variables"""
         self.build()
 
         def cleanup():
             pass
 
         # Execute the cleanup function during test case tear down.

lldb/packages/Python/lldbsuite/test/commands/expression/weak_symbols/TestWeakSymbols.py

class TestWeakSymbolsInExpressions(TestBase):
 
     @decorators.skipUnlessDarwin
     def test_weak_symbol_in_expr(self):
         """Tests that we can refer to weak symbols in expressions."""
         self.build()
         self.main_source_file = lldb.SBFileSpec("main.c")
         self.do_test()
 
-    def setUp(self):
-        # Call super's setUp().
-        TestBase.setUp(self)
-
     def run_weak_var_check (self, weak_varname, present):
         # The expression will modify present_weak_int to signify which branch
         # was taken.  Set it to so we don't get confused by a previous run.
         value = self.target.FindFirstGlobalVariable("present_weak_int")
         value.SetValueFromCString("0")
         if present:
             correct_value = 10
         else:

lldb/packages/Python/lldbsuite/test/commands/frame/diagnose/array/TestArray.py

 """
 Test the output of `frame diagnose` for an array access
 """
 
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class TestArray(TestBase):
     mydir = TestBase.compute_mydir(__file__)
 
-    def setUp(self):
-        TestBase.setUp(self)
-
     @skipUnlessDarwin
     @skipIfDarwinEmbedded  # <rdar://problem/33842388> frame diagnose doesn't work for armv7 or arm64
     def test_array(self):
         self.build()
         exe = self.getBuildArtifact("a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
         self.runCmd("run", RUN_SUCCEEDED)
         self.expect("thread list", "Thread should be stopped",
                     substrs=['stopped'])
         self.expect(
             "frame diagnose",
             "Crash diagnosis was accurate",
             substrs=["a[10]"])

lldb/packages/Python/lldbsuite/test/commands/frame/language/TestGuessLanguage.py

class TestFrameGuessLanguage(TestBase):
 
     @skipIf(compiler="clang", compiler_version=['<', '10.0'])
     @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr37658")
     def test_guess_language(self):
         """Test GuessLanguage for C and C++."""
         self.build()
         self.do_test()
 
-    def setUp(self):
-        # Call super's setUp().
-        TestBase.setUp(self)
-
     def check_language(self, thread, frame_no, test_lang):
         frame = thread.frames[frame_no]
         self.assertTrue(frame.IsValid(), "Frame %d was not valid."%(frame_no))
         lang = frame.GuessLanguage()
         self.assertEqual(lang, test_lang)
 
     def do_test(self):
         """Test GuessLanguage for C & C++."""

lldb/packages/Python/lldbsuite/test/commands/frame/var/TestFrameVar.py

class TestFrameVar(TestBase):
     # set this to true.  That way it won't be run once for
     # each debug info format.
     NO_DEBUG_INFO_TESTCASE = True
 
     def test_frame_var(self):
         self.build()
         self.do_test()
 
-    def setUp(self):
-        # Call super's setUp().
-        TestBase.setUp(self)
-
     def do_test(self):
         exe = self.getBuildArtifact("a.out")
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 
         # Now create a breakpoint in main.c at the source matching

lldb/packages/Python/lldbsuite/test/commands/register/register/intel_xtended_registers/TestMPXRegisters.py

 """
 Test the Intel(R) MPX registers.
 """
 
 
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class RegisterCommandsTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    def setUp(self):
-        TestBase.setUp(self)
-
     @skipIf(compiler="clang")
     @skipIf(oslist=no_match(['linux']))
     @skipIf(archs=no_match(['i386', 'x86_64']))
     @skipIf(oslist=["linux"], compiler="gcc", compiler_version=["<", "5"]) #GCC version >= 5 supports Intel(R) MPX.
     def test_mpx_registers_with_example_code(self):
         """Test Intel(R) MPX registers with example code."""
         self.build()
         self.mpx_registers_with_example_code()

lldb/packages/Python/lldbsuite/test/commands/register/register/intel_xtended_registers/mpx_offset_intersection/TestMPXOffsetIntersection.py

class MPXOffsetIntersectionTestCase(TestBase):
 
     AVX_REGS = ('ymm' + str(i) for i in range(16))
     YMM_VALUE = '{' + ' '.join(('0x00' for _ in range(32))) + '}'
 
     MPX_REGULAR_REGS = ('bnd0', 'bnd1', 'bnd2', 'bnd3')
     MPX_CONFIG_REGS = ('bndcfgu', 'bndstatus')
     BND_VALUE = '{' + ' '.join(('0xff' for _ in range(16))) + '}'
 
-    def setUp(self):
-        TestBase.setUp(self)
-
     @skipIf(oslist=no_match(['linux']))
     @skipIf(archs=no_match(['x86_64']))
     def test_mpx_registers_offset_intersection(self):
         """Test if AVX data does not overwrite MPX values."""
         self.build()
         self.mpx_registers_offset_intersection()
 
     def mpx_registers_offset_intersection(self):

lldb/packages/Python/lldbsuite/test/commands/target/stop-hooks/TestStopHooks.py

class TestStopHooks(TestBase):
     NO_DEBUG_INFO_TESTCASE = True
 
     def test_stop_hooks_step_out(self):
         """Test that stop hooks fire on step-out."""
         self.build()
         self.main_source_file = lldb.SBFileSpec("main.c")
         self.step_out_test()
 
-    def setUp(self):
-        # Call super's setUp().
-        TestBase.setUp(self)
-
     def step_out_test(self):
         (target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(self,
                                    "Set a breakpoint here", self.main_source_file)
 
         interp = self.dbg.GetCommandInterpreter()
         result = lldb.SBCommandReturnObject()
         interp.HandleCommand("target stop-hook add -o 'expr g_var++'", result)
         self.assertTrue(result.Succeeded, "Set the target stop hook")
         thread.StepOut()
         var = target.FindFirstGlobalVariable("g_var")
         self.assertTrue(var.IsValid())
         self.assertEqual(var.GetValueAsUnsigned(), 1, "Updated g_var")
 
 

lldb/packages/Python/lldbsuite/test/commands/version/TestVersion.py

 import lldb
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test.decorators import *
 
 class VersionTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    def setUp(self):
-        TestBase.setUp(self)
-
     @no_debug_info_test
     def test_version(self):
         # Should work even when people patch the output,
         # so let's just assume that every vendor at least mentions
         # 'lldb' in their version string.
         self.expect("version", substrs=['lldb'])
 
     @no_debug_info_test
     def test_version_invalid_invocation(self):
         self.expect("version a", error=True,
                     substrs=['the version command takes no arguments.'])

lldb/packages/Python/lldbsuite/test/commands/watchpoints/watchpoint_disable/TestWatchpointDisable.py

 """
 Test that the SBWatchpoint::SetEnable API works.
 """
 
 import lldb
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test.decorators import *
 from lldbsuite.test import lldbplatform, lldbplatformutil
 
 
 class TestWatchpointSetEnable(TestBase):
     mydir = TestBase.compute_mydir(__file__)
 
-    def setUp(self):
-        # Call super's setUp().
-        TestBase.setUp(self)
-
     def test_disable_works (self):
         """Set a watchpoint, disable it, and make sure it doesn't get hit."""
         self.build()
         self.do_test(False)
 
     def test_disable_enable_works (self):
         """Set a watchpoint, disable it, and make sure it doesn't get hit."""
         self.build()

lldb/packages/Python/lldbsuite/test/functionalities/breakpoint/address_breakpoints/TestAddressBreakpoints.py

class AddressBreakpointTestCase(TestBase):
 
     NO_DEBUG_INFO_TESTCASE = True
 
     def test_address_breakpoints(self):
         """Test address breakpoints set with shared library of SBAddress work correctly."""
         self.build()
         self.address_breakpoints()
 
-    def setUp(self):
-        # Call super's setUp().
-        TestBase.setUp(self)
-
     def address_breakpoints(self):
         """Test address breakpoints set with shared library of SBAddress work correctly."""
         exe = self.getBuildArtifact("a.out")
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 

lldb/packages/Python/lldbsuite/test/functionalities/breakpoint/address_breakpoints/TestBadAddressBreakpoints.py

class BadAddressBreakpointTestCase(TestBase):
 
     NO_DEBUG_INFO_TESTCASE = True
 
     def test_bad_address_breakpoints(self):
         """Test that breakpoints set on a bad address say they are bad."""
         self.build()
         self.address_breakpoints()
 
-    def setUp(self):
-        # Call super's setUp().
-        TestBase.setUp(self)
-
     def address_breakpoints(self):
         """Test that breakpoints set on a bad address say they are bad."""
         target, process, thread, bkpt = \
             lldbutil.run_to_source_breakpoint(self,
                                               "Set a breakpoint here",
                                               lldb.SBFileSpec("main.c"))
 
         # Now see if we can read from 0.  If I can't do that, I don't

lldb/packages/Python/lldbsuite/test/functionalities/breakpoint/auto_continue/TestBreakpointAutoContinue.py

def launch_it (self, expected_state):
         process = self.target.Launch(launch_info, error)
         self.assertTrue(error.Success(), "Launch failed.")
 
         state = process.GetState()
         self.assertEqual(state, expected_state, "Didn't get expected state")
 
         return process
 
-    def setUp(self):
-        # Call super's setUp().
-        TestBase.setUp(self)
-
     def simple_auto_continue(self):
         bpno = self.make_target_and_bkpt()
         process = self.launch_it(lldb.eStateExited)
 
         bkpt = self.target.FindBreakpointByID(bpno)
         self.assertEqual(bkpt.GetHitCount(), 2, "Should have run through the breakpoint twice")
 
     def auto_continue_with_command(self):

lldb/packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_language/TestBreakpointLanguage.py

 """
 Test that the language option for breakpoints works correctly
 parser.
 """
 
 
 
 import lldb
 from lldbsuite.test.lldbtest import *
 import lldbsuite.test.lldbutil as lldbutil
 
 
 class TestBreakpointLanguage(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    def setUp(self):
-        # Call super's setUp().
-        TestBase.setUp(self)
-        # Find the line number to break inside main().
-
     def check_location_file(self, bp, loc, test_name):
         bp_loc = bp.GetLocationAtIndex(loc)
         addr = bp_loc.GetAddress()
         comp_unit = addr.GetCompileUnit()
         comp_name = comp_unit.GetFileSpec().GetFilename()
         return comp_name == test_name
 
     def test_regex_breakpoint_language(self):

lldb/packages/Python/lldbsuite/test/functionalities/breakpoint/scripted_bkpt/TestScriptedResolver.py

def test_command_line(self):
         self.do_test_cli()
 
     def test_bad_command_lines(self):
         """Make sure we get appropriate errors when we give invalid key/value
            options"""
         self.build()
         self.do_test_bad_options()        
 
-    def setUp(self):
-        # Call super's setUp().
-        TestBase.setUp(self)
-
     def make_target_and_import(self):
         target = lldbutil.run_to_breakpoint_make_target(self)
         interp = self.dbg.GetCommandInterpreter()
         error = lldb.SBError()
 
         script_name = os.path.join(self.getSourceDir(), "resolver.py")
         source_name = os.path.join(self.getSourceDir(), "main.c")
 

lldb/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-caching/TestDataFormatterCaching.py

 import lldb
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test.decorators import *
 import lldbsuite.test.lldbutil as lldbutil
 
 
 class TestDataFormatterCaching(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    def setUp(self):
-        TestBase.setUp(self)
-
     def test_with_run_command(self):
         """
         Test that hardcoded summary formatter matches aren't improperly cached.
         """
         self.build()
         target, process, thread, bkpt = lldbutil.run_to_source_breakpoint(
             self, 'break here', lldb.SBFileSpec('a.c'))
         valobj = self.frame().FindVariable('f')
         self.assertEqual(valobj.GetValue(), '4')
         bkpt_b = target.BreakpointCreateBySourceRegex('break here',
                                                       lldb.SBFileSpec('b.c'))
         lldbutil.continue_to_breakpoint(process, bkpt_b)
         valobj = self.frame().FindVariable('f4')
         self.assertEqual(valobj.GetSummary(), '(1, 2, 3, 4)')

lldb/packages/Python/lldbsuite/test/functionalities/data-formatter/type_summary_list_arg/TestTypeSummaryListArg.py

 """
 Test lldb data formatter subsystem.
 """
 
 
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class TypeSummaryListArgumentTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    def setUp(self):
-        # Call super's setUp().
-        TestBase.setUp(self)
-
     @no_debug_info_test
     def test_type_summary_list_with_arg(self):
         """Test that the 'type summary list' command handles command line arguments properly"""
         self.expect(
             'type summary list Foo',
             substrs=[
                 'Category: default',
                 'Category: system'])

lldb/packages/Python/lldbsuite/test/functionalities/history/TestHistoryRecall.py

class TestHistoryRecall(TestBase):
     # set this to true.  That way it won't be run once for
     # each debug info format.
     NO_DEBUG_INFO_TESTCASE = True
 
     def test_history_recall(self):
         """Test the !N and !-N functionality of the command interpreter."""
         self.sample_test()
 
-    def setUp(self):
-        # Call super's setUp().
-        TestBase.setUp(self)
-
     def sample_test(self):
         interp = self.dbg.GetCommandInterpreter()
         result = lldb.SBCommandReturnObject()
         interp.HandleCommand("command 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("command history" in result.GetOutput(), "!0 didn't rerun command 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.")

lldb/packages/Python/lldbsuite/test/functionalities/longjmp/TestLongjmp.py

 """
 Test the use of setjmp/longjmp for non-local goto operations in a single-threaded inferior.
 """
 
 
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class LongjmpTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    def setUp(self):
-        TestBase.setUp(self)
-
     @skipIfDarwin  # llvm.org/pr16769: LLDB on Mac OS X dies in function ReadRegisterBytes in GDBRemoteRegisterContext.cpp
     @skipIfFreeBSD  # llvm.org/pr17214
     @expectedFailureAll(oslist=["linux"], bugnumber="llvm.org/pr20231")
     @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778")
     @expectedFlakeyNetBSD
     def test_step_out(self):
         """Test stepping when the inferior calls setjmp/longjmp, in particular, thread step-out."""
         self.build()

lldb/packages/Python/lldbsuite/test/functionalities/pre_run_dylibs/TestPreRunDylibs.py

 
 import unittest2
 import lldb
 from lldbsuite.test.lldbtest import *
 import lldbsuite.test.lldbutil as lldbutil
 from lldbsuite.test.decorators import *
 
 class TestPreRunLibraries(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
     NO_DEBUG_INFO_TESTCASE = True
 
-    def setUp(self):
-        # Call super's setUp().
-        TestBase.setUp(self)
-
     @skipIf(oslist=no_match(['darwin','macos']))
     def test(self):
         """Test that we find directly linked dylib pre-run."""
 
         self.build()
         target = self.dbg.CreateTarget(self.getBuildArtifact("a.out"))
         self.assertTrue(target, VALID_TARGET)
 

lldb/packages/Python/lldbsuite/test/functionalities/stats_api/TestStatisticsAPI.py

 # Test the SBAPI for GetStatistics()
 
 import json
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class TestStatsAPI(TestBase):
     mydir = TestBase.compute_mydir(__file__)
 
-    def setUp(self):
-        TestBase.setUp(self)
-
     def test_stats_api(self):
         self.build()
         exe = self.getBuildArtifact("a.out")
         target = self.dbg.CreateTarget(exe)
 
         # Test enabling/disabling stats
         self.assertFalse(target.GetCollectingStats())
         target.SetCollectingStats(True)

lldb/packages/Python/lldbsuite/test/functionalities/tail_call_frames/sbapi_support/TestTailCallFrameSBAPI.py

class TestTailCallFrameSBAPI(TestBase):
 
     @skipIf(compiler="clang", compiler_version=['<', '8.0'])
     @skipIf(dwarf_version=['<', '4'])
     @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr26265")
     def test_tail_call_frame_sbapi(self):
         self.build()
         self.do_test()
 
-    def setUp(self):
-        # Call super's setUp().
-        TestBase.setUp(self)
-
     def do_test(self):
         exe = self.getBuildArtifact("a.out")
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 
         breakpoint = target.BreakpointCreateBySourceRegex("break here",

lldb/packages/Python/lldbsuite/test/functionalities/tail_call_frames/thread_step_out_or_return/TestSteppingOutWithArtificialFrames.py

def test_return_past_artificial_frame(self):
         self.assertFalse(frame2.IsArtificial())
 
         # Ditto: stepping out of frame #2 should move to frame #4.
         thread.ReturnFromFrame(thread.GetSelectedFrame(), value)
         frame4 = thread.GetSelectedFrame()
         self.assertEqual(frame4.GetDisplayFunctionName(), "main")
         self.assertFalse(frame2.IsArtificial())
 
-    def setUp(self):
-        # Call super's setUp().
-        TestBase.setUp(self)

lldb/packages/Python/lldbsuite/test/functionalities/thread/backtrace_limit/TestBacktraceLimit.py

 """
 Test that the target.process.thread.max-backtrace-depth setting works.
 """
 
 import unittest2
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class BacktraceLimitSettingTest(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
     NO_DEBUG_INFO_TESTCASE = True
 
-    def setUp(self):
-        # Call super's setUp().
-        TestBase.setUp(self)
-
     def test_backtrace_depth(self):
         """Test that the max-backtrace-depth setting limits backtraces."""
         self.build()
         self.main_source_file = lldb.SBFileSpec("main.cpp")
         (target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(self,
                 "Set a breakpoint here", self.main_source_file)
         interp = self.dbg.GetCommandInterpreter()
         result = lldb.SBCommandReturnObject()
         interp.HandleCommand("settings set target.process.thread.max-backtrace-depth 30", result)
         self.assertEqual(True, result.Succeeded())
         self.assertEqual(30, thread.GetNumFrames())

lldb/packages/Python/lldbsuite/test/functionalities/tsan/cpp_global_location/TestTsanCPPGlobalLocation.py

class TsanCPPGlobalLocationTestCase(TestBase):
     @expectedFailureNetBSD
     @skipIfFreeBSD  # llvm.org/pr21136 runtimes not yet available by default
     @skipIfRemote
     @skipUnlessThreadSanitizer
     def test(self):
         self.build()
         self.tsan_tests()
 
-    def setUp(self):
-        # Call super's setUp().
-        TestBase.setUp(self)
-
     def tsan_tests(self):
         exe = self.getBuildArtifact("a.out")
         self.expect(
             "file " + exe,
             patterns=["Current executable set to .*a.out"])
 
         self.runCmd("run")
 

lldb/packages/Python/lldbsuite/test/functionalities/tsan/global_location/TestTsanGlobalLocation.py

class TsanGlobalLocationTestCase(TestBase):
     @expectedFailureNetBSD
     @skipIfFreeBSD  # llvm.org/pr21136 runtimes not yet available by default
     @skipIfRemote
     @skipUnlessThreadSanitizer
     def test(self):
         self.build()
         self.tsan_tests()
 
-    def setUp(self):
-        # Call super's setUp().
-        TestBase.setUp(self)
-
     def tsan_tests(self):
         exe = self.getBuildArtifact("a.out")
         self.expect(
             "file " + exe,
             patterns=["Current executable set to .*a.out"])
 
         self.runCmd("run")
 

lldb/packages/Python/lldbsuite/test/functionalities/tsan/multiple/TestTsanMultiple.py

class TsanMultipleTestCase(TestBase):
     @expectedFailureNetBSD
     @skipIfFreeBSD  # llvm.org/pr21136 runtimes not yet available by default
     @skipIfRemote
     @skipUnlessThreadSanitizer
     def test(self):
         self.build()
         self.tsan_tests()
 
-    def setUp(self):
-        # Call super's setUp().
-        TestBase.setUp(self)
-
     def tsan_tests(self):
         exe = self.getBuildArtifact("a.out")
         self.expect(
             "file " + exe,
             patterns=["Current executable set to .*a.out"])
 
         self.runCmd("env TSAN_OPTIONS=abort_on_error=0")
 

lldb/packages/Python/lldbsuite/test/functionalities/tsan/thread_numbers/TestTsanThreadNumbers.py

class TsanThreadNumbersTestCase(TestBase):
     @expectedFailureNetBSD
     @skipIfFreeBSD  # llvm.org/pr21136 runtimes not yet available by default
     @skipIfRemote
     @skipUnlessThreadSanitizer
     def test(self):
         self.build()
         self.tsan_tests()
 
-    def setUp(self):
-        # Call super's setUp().
-        TestBase.setUp(self)
-
     def tsan_tests(self):
         exe = self.getBuildArtifact("a.out")
         self.expect(
             "file " + exe,
             patterns=["Current executable set to .*a.out"])
 
         self.runCmd("run")
 

lldb/packages/Python/lldbsuite/test/functionalities/var_path/TestVarPath.py

class TestVarPath(TestBase):
     # set this to true.  That way it won't be run once for
     # each debug info format.
     NO_DEBUG_INFO_TESTCASE = True
 
     def test_frame_var(self):
         self.build()
         self.do_test()
 
-    def setUp(self):
-        # Call super's setUp().
-        TestBase.setUp(self)
-
     def verify_point(self, frame, var_name, var_typename, x_value, y_value):
         v = frame.GetValueForVariablePath(var_name)
         self.assertTrue(v.GetError().Success(), "Make sure we find '%s'" % (var_name))
         self.assertTrue(v.GetType().GetName() == var_typename, 
                         "Make sure '%s' has type '%s'" % (var_name, var_typename))
 
         if '*' in var_typename:
             valid_prefix = var_name + '->'

lldb/packages/Python/lldbsuite/test/lang/c/find_struct_type/TestFindStructTypes.py

class TestFindTypesOnStructType(TestBase):
     # each debug info format.
     NO_DEBUG_INFO_TESTCASE = True
 
     def test_find_types_struct_type(self):
         """Make sure FindTypes actually finds 'struct typename' not just 'typename'."""
         self.build()
         self.do_test()
 
-    def setUp(self):
-        # Call super's setUp().
-        TestBase.setUp(self)
-
     def do_test(self):
         """Make sure FindTypes actually finds 'struct typename' not just 'typename'."""
         exe = self.getBuildArtifact("a.out")
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 

lldb/packages/Python/lldbsuite/test/lang/c/local_types/TestUseClosestType.py

class TestUseClosestType(TestBase):
 
     @expectedFailureAll(bugnumber="<rdar://problem/53262085>")
     def test_use_in_expr(self):
         """Use the shadowed type directly, see if we get a conflicting type definition."""
         self.build()
         self.main_source_file = lldb.SBFileSpec("main.c")
         self.expr_test()
 
-    def setUp(self):
-        # Call super's setUp().
-        TestBase.setUp(self)
-
     def run_and_check_expr(self, num_children, child_type):
         frame = self.thread.GetFrameAtIndex(0)
         result = frame.EvaluateExpression("struct Foo *$mine = (struct Foo *) malloc(sizeof(struct Foo)); $mine")
         self.assertTrue(result.GetError().Success(), "Failed to parse an expression using a multiply defined type: %s"%(result.GetError().GetCString()), )
         self.assertEqual(result.GetTypeName(), "struct Foo *", "The result has the right typename.")
         self.assertEqual(result.GetNumChildren(), num_children, "Got the right number of children")
         self.assertEqual(result.GetChildAtIndex(0).GetTypeName(), child_type, "Got the right type.")
 

lldb/packages/Python/lldbsuite/test/lang/cpp/dynamic-value-same-basename/TestDynamicValueSameBase.py

class DynamicValueSameBaseTestCase(TestBase):
     NO_DEBUG_INFO_TESTCASE = True
 
     def test_same_basename_this(self):
         """Test that the we use the full name to resolve dynamic types."""
         self.build()
         self.main_source_file = lldb.SBFileSpec("main.cpp")
         self.sample_test()
 
-    def setUp(self):
-        # Call super's setUp().
-        TestBase.setUp(self)
-
     def sample_test(self):
         (target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(self,
                                    "Break here to get started", self.main_source_file)
 
         # Set breakpoints in the two class methods and run to them:
         namesp_bkpt = target.BreakpointCreateBySourceRegex("namesp function did something.", self.main_source_file)
         self.assertEqual(namesp_bkpt.GetNumLocations(), 1, "Namespace breakpoint invalid")
 

lldb/packages/Python/lldbsuite/test/lang/cpp/trivial_abi/TestTrivialABI.py

@expectedFailureAll(archs=["aarch64"], oslist=["linux"],
                         bugnumber="llvm.org/pr44161")
     @expectedFailureAll(archs=["arm64", "arm64e"], bugnumber="<rdar://problem/57844240>")
     def test_call_nontrivial(self):
         """Test that we can print a variable & call a function on the same class w/o the trivial ABI marker."""
         self.build()
         self.main_source_file = lldb.SBFileSpec("main.cpp")
         self.expr_test(False)
 
-    def setUp(self):
-        # Call super's setUp().
-        TestBase.setUp(self)
-
     def check_value(self, test_var, ivar_value):
         self.assertTrue(test_var.GetError().Success(), "Invalid valobj: %s"%(test_var.GetError().GetCString()))
         ivar = test_var.GetChildMemberWithName("ivar")
         self.assertTrue(test_var.GetError().Success(), "Failed to fetch ivar")
         self.assertEqual(ivar_value, ivar.GetValueAsSigned(), "Got the right value for ivar")
 
     def check_frame(self, thread):
         frame = thread.frames[0]

lldb/packages/Python/lldbsuite/test/lang/objc/modules-app-update/TestClangModulesAppUpdate.py

 
 import unittest2
 import os
 import shutil
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class TestClangModuleAppUpdate(TestBase):
     mydir = TestBase.compute_mydir(__file__)
 
-    def setUp(self):
-        TestBase.setUp(self)
-
     @skipUnlessDarwin
     @skipIf(debug_info=no_match(["gmodules"]))
     def test_rebuild_app_modules_untouched(self):
         with open(self.getBuildArtifact("module.modulemap"), "w") as f:
             f.write("""
                     module Foo { header "f.h" }
                     """)
         with open(self.getBuildArtifact("f.h"), "w") as f:

lldb/packages/Python/lldbsuite/test/lang/objc/modules-cache/TestClangModulesCache.py

 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class ObjCModulesTestCase(TestBase):
     NO_DEBUG_INFO_TESTCASE = True
     mydir = TestBase.compute_mydir(__file__)
 
-    def setUp(self):
-        TestBase.setUp(self)
-
     @skipUnlessDarwin
     def test_expr(self):
         self.build()
         self.main_source_file = lldb.SBFileSpec("main.m")
         self.runCmd("settings set target.auto-import-clang-modules true")
         mod_cache = self.getBuildArtifact("my-clang-modules-cache")
         if os.path.isdir(mod_cache):
           shutil.rmtree(mod_cache)

lldb/packages/Python/lldbsuite/test/lang/objc/modules-hash-mismatch/TestClangModulesHashMismatch.py

 
 import unittest2
 import os
 import shutil
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class TestClangModuleHashMismatch(TestBase):
     mydir = TestBase.compute_mydir(__file__)
 
-    def setUp(self):
-        TestBase.setUp(self)
-
     @skipUnlessDarwin
     @skipIf(debug_info=no_match(["gmodules"]))
     def test_expr(self):
         with open(self.getBuildArtifact("module.modulemap"), "w") as f:
             f.write("""
                     module Foo { header "f.h" }
                     """)
         with open(self.getBuildArtifact("f.h"), "w") as f:

lldb/packages/Python/lldbsuite/test/lang/objc/modules-inline-functions/TestModulesInlineFunctions.py

 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class ModulesInlineFunctionsTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    def setUp(self):
-        # Call super's setUp().
-        TestBase.setUp(self)
-
     @skipUnlessDarwin
     @skipIf(macos_version=["<", "10.12"], debug_info=no_match(["gmodules"]))
     def test_expr(self):
         self.build()
         exe = self.getBuildArtifact("a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         # Break inside the foo function which takes a bar_ptr argument.

lldb/packages/Python/lldbsuite/test/lang/objc/modules-update/TestClangModulesUpdate.py

 
 import unittest2
 import os
 import shutil
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class TestClangModuleUpdate(TestBase):
     mydir = TestBase.compute_mydir(__file__)
 
-    def setUp(self):
-        TestBase.setUp(self)
-
     @skipUnlessDarwin
     @skipIf(debug_info=no_match(["gmodules"]))
     def test_expr(self):
         with open(self.getBuildArtifact("module.modulemap"), "w") as f:
             f.write("""
                     module Foo { header "f.h" }
                     """)
         with open(self.getBuildArtifact("f.h"), "w") as f:

lldb/packages/Python/lldbsuite/test/lang/objcxx/cxx-bridged-po/TestObjCXXBridgedPO.py

 import lldb
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test.decorators import *
 import lldbsuite.test.lldbutil as lldbutil
 
 class TestObjCXXBridgedPO(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    def setUp(self):
-        TestBase.setUp(self)
-
     @skipUnlessDarwin
     def test_bridged_type_po(self):
         self.build()
         lldbutil.run_to_source_breakpoint(
             self, 'break here', lldb.SBFileSpec('main.mm'))
         self.expect('po num',
                     "did not get the Objective-C object description",
                     substrs=['CFNumber', '0x', '42'])
         pointer_val = str(self.frame().FindVariable('num').GetValue())
         self.expect('po '+pointer_val,
                     "did not get the Objective-C object description",
                     substrs=['CFNumber', '0x', '42'])

lldb/packages/Python/lldbsuite/test/lang/objcxx/hide-runtime-values/TestObjCXXHideRuntimeValues.py

 import lldb
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test.decorators import *
 import lldbsuite.test.lldbutil as lldbutil
 import unittest2
 
 
 class TestObjCXXHideRuntimeSupportValues(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    def setUp(self):
-        TestBase.setUp(self)
-
     @skipIfFreeBSD
     @skipIfLinux
     @skipIfWindows
     @skipIfNetBSD
     def test_hide_runtime_support_values(self):
         self.build()
         _, process, _, _ = lldbutil.run_to_source_breakpoint(
             self, 'break here', lldb.SBFileSpec('main.mm'))

lldb/packages/Python/lldbsuite/test/linux/mix-dwo-and-regular-objects/TestMixedDwarfBinary.py

 """ Testing debugging of a binary with "mixed" dwarf (with/without fission). """
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class TestMixedDwarfBinary(TestBase):
     mydir = TestBase.compute_mydir(__file__)
 
-    def setUp(self):
-        TestBase.setUp(self)
-
     @no_debug_info_test  # Prevent the genaration of the dwarf version of this test
     @add_test_categories(["dwo"])
     @skipUnlessPlatform(["linux"])
     def test_mixed_dwarf(self):
         """Test that 'frame variable' works
         for the executable built from two source files compiled
         with/whithout -gsplit-dwarf correspondingly."""
 

lldb/packages/Python/lldbsuite/test/macosx/find-app-in-bundle/TestFindAppInBundle.py

class FindAppInMacOSAppBundle(TestBase):
     NO_DEBUG_INFO_TESTCASE = True
 
     def test_find_app_in_bundle(self):
         """There can be many tests in a test case - describe this test here."""
         self.build()
         self.main_source_file = lldb.SBFileSpec("main.c")
         self.find_app_in_bundle_test()
 
-    def setUp(self):
-        # Call super's setUp().
-        TestBase.setUp(self)
-
     def find_app_in_bundle_test(self):
         """This reads in the .app, makes sure we get the right binary and can run it."""
 
         # This function starts a process, "a.out" by default, sets a source
         # breakpoint, runs to it, and returns the thread, process & target.
         # It optionally takes an SBLaunchOption argument if you want to pass
         # arguments or environment variables.
         exe = self.getBuildArtifact("TestApp.app")

lldb/packages/Python/lldbsuite/test/macosx/thread-names/TestInterruptThreadNames.py

 """Test that we get thread names when interrupting a process."""
 
 
 import time
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class TestInterruptThreadNames(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    def setUp(self):
-        # Call super's setUp().
-        TestBase.setUp(self)
-
     @skipUnlessDarwin
     @add_test_categories(['pyapi'])
     def test_with_python_api(self):
         """Test that we get thread names when interrupting a process."""
         self.build()
         exe = self.getBuildArtifact("a.out")
 
         target = self.dbg.CreateTarget(exe)

lldb/packages/Python/lldbsuite/test/macosx/version_zero/TestGetVersionZeroVersion.py

class TestGetVersionForZero(TestBase):
     # each debug info format.
     NO_DEBUG_INFO_TESTCASE = True
 
     def test_get_version_zero(self):
         """Read in a library with a version of 0.0.0.  Test SBModule::GetVersion"""
         self.yaml2obj("libDylib.dylib.yaml", self.getBuildArtifact("libDylib.dylib"))
         self.do_test()
 
-    def setUp(self):
-        # Call super's setUp().
-        TestBase.setUp(self)
-
     def do_test(self):
         lib_name = "libDylib.dylib"
         target = lldbutil.run_to_breakpoint_make_target(self, exe_name=lib_name)
         module = target.FindModule(lldb.SBFileSpec(lib_name))
         self.assertTrue(module.IsValid(), "Didn't find the libDylib.dylib module")
         # For now the actual version numbers are wrong for a library of 0.0.0
         # but the previous code would crash iterating over the resultant
         # list.  So we are testing that that doesn't happen.
         did_iterate = False
         for elem in module.GetVersion():
             did_iterate = True
         self.assertTrue(did_iterate, "Didn't get into the GetVersion loop")
 

lldb/packages/Python/lldbsuite/test/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):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    def setUp(self):
-        # Call super's setUp().
-        TestBase.setUp(self)
-
     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")
 
         self.input_file = os.path.join(

lldb/packages/Python/lldbsuite/test/python_api/sbstructureddata/TestStructuredDataAPI.py

 class TestStructuredDataAPI(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
     NO_DEBUG_INFO_TESTCASE = True
 
     def test(self):
         self.structured_data_api_test()
 
-    def setUp(self):
-        TestBase.setUp(self)
-
     @add_test_categories(['pyapi'])
     def structured_data_api_test(self):
         error = lldb.SBError()
         s = lldb.SBStream()
         s.Print(
             "{\"key_dict\":{\"key_string\":\"STRING\",\"key_int\":3,\"key_float\":2.99,\"key_bool\":true,\"key_array\":[\"23\",\"arr\"]}}")
         example = lldb.SBStructuredData()
 

lldb/packages/Python/lldbsuite/test/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):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    def setUp(self):
-        # Call super's setUp().
-        TestBase.setUp(self)
-
     @add_test_categories(['pyapi'])
     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)