[lldb] Mark several tests as not dependent on debug info

[teemperor]

Summary

This just adds NO_DEBUG_INFO_TESTCASE to tests that don't really exercise anything debug information specific
and therefore don't need to be rerun for all debug information variants.

[teemperor]

Some of the tests technically touch debug information but don't test features specific to it. If anyone thinks some of these tests are worthwhile to run with all debug information variants then let me know.

[labath]

These all seem fine to me...

lldb/packages/Python/lldbsuite/test/commands/gui/basic/TestGuiBasic.py

13 ↗

(On Diff #237047)

This shouldn't be needed as all PExpectTests set this by default...

lldb/packages/Python/lldbsuite/test/commands/platform/process/TestProcessList.py

18 ↗

(On Diff #237047)

duplicate annotation

[aprantl]

I believe that all of these make sense.

lldb/packages/Python/lldbsuite/test/python_api/rdar-12481949/Test-rdar-12481949.py

12

Do you think you could dig up that radar and rename this to something more meaningful?

[stella.stamenova]

This introduced a failure on the Windows LLDB bot (there were already other failing tests though, so maybe you missed it):

http://lab.llvm.org:8011/builders/lldb-x64-windows-ninja/builds/12554

[teemperor]

In D72447#1817559, @stella.stamenova wrote:

This introduced a failure on the Windows LLDB bot (there were already other failing tests though, so maybe you missed it):

http://lab.llvm.org:8011/builders/lldb-x64-windows-ninja/builds/12554

It seems indeed like this is causing timeouts but it's not clear how adding NO_DEBUG_INFO_TESTCASE can cause that. Anyway, I reverted the changes to the test that started timing out so that should fix it. Thanks!

lldb/packages/Python/lldbsuite/test/commands/apropos/with-process/TestAproposWithProcess.py

 """
 Test that apropos env doesn't crash trying to touch the process plugin command
 """
 
 
 
 import lldb
 from lldbsuite.test.lldbtest import *
 import lldbsuite.test.lldbutil as lldbutil
 
 
 class AproposWithProcessTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
+    NO_DEBUG_INFO_TESTCASE = True
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number to break inside main().
         self.line = line_number('main.cpp', '// break here')
 
     def test_apropos_with_process(self):

lldb/packages/Python/lldbsuite/test/commands/command/nested_alias/TestNestedAlias.py

 """
 Test that an alias can reference other aliases without crashing.
 """
 
 
 
 import lldb
 from lldbsuite.test.lldbtest import *
 import lldbsuite.test.lldbutil as lldbutil
 
 
 class NestedAliasTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
+    NO_DEBUG_INFO_TESTCASE = True
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number to break inside main().
         self.line = line_number('main.cpp', '// break here')
 
     def test_nested_alias(self):

lldb/packages/Python/lldbsuite/test/commands/command/script_alias/TestCommandScriptAlias.py

 """
 Test lldb Python commands.
 """
 
 
 
 import lldb
 from lldbsuite.test.lldbtest import *
 
 
 class CommandScriptAliasTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
+    NO_DEBUG_INFO_TESTCASE = True
 
     def test_pycmd(self):
         self.runCmd("command script import tcsacmd.py")
         self.runCmd("command script add -f tcsacmd.some_command_here attach")
 
         # This is the function to remove the custom commands in order to have a
         # clean slate for the next test case.
         def cleanup():

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__)
+    NO_DEBUG_INFO_TESTCASE = True
 
     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/process/attach-resume/TestAttachResume.py

 from lldbsuite.test import lldbutil
 
 exe_name = "AttachResume"  # Must match Makefile
 
 
 class AttachResumeTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
+    NO_DEBUG_INFO_TESTCASE = True
 
     @skipIfRemote
     @expectedFailureAll(oslist=['freebsd'], bugnumber='llvm.org/pr19310')
     @expectedFailureNetBSD
     @skipIfWindows # llvm.org/pr24778, llvm.org/pr21753
     def test_attach_continue_interrupt_detach(self):
         """Test attach/continue/interrupt/detach"""
         self.build()

lldb/packages/Python/lldbsuite/test/commands/process/launch-with-shellexpand/TestLaunchWithShellExpand.py

 """
 Test that argdumper is a viable launching strategy.
 """
 import os
 
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class LaunchWithShellExpandTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
+    NO_DEBUG_INFO_TESTCASE = True
 
     @expectedFailureAll(
         oslist=[
             "windows",
             "linux",
             "freebsd"],
         bugnumber="llvm.org/pr24778 llvm.org/pr22627")
     @skipIfDarwinEmbedded # iOS etc don't launch the binary via a shell, so arg expansion won't happen

lldb/packages/Python/lldbsuite/test/commands/statistics/basic/TestStats.py

 from lldbsuite.test import lldbinline
 from lldbsuite.test import decorators
 
 lldbinline.MakeInlineTest(
-    __file__, globals(), [])
+    __file__, globals(), [decorators.no_debug_info_test])

lldb/packages/Python/lldbsuite/test/commands/target/create-no-such-arch/TestNoSuchArch.py

 """
 Test that using a non-existent architecture name does not crash LLDB.
 """
 
 
 import lldb
 from lldbsuite.test.lldbtest import *
 import lldbsuite.test.lldbutil as lldbutil
 
 
 class NoSuchArchTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
+    NO_DEBUG_INFO_TESTCASE = True
 
     def test(self):
         self.build()
         exe = self.getBuildArtifact("a.out")
 
         # Check that passing an invalid arch via the command-line fails but
         # doesn't crash
         self.expect(

lldb/packages/Python/lldbsuite/test/commands/watchpoints/hello_watchlocation/TestWatchLocation.py

 """
 Test lldb watchpoint that uses '-s size' to watch a pointed location with size.
 """
 
 
 
 import re
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class HelloWatchLocationTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
+    NO_DEBUG_INFO_TESTCASE = True
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Our simple source filename.
         self.source = 'main.cpp'
         # Find the line number to break inside main().
         self.line = line_number(

lldb/packages/Python/lldbsuite/test/commands/watchpoints/hello_watchpoint/TestMyFirstWatchpoint.py

 """
 Test my first lldb watchpoint.
 """
 
 
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class HelloWatchpointTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
+    NO_DEBUG_INFO_TESTCASE = True
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Our simple source filename.
         self.source = 'main.c'
         # Find the line number to break inside main().
         self.line = line_number(

lldb/packages/Python/lldbsuite/test/commands/watchpoints/step_over_watchpoint/TestStepOverWatchpoint.py

 """Test stepping over watchpoints."""
 
 
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class TestStepOverWatchpoint(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
+    NO_DEBUG_INFO_TESTCASE = True
 
     @expectedFailureAll(
         oslist=["linux"],
         archs=[
             'aarch64',
             'arm'],
         bugnumber="llvm.org/pr26031")
     # Read-write watchpoints not supported on SystemZ

lldb/packages/Python/lldbsuite/test/commands/watchpoints/variable_out_of_scope/TestWatchedVarHitWhenInScope.py

 """
 Test that a variable watchpoint should only hit when in scope.
 """
 
 
 
 import unittest2
 import lldb
 from lldbsuite.test.lldbtest import *
 import lldbsuite.test.lldbutil as lldbutil
 from lldbsuite.test.decorators import *
 
 
 class WatchedVariableHitWhenInScopeTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
+    NO_DEBUG_INFO_TESTCASE = True
 
     # This test depends on not tracking watchpoint expression hits if we have
     # left the watchpoint scope.  We will provide such an ability at some point
     # but the way this was done was incorrect, and it is unclear that for the
     # most part that's not what folks mostly want, so we have to provide a
     # clearer API to express this.
 
     def setUp(self):

lldb/packages/Python/lldbsuite/test/commands/watchpoints/watchpoint_commands/TestWatchpointCommands.py

 """
 Test watchpoint list, enable, disable, and delete commands.
 """
 
 
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class WatchpointCommandsTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
+    NO_DEBUG_INFO_TESTCASE = True
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Our simple source filename.
         self.source = 'main.c'
         # Find the line number to break inside main().
         self.line = line_number(

lldb/packages/Python/lldbsuite/test/commands/watchpoints/watchpoint_commands/command/TestWatchpointCommandLLDB.py

 """
 Test 'watchpoint command'.
 """
 
 
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class WatchpointLLDBCommandTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
+    NO_DEBUG_INFO_TESTCASE = True
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Our simple source filename.
         self.source = 'main.cpp'
         # Find the line number to break inside main().
         self.line = line_number(

lldb/packages/Python/lldbsuite/test/commands/watchpoints/watchpoint_commands/command/TestWatchpointCommandPython.py

 """
 Test 'watchpoint command'.
 """
 
 
 
 import os
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class WatchpointPythonCommandTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
+    NO_DEBUG_INFO_TESTCASE = True
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Our simple source filename.
         self.source = 'main.cpp'
         # Find the line number to break inside main().
         self.line = line_number(

lldb/packages/Python/lldbsuite/test/commands/watchpoints/watchpoint_commands/condition/TestWatchpointConditionCmd.py

 """
 Test watchpoint modify command to set condition on a watchpoint.
 """
 
 
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class WatchpointConditionCmdTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
+    NO_DEBUG_INFO_TESTCASE = True
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Our simple source filename.
         self.source = 'main.cpp'
         # Find the line number to break inside main().
         self.line = line_number(

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__)
+    NO_DEBUG_INFO_TESTCASE = True
 
     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."""

lldb/packages/Python/lldbsuite/test/commands/watchpoints/watchpoint_events/TestWatchpointEvents.py

 """Test that adding, deleting and modifying watchpoints sends the appropriate events."""
 
 from __future__ import print_function
 
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class TestWatchpointEvents (TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
+    NO_DEBUG_INFO_TESTCASE = True
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line numbers that we will step to in main:
         self.main_source = "main.c"
 
     @add_test_categories(['pyapi'])

lldb/packages/Python/lldbsuite/test/commands/watchpoints/watchpoint_on_vectors/TestValueOfVectorVariable.py

 """
 Test displayed value of a vector variable while doing watchpoint operations
 """
 
 
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class TestValueOfVectorVariableTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
+    NO_DEBUG_INFO_TESTCASE = True
 
     def test_value_of_vector_variable_using_watchpoint_set(self):
         """Test verify displayed value of vector variable."""
         exe = self.getBuildArtifact("a.out")
         d = {'C_SOURCES': self.source, 'EXE': exe}
         self.build(dictionary=d)
         self.setTearDownCleanup(dictionary=d)
         self.value_of_vector_variable_with_watchpoint_set()

lldb/packages/Python/lldbsuite/test/commands/watchpoints/watchpoint_set_command/TestWatchLocationWithWatchSet.py

 """
 Test lldb watchpoint that uses 'watchpoint set -w write -s size' to watch a pointed location with size.
 """
 
 
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class WatchLocationUsingWatchpointSetTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
+    NO_DEBUG_INFO_TESTCASE = True
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Our simple source filename.
         self.source = 'main.cpp'
         # Find the line number to break inside main().
         self.line = line_number(

lldb/packages/Python/lldbsuite/test/lang/c/offsetof/TestOffsetof.py

 from lldbsuite.test import lldbinline
+from lldbsuite.test import decorators
 
-lldbinline.MakeInlineTest(__file__, globals())
+lldbinline.MakeInlineTest(__file__, globals(), [decorators.no_debug_info_test])

lldb/packages/Python/lldbsuite/test/lang/cpp/offsetof/TestOffsetofCpp.py

 from lldbsuite.test import lldbinline
+from lldbsuite.test import decorators
 
-lldbinline.MakeInlineTest(__file__, globals())
+lldbinline.MakeInlineTest(__file__, globals(), [decorators.no_debug_info_test])

lldb/packages/Python/lldbsuite/test/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):
 
     mydir = TestBase.compute_mydir(__file__)
+    NO_DEBUG_INFO_TESTCASE = True
 
     @add_test_categories(['pyapi'])
-    @no_debug_info_test
     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())
         self.dbg.CreateTargetWithFileAndTargetTriple(None, None)

lldb/packages/Python/lldbsuite/test/python_api/default-constructor/TestDefaultConstructorForAPIObjects.py

 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class APIDefaultConstructorTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
+    NO_DEBUG_INFO_TESTCASE = True
 
     @add_test_categories(['pyapi'])
-    @no_debug_info_test
     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
         sb_address.fuzz_obj(obj)
 
     @add_test_categories(['pyapi'])
-    @no_debug_info_test
     def test_SBBlock(self):
         obj = lldb.SBBlock()
         if self.TraceOn():
             print(obj)
         self.assertFalse(obj)
         # Do fuzz testing on the invalid obj, it should not crash lldb.
         import sb_block
         sb_block.fuzz_obj(obj)
 
     @add_test_categories(['pyapi'])
-    @no_debug_info_test
     def test_SBBreakpoint(self):
         obj = lldb.SBBreakpoint()
         if self.TraceOn():
             print(obj)
         self.assertFalse(obj)
         # Do fuzz testing on the invalid obj, it should not crash lldb.
         import sb_breakpoint
         sb_breakpoint.fuzz_obj(obj)
 
     @add_test_categories(['pyapi'])
-    @no_debug_info_test
     def test_SBBreakpointLocation(self):
         obj = lldb.SBBreakpointLocation()
         if self.TraceOn():
             print(obj)
         self.assertFalse(obj)
         # Do fuzz testing on the invalid obj, it should not crash lldb.
         import sb_breakpointlocation
         sb_breakpointlocation.fuzz_obj(obj)
 
     @add_test_categories(['pyapi'])
-    @no_debug_info_test
     def test_SBBreakpointName(self):
         obj = lldb.SBBreakpointName()
         if self.TraceOn():
             print(obj)
         self.assertFalse(obj)
         # Do fuzz testing on the invalid obj, it should not crash lldb.
         import sb_breakpointname
         sb_breakpointname.fuzz_obj(obj)
 
     @add_test_categories(['pyapi'])
-    @no_debug_info_test
     def test_SBBroadcaster(self):
         obj = lldb.SBBroadcaster()
         if self.TraceOn():
             print(obj)
         self.assertFalse(obj)
         # Do fuzz testing on the invalid obj, it should not crash lldb.
         import sb_broadcaster
         sb_broadcaster.fuzz_obj(obj)
 
     @add_test_categories(['pyapi'])
-    @no_debug_info_test
     def test_SBCommandReturnObject(self):
         """SBCommandReturnObject object is valid after default construction."""
         obj = lldb.SBCommandReturnObject()
         if self.TraceOn():
             print(obj)
         self.assertTrue(obj)
 
     @add_test_categories(['pyapi'])
-    @no_debug_info_test
     def test_SBCommunication(self):
         obj = lldb.SBCommunication()
         if self.TraceOn():
             print(obj)
         self.assertFalse(obj)
         # Do fuzz testing on the invalid obj, it should not crash lldb.
         import sb_communication
         sb_communication.fuzz_obj(obj)
 
     @add_test_categories(['pyapi'])
-    @no_debug_info_test
     def test_SBCompileUnit(self):
         obj = lldb.SBCompileUnit()
         if self.TraceOn():
             print(obj)
         self.assertFalse(obj)
         # Do fuzz testing on the invalid obj, it should not crash lldb.
         import sb_compileunit
         sb_compileunit.fuzz_obj(obj)
 
     @add_test_categories(['pyapi'])
-    @no_debug_info_test
     def test_SBDebugger(self):
         obj = lldb.SBDebugger()
         if self.TraceOn():
             print(obj)
         self.assertFalse(obj)
         # Do fuzz testing on the invalid obj, it should not crash lldb.
         import sb_debugger
         sb_debugger.fuzz_obj(obj)
 
     @add_test_categories(['pyapi'])
-    @no_debug_info_test
     # darwin: This test passes with swig 3.0.2, fails w/3.0.5 other tests fail
     # with 2.0.12 http://llvm.org/pr23488
     def test_SBError(self):
         obj = lldb.SBError()
         if self.TraceOn():
             print(obj)
         self.assertFalse(obj)
         # Do fuzz testing on the invalid obj, it should not crash lldb.
         import sb_error
         sb_error.fuzz_obj(obj)
 
     @add_test_categories(['pyapi'])
-    @no_debug_info_test
     def test_SBEvent(self):
         obj = lldb.SBEvent()
         # This is just to test that typemap, as defined in lldb.swig, works.
         obj2 = lldb.SBEvent(0, "abc")
         if self.TraceOn():
             print(obj)
         self.assertFalse(obj)
         # Do fuzz testing on the invalid obj, it should not crash lldb.
         import sb_event
         sb_event.fuzz_obj(obj)
 
     @add_test_categories(['pyapi'])
     def test_SBFileSpec(self):
         obj = lldb.SBFileSpec()
         # This is just to test that FileSpec(None) does not crash.
         obj2 = lldb.SBFileSpec(None, True)
         if self.TraceOn():
             print(obj)
         self.assertFalse(obj)
         # Do fuzz testing on the invalid obj, it should not crash lldb.
         import sb_filespec
         sb_filespec.fuzz_obj(obj)
 
     @add_test_categories(['pyapi'])
-    @no_debug_info_test
     def test_SBFrame(self):
         obj = lldb.SBFrame()
         if self.TraceOn():
             print(obj)
         self.assertFalse(obj)
         # Do fuzz testing on the invalid obj, it should not crash lldb.
         import sb_frame
         sb_frame.fuzz_obj(obj)
 
     @add_test_categories(['pyapi'])
-    @no_debug_info_test
     def test_SBFunction(self):
         obj = lldb.SBFunction()
         if self.TraceOn():
             print(obj)
         self.assertFalse(obj)
         # Do fuzz testing on the invalid obj, it should not crash lldb.
         import sb_function
         sb_function.fuzz_obj(obj)
 
     @add_test_categories(['pyapi'])
-    @no_debug_info_test
     def test_SBFile(self):
         sbf = lldb.SBFile()
         self.assertFalse(sbf.IsValid())
         self.assertFalse(bool(sbf))
         e, n = sbf.Write(b'foo')
         self.assertTrue(e.Fail())
         self.assertEqual(n, 0)
         buffer = bytearray(100)
         e, n = sbf.Read(buffer)
         self.assertEqual(n, 0)
         self.assertTrue(e.Fail())
 
     @add_test_categories(['pyapi'])
-    @no_debug_info_test
     def test_SBInstruction(self):
         obj = lldb.SBInstruction()
         if self.TraceOn():
             print(obj)
         self.assertFalse(obj)
         # Do fuzz testing on the invalid obj, it should not crash lldb.
         import sb_instruction
         sb_instruction.fuzz_obj(obj)
 
     @add_test_categories(['pyapi'])
-    @no_debug_info_test
     def test_SBInstructionList(self):
         obj = lldb.SBInstructionList()
         if self.TraceOn():
             print(obj)
         self.assertFalse(obj)
         # Do fuzz testing on the invalid obj, it should not crash lldb.
         import sb_instructionlist
         sb_instructionlist.fuzz_obj(obj)
 
     @add_test_categories(['pyapi'])
-    @no_debug_info_test
     def test_SBLineEntry(self):
         obj = lldb.SBLineEntry()
         if self.TraceOn():
             print(obj)
         self.assertFalse(obj)
         # Do fuzz testing on the invalid obj, it should not crash lldb.
         import sb_lineentry
         sb_lineentry.fuzz_obj(obj)
 
     @add_test_categories(['pyapi'])
-    @no_debug_info_test
     def test_SBListener(self):
         obj = lldb.SBListener()
         if self.TraceOn():
             print(obj)
         self.assertFalse(obj)
         # Do fuzz testing on the invalid obj, it should not crash lldb.
         import sb_listener
         sb_listener.fuzz_obj(obj)
 
     @add_test_categories(['pyapi'])
-    @no_debug_info_test
     # Py3 asserts due to a bug in SWIG.  Trying to upstream a patch to fix
     # this in 3.0.8
     @skipIf(py_version=['>=', (3, 0)], swig_version=['<', (3, 0, 8)])
     def test_SBModule(self):
         obj = lldb.SBModule()
         if self.TraceOn():
             print(obj)
         self.assertFalse(obj)
         # Do fuzz testing on the invalid obj, it should not crash lldb.
         import sb_module
         sb_module.fuzz_obj(obj)
 
     @add_test_categories(['pyapi'])
-    @no_debug_info_test
     def test_SBProcess(self):
         obj = lldb.SBProcess()
         if self.TraceOn():
             print(obj)
         self.assertFalse(obj)
         # Do fuzz testing on the invalid obj, it should not crash lldb.
         import sb_process
         sb_process.fuzz_obj(obj)
 
     @add_test_categories(['pyapi'])
-    @no_debug_info_test
     def test_SBProcessInfo(self):
         obj = lldb.SBProcessInfo()
         if self.TraceOn():
             print(obj)
         self.assertFalse(obj)
         # Do fuzz testing on the invalid obj, it should not crash lldb.
         import sb_process_info
         sb_process_info.fuzz_obj(obj)
 
     @add_test_categories(['pyapi'])
-    @no_debug_info_test
     def test_SBSection(self):
         obj = lldb.SBSection()
         if self.TraceOn():
             print(obj)
         self.assertFalse(obj)
         # Do fuzz testing on the invalid obj, it should not crash lldb.
         import sb_section
         sb_section.fuzz_obj(obj)
 
     @add_test_categories(['pyapi'])
-    @no_debug_info_test
     def test_SBStream(self):
         """SBStream object is valid after default construction."""
         obj = lldb.SBStream()
         if self.TraceOn():
             print(obj)
         self.assertTrue(obj)
 
     @add_test_categories(['pyapi'])
-    @no_debug_info_test
     def test_SBStringList(self):
         obj = lldb.SBStringList()
         if self.TraceOn():
             print(obj)
         self.assertFalse(obj)
         # Do fuzz testing on the invalid obj, it should not crash lldb.
         import sb_stringlist
         sb_stringlist.fuzz_obj(obj)
 
     @add_test_categories(['pyapi'])
-    @no_debug_info_test
     def test_SBSymbol(self):
         obj = lldb.SBSymbol()
         if self.TraceOn():
             print(obj)
         self.assertFalse(obj)
         # Do fuzz testing on the invalid obj, it should not crash lldb.
         import sb_symbol
         sb_symbol.fuzz_obj(obj)
 
     @add_test_categories(['pyapi'])
-    @no_debug_info_test
     def test_SBSymbolContext(self):
         obj = lldb.SBSymbolContext()
         if self.TraceOn():
             print(obj)
         self.assertFalse(obj)
         # Do fuzz testing on the invalid obj, it should not crash lldb.
         import sb_symbolcontext
         sb_symbolcontext.fuzz_obj(obj)
 
     @add_test_categories(['pyapi'])
-    @no_debug_info_test
     def test_SBSymbolContextList(self):
         """SBSymbolContextList object is valid after default construction."""
         obj = lldb.SBSymbolContextList()
         if self.TraceOn():
             print(obj)
         self.assertTrue(obj)
 
     @add_test_categories(['pyapi'])
-    @no_debug_info_test
     def test_SBTarget(self):
         obj = lldb.SBTarget()
         if self.TraceOn():
             print(obj)
         self.assertFalse(obj)
         # Do fuzz testing on the invalid obj, it should not crash lldb.
         import sb_target
         sb_target.fuzz_obj(obj)
 
     @add_test_categories(['pyapi'])
-    @no_debug_info_test
     def test_SBThread(self):
         obj = lldb.SBThread()
         if self.TraceOn():
             print(obj)
         self.assertFalse(obj)
         # Do fuzz testing on the invalid obj, it should not crash lldb.
         import sb_thread
         sb_thread.fuzz_obj(obj)
 
     @add_test_categories(['pyapi'])
-    @no_debug_info_test
     def test_SBType(self):
         try:
             obj = lldb.SBType()
             if self.TraceOn():
                 print(obj)
             self.assertFalse(obj)
             # If we reach here, the test fails.
             self.fail("lldb.SBType() should fail, not succeed!")
         except:
             # Exception is expected.
             return
 
         # Unreachable code because lldb.SBType() should fail.
         # Do fuzz testing on the invalid obj, it should not crash lldb.
         import sb_type
         sb_type.fuzz_obj(obj)
 
     @add_test_categories(['pyapi'])
-    @no_debug_info_test
     def test_SBTypeList(self):
         """SBTypeList object is valid after default construction."""
         obj = lldb.SBTypeList()
         if self.TraceOn():
             print(obj)
         self.assertTrue(obj)
 
     @add_test_categories(['pyapi'])
-    @no_debug_info_test
     def test_SBValue(self):
         obj = lldb.SBValue()
         if self.TraceOn():
             print(obj)
         self.assertFalse(obj)
         # Do fuzz testing on the invalid obj, it should not crash lldb.
         import sb_value
         sb_value.fuzz_obj(obj)
 
     @add_test_categories(['pyapi'])
-    @no_debug_info_test
     def test_SBValueList(self):
         obj = lldb.SBValueList()
         if self.TraceOn():
             print(obj)
         self.assertFalse(obj)
         # Do fuzz testing on the invalid obj, it should not crash lldb.
         import sb_valuelist
         sb_valuelist.fuzz_obj(obj)
 
     @add_test_categories(['pyapi'])
-    @no_debug_info_test
     def test_SBWatchpoint(self):
         obj = lldb.SBWatchpoint()
         if self.TraceOn():
             print(obj)
         self.assertFalse(obj)
         # Do fuzz testing on the invalid obj, it should not crash lldb.
         import sb_watchpoint
         sb_watchpoint.fuzz_obj(obj)

lldb/packages/Python/lldbsuite/test/python_api/event/TestEvents.py

 from lldbsuite.test import lldbutil
 
 
 @skipIfLinux   # llvm.org/pr25924, sometimes generating SIGSEGV
 @skipIfDarwin
 class EventAPITestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
+    NO_DEBUG_INFO_TESTCASE = True
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number to of function 'c'.
         self.line = line_number(
             'main.c', '// Find the line number of function "c" here.')
 

lldb/packages/Python/lldbsuite/test/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):
 
     mydir = TestBase.compute_mydir(__file__)
+    NO_DEBUG_INFO_TESTCASE = True
 
     @add_test_categories(['pyapi'])
     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/packages/Python/lldbsuite/test/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):
 
     mydir = TestBase.compute_mydir(__file__)
+    NO_DEBUG_INFO_TESTCASE = True
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         self.line = line_number('main.cpp', '// Set break point at this line.')
 
     @add_test_categories(['pyapi'])
     def test_formatters_api(self):

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

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__)
+    NO_DEBUG_INFO_TESTCASE = True
 
     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/packages/Python/lldbsuite/test/python_api/rdar-12481949/Test-rdar-12481949.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 Radar12481949DataFormatterTestCase(TestBase):
 
     # test for rdar://problem/12481949
     mydir = TestBase.compute_mydir(__file__)
+    NO_DEBUG_INFO_TESTCASE = True
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number to break at.
         self.line = line_number('main.cpp', '// Set break point at this line.')
 
     def test_with_run_command(self):

lldb/packages/Python/lldbsuite/test/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):
 
     mydir = TestBase.compute_mydir(__file__)
+    NO_DEBUG_INFO_TESTCASE = True
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number to break on inside main.cpp.
         self.line = line_number('main.cpp', '// set breakpoint here')
 
     @add_test_categories(['pyapi'])

lldb/packages/Python/lldbsuite/test/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):
 
     mydir = TestBase.compute_mydir(__file__)
+    NO_DEBUG_INFO_TESTCASE = True
 
     @add_test_categories(['pyapi'])
     @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/packages/Python/lldbsuite/test/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):
     mydir = TestBase.compute_mydir(__file__)
+    NO_DEBUG_INFO_TESTCASE = True
 
     @add_test_categories(['pyapi'])
     @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/packages/Python/lldbsuite/test/python_api/value/linked_list/TestValueAPILinkedList.py

 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class ValueAsLinkedListTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
+    NO_DEBUG_INFO_TESTCASE = True
 
     def setUp(self):
         # Call super's setUp().
         TestBase.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')

lldb/packages/Python/lldbsuite/test/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):
 
     mydir = TestBase.compute_mydir(__file__)
+    NO_DEBUG_INFO_TESTCASE = True
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Our simple source filename.
         self.source = 'main.c'
         # Find the line number to break inside main().
         self.line = line_number(

lldb/packages/Python/lldbsuite/test/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):
 
     mydir = TestBase.compute_mydir(__file__)
+    NO_DEBUG_INFO_TESTCASE = True
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Our simple source filename.
         self.source = 'main.c'
         # Find the line number to break inside main().
         self.line = line_number(

lldb/packages/Python/lldbsuite/test/python_api/watchpoint/TestWatchpointIter.py

 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class WatchpointIteratorTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
+    NO_DEBUG_INFO_TESTCASE = True
 
     # 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)

lldb/packages/Python/lldbsuite/test/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):
 
     mydir = TestBase.compute_mydir(__file__)
+    NO_DEBUG_INFO_TESTCASE = True
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Our simple source filename.
         self.source = 'main.cpp'
         # Find the line number to break inside main().
         self.line = line_number(

lldb/packages/Python/lldbsuite/test/python_api/watchpoint/watchlocation/TestSetWatchlocation.py

 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class SetWatchlocationAPITestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
+    NO_DEBUG_INFO_TESTCASE = True
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Our simple source filename.
         self.source = 'main.cpp'
         # Find the line number to break inside main().
         self.line = line_number(

lldb/packages/Python/lldbsuite/test/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):
 
     mydir = TestBase.compute_mydir(__file__)
+    NO_DEBUG_INFO_TESTCASE = True
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Our simple source filename.
         self.source = 'main.cpp'
         # Find the line number to break inside main().
         self.line = line_number(