Merge dsym and dwarf test cases

[tberghammer]

Summary

Merge dsym and dwarf test cases

Currently most of the test files have a separate dwarf and a separate dsym test with almost identical content (only the build step is different). With adding dwo symbol file handling to the test suit it would increase this to a 3-way duplication. The purpose of this change is to eliminate this redundancy with generating 2 test case (one dwarf and one dsym) for each test function specified (dwo handling will be added at a later commit).

Main design goals:

• There should be no boilerplate code in each test file to support the multiple debug info in most of the tests (custom scenarios are acceptable in special cases) so adding a new test case is easier and we can't miss one of the debug info type
• In case of a test failure, the debug symbols used during the test run have to be cleanly visible from the output of dotest.py to make debugging easier both from build bot logs and from local test runs
• Each test case should have a unique, fully qualified name so we can run exactly 1 test with "-f <test-case>.<test-function>" syntax
• Test output should be grouped based on test files the same way as it happens now (displaying dwarf/dsym results separately isn't preferable)

Proposed solution (main logic in lldbtest.py, rest of them are test cases fixed up for the new style):

• Have only 1 test fuction in the test files what will run for all debug info separately and this test function should call just "self.build(...)" to build an inferior with the right debug info
• When a class is created by python (the class object, not the class instance), we will generate a new test method for each debug info format in the test class with the name "<test-function>_<debug-info>" and remove the original test method. This way unittest2 see multiple test methods (1 for each debug info, pretty much as of now) and will handle the test selection and the failure reporting correctly (the debug info will be visible from the end of the test name)
• Add new annotation @no_debug_info_test to disable the generation of multiple tests for each debug info format when the test don't have an inferior

[emaste]

Haven't reviewed in depth yet but in general I really like this idea.

test/lldbtest.py

524

...as a test that doesn't use...

[clayborg]

I like the idea. One question I have is if tests should opt in to multi-debug, or if tests should opt out. This solution does the opt out method. Would it be better to opt in? With something like:

@debug_info_test
def test_stuff(self):
    # ...

I am fine with either, I am just checking in case people have a preference and which one makes more sense. I like opting out because most of our tests will probably need the multiple debug info formats. Also, are we verifying that the compiler supports each different kind of mode? Or do we just try it and we would fail of the compiler say didn't handle DWO debugging?

[clayborg]

Also if the compiler doesn't support the different modes do we avoid mutating the classes? Or if we disable the extra DWARF in .o file mode (be it DWO or Apple) do we avoid mutating the classes?

[tberghammer]

I decided to make it an opt-out feature as most of the test case will use some debug info and this way you don't have to specify it explicitly (mutating a test what don't have any debug info only have performance hit because it will run the same test multiple times).

About mutating, my current plan is to mutate every test isn't marked as no_debug_info_test and mark the test with dwarf_test / dsym_test / dwo_test annotations. The purpose of these annotation would be to enable the debug info based test filtering (e.g. the already existing "-N dwarf" option) and it should also test if the current system (compiler, OS) supports the given debug info format and skip the test if necessary (the dsym_test annotation already skip the test on non-darwin systems).

Other option is to generate the mutated tests only on platforms where they are supported. It have the advantage of removing a huge number of skipped tests and reducing the noise with it, but it also makes it more difficult to compare platforms (and possibly mask away some basic coding errors). I don't have a strong opinion about the two options so if somebody have preferences then let me know.

[zturner]

This is great, I've been thinking about implementing the exact same thing
myself.

Is it possible to remove the need to call self.build()? It seems like the
the wrapped_run function could do it before invoking the actual test
method. This way a large majority of tests could be made simpler.

If you want to customize the build process, you could use a decorator like:

@build_properties(build=False)

or

@build_properties(build=True, clean=False)

or

@build_properties(dictionary={foo})

If no @build_properties decorator is present, it just calls self.build()
before invoking the test.

Thoughts?

[tberghammer]

Update all tests to use the new dsym/dwarf generation method where applicable and do minor cleanups on the tests:

• Inline methods where the number of call sites decreased to 1
• Remove trivial setUp() methods
• Fix incorrect skip/xfail markings

At the current stage there are no regression on Linux (x86_64, i386) /Android (arm).

On OSX there are 3 new test what are failing after this change because beforehand they were running only with dsym and currently the dwarf version of them is failing (we haven't tested them before). The list of test cases where this issue happens:

• TestHiddenIvars
• TestObjCIvarStripped
• TestObjCStaticMethodStripped

Greg: What should I do with these cases? (Should I disable them as they shouldn't run with dwarf, should I XFAIL them or should I just let them being failed?)

Ed, Zachary: I haven't tested this change on FreeBSD/Windows. I expect no regression there but it would be good if you can try it out and let me know how it goes.

Further plans with the test suit (based on available resources):

• Add logic to run tests with dwo debug info
• Possibly implement the suggestion of Zachary about moving the build stage into the wrapper function (I am nor sure it will help the readability too much)
• Possibly remove the setUp functions from the test cases where their content can be moved to other functions without code duplication (in several case it just initialize a line_number variable)

[zturner]

I am at CppCon all week. If you need to get this in before Monday, can you
have Oleksiy or Chaoren test on Windows? Otherwise I can take a look next
week.

[clayborg]

Looks good. For the failing test cases, just check this stuff in and we should take care or marking any needed tests and expected fail. Is there a way to mark a test such that the "dwarf in .o files" will expected fail if we need to do that? If there currently isn't, we need to add the ability to say that normal dwarf (dSYM file for MacOSX or dwarf in object file for all other platforms), DWO, and dwarf in .o files (apple) can be marked as expected fail, skip, etc...

[tberghammer]

In D13028#250822, @clayborg wrote:

Looks good. For the failing test cases, just check this stuff in and we should take care or marking any needed tests and expected fail. Is there a way to mark a test such that the "dwarf in .o files" will expected fail if we need to do that? If there currently isn't, we need to add the ability to say that normal dwarf (dSYM file for MacOSX or dwarf in object file for all other platforms), DWO, and dwarf in .o files (apple) can be marked as expected fail, skip, etc...

I added an [expectedFailure,expectedFlakey,skipIf][Dwarf,Dsym] (will add Dwo whit the rest of the dwo specific logic) decorators and we can also specify the debug info for expectedFailureAll. If we need more decorators then we can add them the first time we have to use them (the debug info fomrat is stored in self.debug_info as a string)

[zturner]

At some point I really would love to reduce the number of decorators. It's
starting to get ridiculous :)

Seems like we only need one decorator that takes everything as optional
arguments

[tfiala]

LGTM as well. Thanks!

[tberghammer]

Re-base to ToT.

I plan to commit this CL in on Wednesday morning if there is no objection from Windows/FreeBSD side.

[emaste]

No objection from me on the FreeBSD side. I'm leaving shortly to travel to EuroBSDCon so probably will not be able to test before Wednesday, but I can investigate and update decorators as appropriate afterwards.

[emaste]

I'm leaving shortly to travel to EuroBSDCon so probably will not be able to test before Wednesday, but I can investigate and update decorators as appropriate afterwards.

A follow up - the tests look good on FreeBSD after this change. On my branch with a few updates to FreeBSD expected failure decorators,

[1/1] Testing LLDB (parallel execution, with a separate subprocess per test)
Testing: 399 test suites, 8 threads
399 out of 399 test suites processed - TestMiFile.py                           
Ran 399 test suites (0 failed) (0.000000%)
Ran 322 test cases (0 failed) (0.000000%)

Unexpected Successes (1)
UNEXPECTED SUCCESS: LLDB (suite) :: TestRecursiveInferior.py (FreeBSD feynman 10.2-STABLE FreeBSD 10.2-STABLE #44 r288174+7644546(stable-10): Thu Sep 24 14:02:11 EDT 2015     emaste@feynman:/tank/emaste/obj/tank/emaste/src/git-stable-10/sys/GENERIC amd64 amd64)
      224.52 real       665.99 user       366.72 sys

[zturner]

Hi Tamas,

This breaks TestBuiltinTrap on Windows. Do you have any insight about why
this might be happening? That test is not modified at all by this patch
from what I can tell, but a bisect pinpoints this CL as the reason for the
failure.

[zturner]

Actually nevermind, the changed file list was cut off by the email, so I didn't see that it had been modified. It looks like you just didn't copy over the @skipIfWindows decorator. I can fix that easily, sorry for the noise.

test/arm_emulation/TestEmulations.py

 """
 Test some ARM instruction emulation.
 """
 
 import os, time
 import unittest2
 import lldb
 from lldbtest import *
 
 class ARMEmulationTestCase(TestBase):
     
     mydir = TestBase.compute_mydir(__file__)
 
+    @no_debug_info_test
     def test_thumb_emulations (self):
         current_dir = os.getcwd();
         test_dir = os.path.join (current_dir, "new-test-files")
         files = os.listdir (test_dir)
         thumb_files = list()
         for f in files:
             if '-thumb.dat' in f:
                 thumb_files.append (f)
                 
         for f in thumb_files:
             test_file = os.path.join (test_dir, f)
             self.run_a_single_test (test_file)
 
-
+    @no_debug_info_test
     def test_arm_emulations (self):
         current_dir = os.getcwd();
         test_dir = os.path.join (current_dir, "new-test-files")
         files = os.listdir (test_dir)
         arm_files = list()
         for f in files:
             if '-arm.dat' in f:
                 arm_files.append (f)

test/benchmarks/continue/TestBenchmarkContinue.py

 """
 Test lldb data formatter subsystem.
 """
 
 import os, time
 import unittest2
 import lldb
 from lldbbench import *
 import lldbutil
 
 class TestBenchmarkContinue(BenchBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @benchmarks_test
-    @skipUnlessDarwin
-    @dsym_test
-    def test_with_dsym_and_run_command(self):
+    def test_run_command(self):
         """Benchmark different ways to continue a process"""
-        self.buildDsym()
-        self.data_formatter_commands()
-
-    @benchmarks_test
-    @dwarf_test
-    def test_with_dwarf_and_run_command(self):
-        """Benchmark different ways to continue a process"""
-        self.buildDwarf()
+        self.build()
         self.data_formatter_commands()
 
     def setUp(self):
         # Call super's setUp().
         BenchBase.setUp(self)
 
     def data_formatter_commands(self):
         """Benchmark different ways to continue a process"""

test/benchmarks/disassembly/TestDisassembly.py

def setUp(self):
         self.function = 'Driver::MainLoop()'
         self.lldb_avg = None
         self.gdb_avg = None
         self.count = lldb.bmIterationCount
         if self.count <= 0:
             self.count = 5
 
     @benchmarks_test
+    @no_debug_info_test
     @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     def test_run_lldb_then_gdb(self):
         """Test disassembly on a large function with lldb vs. gdb."""
         print
         print "lldb path: %s" % lldbtest_config.lldbExec
         print "gdb path: %s" % self.gdbExec
 
         print
         self.run_lldb_disassembly(self.exe, self.function, self.count)
         print "lldb benchmark:", self.stopwatch
         self.run_gdb_disassembly(self.exe, self.function, self.count)
         print "gdb benchmark:", self.stopwatch
         print "lldb_avg/gdb_avg: %f" % (self.lldb_avg/self.gdb_avg)
 
     @benchmarks_test
+    @no_debug_info_test
     @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     def test_run_gdb_then_lldb(self):
         """Test disassembly on a large function with lldb vs. gdb."""
         print
         print "lldb path: %s" % lldbtest_config.lldbExec
         print "gdb path: %s" % self.gdbExec
 
         print

test/benchmarks/disassembly/TestDoAttachThenDisassembly.py

def setUp(self):
             self.exe = lldb.bmExecutable
         else:
             self.exe = lldbtest_config.lldbExec
         self.count = lldb.bmIterationCount
         if self.count <= 0:
             self.count = 10
 
     @benchmarks_test
+    @no_debug_info_test
     def test_attach_then_disassembly(self):
         """Attach to a spawned lldb process then run disassembly benchmarks."""
         print
         self.run_lldb_attach_then_disassembly(self.exe, self.count)
         print "lldb disassembly benchmark:", self.stopwatch
 
     def run_lldb_attach_then_disassembly(self, exe, count):
         target = self.dbg.CreateTarget(exe)

test/benchmarks/disassembly/TestXcode41Vs42GDBDisassembly.py

def setUp(self):
         self.function = 'Driver::MainLoop()'
         self.gdb_41_avg = None
         self.gdb_42_avg = None
         self.count = lldb.bmIterationCount
         if self.count <= 0:
             self.count = 5
 
     @benchmarks_test
+    @no_debug_info_test
     @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     def test_run_41_then_42(self):
         """Test disassembly on a large function with 4.1 vs. 4.2's gdb."""
         print
         self.run_gdb_disassembly(self.gdb_41_exe, self.exe, self.function, self.count)
         print "4.1 gdb benchmark:", self.stopwatch
         self.gdb_41_avg = self.stopwatch.avg()
         self.run_gdb_disassembly(self.gdb_42_exe, self.exe, self.function, self.count)
         print "4.2 gdb benchmark:", self.stopwatch
         self.gdb_42_avg = self.stopwatch.avg()
         print "gdb_42_avg/gdb_41_avg: %f" % (self.gdb_42_avg/self.gdb_41_avg)
 
     @benchmarks_test
+    @no_debug_info_test
     @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     def test_run_42_then_41(self):
         """Test disassembly on a large function with 4.1 vs. 4.2's gdb."""
         print
         self.run_gdb_disassembly(self.gdb_42_exe, self.exe, self.function, self.count)
         print "4.2 gdb benchmark:", self.stopwatch
         self.gdb_42_avg = self.stopwatch.avg()
         self.run_gdb_disassembly(self.gdb_41_exe, self.exe, self.function, self.count)

test/benchmarks/expression/TestExpressionCmd.py

def setUp(self):
         self.count = lldb.bmIterationCount
         if self.count <= 0:
             self.count = 25
 
     @benchmarks_test
     @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     def test_expr_cmd(self):
         """Test lldb's expression commands and collect statistics."""
-        self.buildDefault()
+        self.build()
         self.exe_name = 'a.out'
 
         print
         self.run_lldb_repeated_exprs(self.exe_name, self.count)
         print "lldb expr cmd benchmark:", self.stopwatch
 
     def run_lldb_repeated_exprs(self, exe_name, count):
         import pexpect

test/benchmarks/expression/TestRepeatedExprs.py

def setUp(self):
         self.count = lldb.bmIterationCount
         if self.count <= 0:
             self.count = 100
 
     @benchmarks_test
     @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     def test_compare_lldb_to_gdb(self):
         """Test repeated expressions with lldb vs. gdb."""
-        self.buildDefault()
+        self.build()
         self.exe_name = 'a.out'
 
         print
         self.run_lldb_repeated_exprs(self.exe_name, self.count)
         print "lldb benchmark:", self.stopwatch
         self.run_gdb_repeated_exprs(self.exe_name, self.count)
         print "gdb benchmark:", self.stopwatch
         print "lldb_avg/gdb_avg: %f" % (self.lldb_avg/self.gdb_avg)

test/benchmarks/frame_variable/TestFrameVariableResponse.py

def setUp(self):
         else:
             self.break_spec = '-n main'
 
         self.count = lldb.bmIterationCount
         if self.count <= 0:
             self.count = 20
 
     @benchmarks_test
+    @no_debug_info_test
     @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     def test_startup_delay(self):
         """Test response time for the 'frame variable' command."""
         print
         self.run_frame_variable_bench(self.exe, self.break_spec, self.count)
         print "lldb frame variable benchmark:", self.stopwatch
 
     def run_frame_variable_bench(self, exe, break_spec, count):

test/benchmarks/startup/TestStartupDelays.py

def setUp(self):
         else:
             self.break_spec = '-n main'
 
         self.count = lldb.bmIterationCount
         if self.count <= 0:
             self.count = 30
 
     @benchmarks_test
+    @no_debug_info_test
     @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     def test_startup_delay(self):
         """Test start up delays creating a target, setting a breakpoint, and run to breakpoint stop."""
         print
         self.run_startup_delays_bench(self.exe, self.break_spec, self.count)
         print "lldb startup delay (create fresh target) benchmark:", self.stopwatch
         print "lldb startup delay (set first breakpoint) benchmark:", self.stopwatch2
         print "lldb startup delay (run to breakpoint) benchmark:", self.stopwatch3

test/benchmarks/stepping/TestRunHooksThenSteppings.py

class RunHooksThenSteppingsBench(BenchBase):
 
     def setUp(self):
         BenchBase.setUp(self)
         self.count = lldb.bmIterationCount
         if self.count <= 0:
             self.count = 50
 
     @benchmarks_test
+    @no_debug_info_test
     @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     def test_lldb_runhooks_then_steppings(self):
         """Test lldb steppings on a large executable."""
         print
         self.run_lldb_runhooks_then_steppings(self.count)
         print "lldb stepping benchmark:", self.stopwatch
 
     def run_lldb_runhooks_then_steppings(self, count):

test/benchmarks/stepping/TestSteppingSpeed.py

def setUp(self):
         self.count = lldb.bmIterationCount
         if self.count <= 0:
             self.count = 50
 
         #print "self.exe=%s" % self.exe
         #print "self.break_spec=%s" % self.break_spec
 
     @benchmarks_test
+    @no_debug_info_test
     @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     def test_run_lldb_steppings(self):
         """Test lldb steppings on a large executable."""
         print
         self.run_lldb_steppings(self.exe, self.break_spec, self.count)
         print "lldb stepping benchmark:", self.stopwatch
 
     def run_lldb_steppings(self, exe, break_spec, count):

test/benchmarks/turnaround/TestCompileRunToBreakpointTurnaround.py

def setUp(self):
         self.count = lldb.bmIterationCount
         if self.count <= 0:
             self.count = 3
 
         self.lldb_avg = None
         self.gdb_avg = None
 
     @benchmarks_test
+    @no_debug_info_test
     @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     def test_run_lldb_then_gdb(self):
         """Benchmark turnaround time with lldb vs. gdb."""
         print
         self.run_lldb_turnaround(self.exe, self.function, self.count)
         print "lldb turnaround benchmark:", self.stopwatch
         self.run_gdb_turnaround(self.exe, self.function, self.count)
         print "gdb turnaround benchmark:", self.stopwatch

test/driver/batch_mode/TestBatchMode.py

 except:
     pexpect = None
 from lldbtest import *
 
 class DriverBatchModeTest (TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @skipUnlessDarwin
     @skipIfRemote # test not remote-ready llvm.org/pr24813
-    @dsym_test
-    def test_driver_batch_mode_with_dsym(self):
-        """Test that the lldb driver's batch mode works correctly."""
-        self.buildDsym()
-        self.setTearDownCleanup()
-        self.batch_mode ()
-
     @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
-    @skipIfRemote # test not remote-ready llvm.org/pr24813
-    @dwarf_test
-    def test_driver_batch_mode_with_dwarf(self):
+    def test_driver_batch_mode(self):
         """Test that the lldb driver's batch mode works correctly."""
-        self.buildDwarf()
+        self.build()
         self.setTearDownCleanup()
         self.batch_mode()
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Our simple source filename.
         self.source = 'main.c'
 
     def expect_string (self, string):
         """This expects for "string", with timeout & EOF being test fails."""
         try:
             self.child.expect_exact(string)
         except pexpect.EOF:
             self.fail ("Got EOF waiting for '%s'"%(string))
         except pexpect.TIMEOUT:
             self.fail ("Timed out waiting for '%s'"%(string))
 
-
     def batch_mode (self):
         exe = os.path.join(os.getcwd(), "a.out")
         prompt = "(lldb) "
 
         # First time through, pass CRASH so the process will crash and stop in batch mode.
         run_commands = ' -b -o "break set -n main" -o "run" -o "continue" -k "frame var touch_me_not"'
         self.child = pexpect.spawn('%s %s %s %s -- CRASH' % (lldbtest_config.lldbExec, self.lldbOption, run_commands, exe))
         child = self.child
def batch_mode (self):
         self.expect_string ("continue")
         # The App should have not have crashed:
         self.expect_string("Got there on time and it did not crash.")
         # Then we should have a live prompt:
         self.expect_string ("exited")
         index = self.child.expect([pexpect.EOF, pexpect.TIMEOUT])
         self.assertTrue(index == 0, "lldb didn't close on successful batch completion.")
 
-        
-       
-
-        
-        
-
-
-

test/expression_command/call-function/TestCallStdStringFunction.py

class ExprCommandCallFunctionTestCase(TestBase):
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number to break for main.c.
         self.line = line_number('main.cpp',
                                 '// Please test these expressions while stopped at this line:')
 
-    @skipUnlessDarwin
-    @dsym_test
-    def test_with_dsym(self):
-        """Test calling std::String member function."""
-        self.buildDsym()
-        self.call_function()
-
-    @dwarf_test
-    @expectedFailureFreeBSD('llvm.org/pr17807') # Fails on FreeBSD buildbot
     @expectedFailureIcc # llvm.org/pr14437, fails with ICC 13.1
+    @expectedFailureFreeBSD('llvm.org/pr17807') # Fails on FreeBSD buildbot
     @expectedFailureWindows("llvm.org/pr21765")
-    def test_with_dwarf(self):
-        """Test calling std::String member function."""
-        self.buildDwarf()
-        self.call_function()
-
-    def call_function(self):
+    def test_with_dsym(self):
         """Test calling std::String member function."""
+        self.build()
         self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
 
         # Some versions of GCC encode two locations for the 'return' statement in main.cpp
         lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=-1, loc_exact=True)
 
         self.runCmd("run", RUN_SUCCEEDED)
 
         self.expect("print str",

test/expression_command/call-function/TestCallStopAndContinue.py

def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number to break for main.c.
         self.line = line_number('main.cpp',
                                 '// Please test these expressions while stopped at this line:')
         self.func_line = line_number ('main.cpp', 
                                 '{ 5, "five" }')
 
-    @skipUnlessDarwin
-    @dsym_test
-    @expectedFlakeyDarwin("llvm.org/pr20274")
-    def test_with_dsym(self):
-        """Test gathering result from interrupted function call."""
-        self.buildDsym()
-        self.call_function()
-
-    @dwarf_test
     @expectedFlakeyDarwin("llvm.org/pr20274")
     @expectedFailureWindows("llvm.org/pr24489: Name lookup not working correctly on Windows")
-    def test_with_dwarf(self):
-        """Test gathering result from interrupted function call."""
-        self.buildDwarf()
-        self.call_function()
-
-    def call_function(self):
+    def test(self):
         """Test gathering result from interrupted function call."""
+        self.build()
         self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
 
         # Some versions of GCC encode two locations for the 'return' statement in main.cpp
         lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=-1, loc_exact=True)
 
         self.runCmd("run", RUN_SUCCEEDED)
 
         lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.func_line, num_expected_locations=-1, loc_exact=True)

test/expression_command/call-function/TestCallUserDefinedFunction.py

class ExprCommandCallUserDefinedFunction(TestBase):
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number to break for main.c.
         self.line = line_number('main.cpp',
                                 '// Please test these expressions while stopped at this line:')
-    @skipUnlessDarwin
-    @dsym_test
-    @expectedFailureDarwin("llvm.org/pr20274") # intermittent failure on MacOSX
-    def test_with_dsym(self):
-        """Test return values of user defined function calls."""
-        self.buildDsym()
-        self.call_function()
-
-    @dwarf_test
+    @expectedFailureDarwin("llvm.org/pr20274", debug_info=["dsym"]) # intermittent failure on MacOSX
     @expectedFailureWindows("llvm.org/pr24489: Name lookup not working correctly on Windows")
-    def test_with_dwarf(self):
-        """Test return values of user defined function calls."""
-        self.buildDwarf()
-        self.call_functions()
-
-    def call_functions(self):
+    def test(self):
         """Test return values of user defined function calls."""
+        self.build()
 
         # Set breakpoint in main and run exe
         self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
         lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=-1, loc_exact=True)
 
         self.runCmd("run", RUN_SUCCEEDED)
 
         # Test recursive function call.

test/expression_command/call-restarts/TestCallThatRestarts.py

class ExprCommandThatRestartsTestCase(TestBase):
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
 
         self.main_source = "lotta-signals.c"
         self.main_source_spec = lldb.SBFileSpec (self.main_source)
 
-
-    @skipUnlessDarwin
-    @dsym_test
-    @skipIfDarwin # llvm.org/pr19246: intermittent failure
-    def test_with_dsym(self):
-        """Test calling std::String member function."""
-        self.buildDsym()
-        self.call_function()
-
     @dwarf_test
     @skipIfFreeBSD # llvm.org/pr19246: intermittent failure
     @skipIfDarwin # llvm.org/pr19246: intermittent failure
     @skipIfWindows # Test relies on signals, unsupported on Windows
-    def test_with_dwarf(self):
-        """Test calling std::String member function."""
-        self.buildDwarf()
+    def test(self):
+        """Test calling function that hits a signal and restarts."""
+        self.build()
         self.call_function()
 
     def check_after_call (self, num_sigchld):
         after_call = self.sigchld_no.GetValueAsSigned(-1)
         self.assertTrue (after_call - self.start_sigchld_no == num_sigchld, "Really got %d SIGCHLD signals through the call."%(num_sigchld))
         self.start_sigchld_no = after_call
 
         # Check that we are back where we were before:
         frame = self.thread.GetFrameAtIndex(0)
         self.assertTrue (self.orig_frame_pc == frame.GetPC(), "Restored the zeroth frame correctly")
 
-        
     def call_function(self):
-        """Test calling function that hits a signal and restarts."""
         exe_name = "a.out"
         exe = os.path.join(os.getcwd(), exe_name)
 
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
         empty = lldb.SBFileSpec()
         breakpoint = target.BreakpointCreateBySourceRegex('Stop here in main.',self.main_source_spec)
         self.assertTrue(breakpoint.GetNumLocations() > 0, VALID_BREAKPOINT)

test/expression_command/call-throws/TestCallThatThrows.py

class ExprCommandWithThrowTestCase(TestBase):
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
 
         self.main_source = "call-throws.m"
         self.main_source_spec = lldb.SBFileSpec (self.main_source)
 
-
-    @skipUnlessDarwin
-    @dsym_test
-    def test_with_dsym(self):
-        """Test calling a function that throws and ObjC exception."""
-        self.buildDsym()
-        self.call_function()
-
     @skipUnlessDarwin
-    @dwarf_test
-    def test_with_dwarf(self):
+    def test(self):
         """Test calling a function that throws and ObjC exception."""
-        self.buildDwarf()
+        self.build()
         self.call_function()
 
     def check_after_call (self):
         # Check that we are back where we were before:
         frame = self.thread.GetFrameAtIndex(0)
         self.assertTrue (self.orig_frame_pc == frame.GetPC(), "Restored the zeroth frame correctly")
 
         

test/expression_command/expr-in-syscall/TestExpressionInSyscall.py

 """Test that we are able to evaluate expressions when the inferior is blocked in a syscall"""
 
 import os
 import unittest2
 import lldb
 from lldbtest import *
 import lldbutil
 
 
 class ExprSyscallTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @skipUnlessDarwin
-    @dsym_test
-    def test_setpgid_with_dsym(self):
-        self.buildDsym()
-        self.expr_syscall()
-
-    @dwarf_test
     @expectedFailureWindows("llvm.org/pr21765") # Also getpid() is not a function on Windows anyway
-    def test_setpgid_with_dwarf(self):
-        self.buildDwarf()
+    def test_setpgid(self):
+        self.build()
         self.expr_syscall()
 
     def expr_syscall(self):
         exe = os.path.join(os.getcwd(), 'a.out')
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)

test/expression_command/formatters/TestFormatters.py

class ExprFormattersTestCase(TestBase):
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number to break for main.cpp.
         self.line = line_number('main.cpp',
                                 '// Stop here')
 
-    @skipUnlessDarwin
-    @dsym_test
-    def test_with_dsym(self):
-        """Test expr + formatters for good interoperability."""
-        self.buildDsym()
-        self.do_my_test()
-
     @skipIfFreeBSD # llvm.org/pr24691 skipping to avoid crashing the test runner
     @expectedFailureFreeBSD('llvm.org/pr19011') # Newer Clang omits C1 complete object constructor
     @expectedFailureFreeBSD('llvm.org/pr24691') # we hit an assertion in clang
     @expectedFailureWindows("llvm.org/pr21765")
     @skipIfTargetAndroid() # skipping to avoid crashing the test runner
     @expectedFailureAndroid('llvm.org/pr24691') # we hit an assertion in clang
-    @dwarf_test
     def test_with_dwarf(self):
         """Test expr + formatters for good interoperability."""
-        self.buildDwarf()
-        self.do_my_test()
-
-    def do_my_test(self):
-        
+        self.build()
         # This is the function to remove the custom formats in order to have a
         # clean slate for the next test case.
         def cleanup():
             self.runCmd('type summary clear', check=False)
             self.runCmd('type synthetic clear', check=False)
         
         # Execute the cleanup function during test case tear down.
         self.addTearDownHook(cleanup)

test/expression_command/issue_11588/Test11588.py

def test_11581_commands(self):
         def cleanup():
             self.runCmd('type synthetic clear', check=False)
 
 
         # Execute the cleanup function during test case tear down.
         self.addTearDownHook(cleanup)
 
         """valobj.AddressOf() should return correct values."""
-        self.buildDefault()
+        self.build()
         
         exe = os.path.join(os.getcwd(), "a.out")
         
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 
         breakpoint = target.BreakpointCreateBySourceRegex('Set breakpoint here.',lldb.SBFileSpec ("main.cpp", False))
         

test/expression_command/options/TestExprOptions.py

def setUp(self):
 
         self.main_source = "main.cpp"
         self.main_source_spec = lldb.SBFileSpec (self.main_source)
         self.line = line_number('main.cpp', '// breakpoint_in_main')
         self.exe = os.path.join(os.getcwd(), "a.out")
 
     def test_expr_options(self):
         """These expression command options should work as expected."""
-        self.buildDefault()
+        self.build()
 
         # Set debugger into synchronous mode
         self.dbg.SetAsync(False)
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(self.exe)
         self.assertTrue(target, VALID_TARGET)
 

test/expression_command/persist_objc_pointeetype/TestPersistObjCPointeeType.py

class PersistObjCPointeeType(TestBase):
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number to break for main.cpp.
         self.line = line_number('main.m','// break here')
 
     @skipUnlessDarwin
-    @dsym_test
     @expectedFailureAll(
         bugnumber='http://llvm.org/pr23504',
         oslist=['macosx'], compiler='clang', compiler_version=['<', '7.0.0'])
     def test_with_dsym(self):
         """Test that we can p *objcObject"""
-        self.buildDsym()
-        self.do_my_test()
+        self.build()
 
-    @skipUnlessDarwin
-    @dwarf_test
-    @expectedFailureAll(
-        bugnumber='http://llvm.org/pr23504',
-        oslist=['macosx'], compiler='clang', compiler_version=['<', '7.0.0'])
-    def test_with_dwarf(self):
-        """Test that we can p *objcObject"""
-        self.buildDwarf()
-        self.do_my_test()
-
-    def do_my_test(self):
         def cleanup():
             pass
 
         # Execute the cleanup function during test case tear down.
         self.addTearDownHook(cleanup)
 
         self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
 

test/expression_command/persistent_ptr_update/TestPersistentPtrUpdate.py

 class PersistentPtrUpdateTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
 
-    @skipUnlessDarwin
-    @dsym_test
-    def test_with_dsym(self):
+    def test(self):
         """Test that we can have persistent pointer variables"""
-        self.buildDsym()
-        self.do_my_test()
+        self.build()
 
-    @skipUnlessDarwin
-    @dwarf_test
-    def test_with_dwarf(self):
-        """Test that we can have persistent pointer variables"""
-        self.buildDwarf()
-        self.do_my_test()
-
-    def do_my_test(self):
         def cleanup():
             pass
         
         # Execute the cleanup function during test case tear down.
         self.addTearDownHook(cleanup)
 
         self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
         

test/expression_command/persistent_types/TestNestedPersistentTypes.py

 """
 Test that nested persistent types work.
 """
 
 import os, time
 import unittest2
 import lldb
 from lldbtest import *
 
 class NestedPersistentTypesTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @expectedFailureWindows("llvm.org/pr21765")
     def test_persistent_types(self):
         """Test that nested persistent types work."""
-        self.buildDefault()
+        self.build()
 
         self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
 
         self.runCmd("breakpoint set --name main")
 
         self.runCmd("run", RUN_SUCCEEDED)
 
         self.runCmd("expression struct $foo { int a; int b; };")

test/expression_command/persistent_types/TestPersistentTypes.py

 """
 Test that lldb persistent types works correctly.
 """
 
 import os, time
 import unittest2
 import lldb
 from lldbtest import *
 
 class PersistenttypesTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @expectedFailureWindows("llvm.org/pr21765")
     def test_persistent_types(self):
         """Test that lldb persistent types works correctly."""
-        self.buildDefault()
+        self.build()
 
         self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
 
         self.runCmd("breakpoint set --name main")
 
         self.runCmd("run", RUN_SUCCEEDED)
 
         self.runCmd("expression struct $foo { int a; int b; };")

test/expression_command/persistent_variables/TestPersistentVariables.py

 """
 Test that lldb persistent variables works correctly.
 """
 
 import os, time
 import unittest2
 import lldb
 from lldbtest import *
 
 class PersistentVariablesTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     def test_persistent_variables(self):
         """Test that lldb persistent variables works correctly."""
-        self.buildDefault()
+        self.build()
 
         self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
 
         self.runCmd("breakpoint set --source-pattern-regexp break")
 
         self.runCmd("run", RUN_SUCCEEDED)
 
         self.runCmd("expression int $i = i")

test/expression_command/po_verbosity/TestPoVerbosity.py

class PoVerbosityTestCase(TestBase):
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number to break for main.cpp.
         self.line = line_number('main.m',
                                 '// Stop here')
 
     @skipUnlessDarwin
-    @dsym_test
-    def test_with_dsym(self):
+    def test(self):
         """Test that the po command acts correctly."""
-        self.buildDsym()
-        self.do_my_test()
-
-    @skipUnlessDarwin
-    @dwarf_test
-    def test_with_dwarf(self):
-        """Test that the po command acts correctly."""
-        self.buildDwarf()
-        self.do_my_test()
-
-    def do_my_test(self):
+        self.build()
         
         # This is the function to remove the custom formats in order to have a
         # clean slate for the next test case.
         def cleanup():
             self.runCmd('type summary clear', check=False)
             self.runCmd('type synthetic clear', check=False)
         
         # Execute the cleanup function during test case tear down.

test/expression_command/radar_8638051/Test8638051.py

 """
 Test the robustness of lldb expression parser.
 """
 
 import os, time
 import unittest2
 import lldb
 from lldbtest import *
 
 class Radar8638051TestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     def test_expr_commands(self):
         """The following expression commands should not crash."""
-        self.buildDefault()
+        self.build()
 
         self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
 
         self.runCmd("breakpoint set -n c")
 
         self.runCmd("run", RUN_SUCCEEDED)
 
         self.expect("expression val",

test/expression_command/radar_9531204/TestPrintfAfterUp.py

 class Radar9531204TestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     # rdar://problem/9531204
     @expectedFailureWindows("llvm.org/pr21765")
     def test_expr_commands(self):
         """The evaluating printf(...) after break stop and then up a stack frame."""
-        self.buildDefault()
+        self.build()
 
         self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
 
         lldbutil.run_break_set_by_symbol (self, 'foo', sym_exact=True, num_expected_locations=1)
 
         self.runCmd("run", RUN_SUCCEEDED)
 
         self.runCmd("frame variable")

test/expression_command/radar_9673664/TestExprHelpExamples.py

def setUp(self):
         TestBase.setUp(self)
         # Find the line number to break inside main().
         self.main_source = "main.c"
         self.line = line_number(self.main_source, '// Set breakpoint here.')
 
     @expectedFailureWindows("llvm.org/pr21765")
     def test_expr_commands(self):
         """The following expression commands should just work."""
-        self.buildDefault()
+        self.build()
 
         self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
 
         lldbutil.run_break_set_by_file_and_line (self, self.main_source, self.line, num_expected_locations=1, loc_exact=True)
 
         self.runCmd("run", RUN_SUCCEEDED)
 
         # rdar://problem/9673664 lldb expression evaluation problem

test/expression_command/test/TestExprs.py

def setUp(self):
 
         # Disable confirmation prompt to avoid infinite wait
         self.runCmd("settings set auto-confirm true")
         self.addTearDownHook(lambda: self.runCmd("settings clear auto-confirm"))
 
 
     def build_and_run(self):
         """These basic expression commands should work as expected."""
-        self.buildDefault()
+        self.build()
 
         self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
 
         lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=False)
 
         self.runCmd("run", RUN_SUCCEEDED)
 
     @unittest2.expectedFailure("llvm.org/pr17135 <rdar://problem/14874559> APFloat::toString does not identify the correct (i.e. least) precision.")
def test_many_expr_commands(self):
                        "a.out"])
         # (const char *) $8 = 0x... "/Volumes/data/lldb/svn/trunk/test/expression_command/test/a.out"
 
     @python_api_test
     @expectedFailureAll("llvm.org/pr23139", oslist=["linux"], compiler="gcc", compiler_version=[">=","4.9"], archs=["i386"])
     @expectedFailureWindows # Test crashes
     def test_evaluate_expression_python(self):
         """Test SBFrame.EvaluateExpression() API for evaluating an expression."""
-        self.buildDefault()
+        self.build()
 
         exe = os.path.join(os.getcwd(), "a.out")
 
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 
         # Create the breakpoint.
         filespec = lldb.SBFileSpec("main.cpp", False)
def test_evaluate_expression_python(self):
         self.assertTrue (value.GetValueAsSigned(0) == 2)
         self.assertTrue (callee_break.GetHitCount() == 2)
 
     # rdar://problem/8686536
     # CommandInterpreter::HandleCommand is stripping \'s from input for WantsRawCommand commands
     @expectedFailureWindows("llvm.org/pr21765")
     def test_expr_commands_can_handle_quotes(self):
         """Throw some expression commands with quotes at lldb."""
-        self.buildDefault()
+        self.build()
 
         self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
 
         lldbutil.run_break_set_by_file_and_line(self, "main.cpp", self.line, num_expected_locations=1,loc_exact=False)
 
         self.runCmd("run", RUN_SUCCEEDED)
 
         # runCmd: expression 'a'

test/expression_command/timeout/TestCallWithTimeout.py

class ExprCommandWithTimeoutsTestCase(TestBase):
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
 
         self.main_source = "wait-a-while.cpp"
         self.main_source_spec = lldb.SBFileSpec (self.main_source)
 
 
-    @skipUnlessDarwin
-    @dsym_test
-    def test_with_dsym(self):
-        """Test calling std::String member function."""
-        self.buildDsym()
-        self.call_function()
-
     @expectedFlakeyFreeBSD("llvm.org/pr19605")
     @expectedFlakeyLinux("llvm.org/pr20275")
     @expectedFailureWindows("llvm.org/pr21765")
-    @dwarf_test
-    def test_with_dwarf(self):
+    def test(self):
         """Test calling std::String member function."""
-        self.buildDwarf()
-        self.call_function()
+        self.build()
 
-    def call_function(self):
-        """Test calling function with timeout."""
         exe_name = "a.out"
         exe = os.path.join(os.getcwd(), exe_name)
 
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 
         breakpoint = target.BreakpointCreateBySourceRegex('stop here in main.',self.main_source_spec)
         self.assertTrue(breakpoint, VALID_BREAKPOINT)

test/expression_command/two-files/TestObjCTypeQueryFromOtherCompileUnit.py

class ObjCTypeQueryTestCase(TestBase):
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number to break for main.m.
         self.line = line_number('main.m',
                                 "// Set breakpoint here, then do 'expr (NSArray*)array_token'.")
 
     @skipUnlessDarwin
-    @dsym_test
-    def test_with_dsym(self):
-        """The expression parser's type search should be wider than the current compilation unit."""
-        self.buildDsym()
-        self.type_query_from_other_cu()
-
-    @skipUnlessDarwin
-    @dwarf_test
     def test_with_dwarf(self):
         """The expression parser's type search should be wider than the current compilation unit."""
-        self.buildDwarf()
-        self.type_query_from_other_cu()
-
-    def type_query_from_other_cu(self):
-        """The expression parser's type search should be wider than the current compilation unit."""
+        self.build()
         self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
 
         lldbutil.run_break_set_by_file_and_line (self, "main.m", self.line, num_expected_locations=1, loc_exact=True)
 
         self.runCmd("run", RUN_SUCCEEDED)
 
         # Now do a NSArry type query from the 'main.m' compile uint.
         self.expect("expression (NSArray*)array_token",

test/functionalities/abbreviation/TestAbbreviations.py

 """
 Test some lldb command abbreviations and aliases for proper resolution.
 """
 
 import os, time
 import unittest2
 import lldb
 from lldbtest import *
 import lldbutil
 
 class AbbreviationsTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @expectedFlakeyFreeBSD("llvm.org/pr22611 thread race condition breaks prompt setting")
+    @no_debug_info_test
     def test_command_abbreviations_and_aliases (self):
         command_interpreter = self.dbg.GetCommandInterpreter()
         self.assertTrue(command_interpreter, VALID_COMMAND_INTERPRETER)
         result = lldb.SBCommandReturnObject()
 
         # Check that abbreviations are expanded to the full command.
         command_interpreter.ResolveCommand("ap script", result)
         self.assertTrue(result.Succeeded())

test/functionalities/abbreviation/TestCommonShortSpellings.py

 """
 Test some lldb command abbreviations to make sure the common short spellings of
 many commands remain available even after we add/delete commands in the future.
 """
 
 import os, time
 import unittest2
 import lldb
 from lldbtest import *
 import lldbutil
 
 class CommonShortSpellingsTestCase(TestBase):
     
     mydir = TestBase.compute_mydir(__file__)
 
+    @no_debug_info_test
     def test_abbrevs2 (self):
         command_interpreter = self.dbg.GetCommandInterpreter()
         self.assertTrue(command_interpreter, VALID_COMMAND_INTERPRETER)
         result = lldb.SBCommandReturnObject()
 
         abbrevs = [
             ('br s', 'breakpoint set'),
             ('disp', '_regexp-display'),  # a.k.a., 'display'

test/functionalities/archives/TestBSDArchives.py

 """Test breaking inside functions defined within a BSD archive file libfoo.a."""
 
 import os, time
 import unittest2
 import lldb
 from lldbtest import *
 import lldbutil
 
 class BSDArchivesTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @expectedFailureWindows("llvm.org/pr24527") # Makefile.rules doesn't know how to build static libs on Windows.
-    def test_with_dwarf(self):
-        """Break inside a() and b() defined within libfoo.a."""
-        self.buildDwarf()
-        self.break_inside_bsd_archives()
-
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number in a(int) to break at.
         self.line = line_number('a.c', '// Set file and line breakpoint inside a().')
 
-    def break_inside_bsd_archives(self):
+    @expectedFailureWindows("llvm.org/pr24527") # Makefile.rules doesn't know how to build static libs on Windows.
+    def test(self):
         """Break inside a() and b() defined within libfoo.a."""
+        self.build()
+
         exe = os.path.join(os.getcwd(), "a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         # Break inside a() by file and line first.
         lldbutil.run_break_set_by_file_and_line (self, "a.c", self.line, num_expected_locations=1, loc_exact=True)
 
         self.runCmd("run", RUN_SUCCEEDED)
 

test/functionalities/asan/TestMemoryHistory.py

 class AsanTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     # The default compiler ("clang") may not support Address Sanitizer or it
     # may not have the debugging API which was recently added, so we're calling
     # self.useBuiltClang() to use clang from the llvm-build directory instead
 
-    @dsym_test
-    @skipIfRemote
-    @skipUnlessCompilerRt
-    @skipUnlessDarwin
-    def test_with_dsym (self):
-        compiler = self.findBuiltClang ()
-        self.buildDsym (None, compiler)
-        self.asan_tests ()
-
-    @dwarf_test
     @expectedFailureLinux # non-core functionality, need to reenable and fix later (DES 2014.11.07)
     @skipIfFreeBSD # llvm.org/pr21136 runtimes not yet available by default
     @skipIfRemote
     @skipUnlessCompilerRt
-    def test_with_dwarf (self):
+    def test (self):
         compiler = self.findBuiltClang ()
-        self.buildDwarf (None, compiler)
+        self.build (None, compiler)
         self.asan_tests ()
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         self.line_malloc = line_number('main.c', '// malloc line')
         self.line_malloc2 = line_number('main.c', '// malloc2 line')
         self.line_free = line_number('main.c', '// free line')

test/functionalities/asan/TestReportData.py

 class AsanTestReportDataCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     # The default compiler ("clang") may not support Address Sanitizer or it
     # may not have the debugging API which was recently added, so we're calling
     # self.useBuiltClang() to use clang from the llvm-build directory instead
 
-    @dsym_test
-    @skipIfRemote
-    @skipUnlessCompilerRt
-    @skipUnlessDarwin
-    def test_with_dsym (self):
-        compiler = self.findBuiltClang ()
-        self.buildDsym (None, compiler)
-        self.asan_tests ()
-
-    @dwarf_test
     @expectedFailureLinux # non-core functionality, need to reenable and fix later (DES 2014.11.07)
     @skipIfFreeBSD # llvm.org/pr21136 runtimes not yet available by default
     @skipIfRemote
     @skipUnlessCompilerRt
-    def test_with_dwarf (self):
+    def test(self):
         compiler = self.findBuiltClang ()
-        self.buildDwarf (None, compiler)
+        self.build (None, compiler)
         self.asan_tests ()
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         self.line_malloc = line_number('main.c', '// malloc line')
         self.line_malloc2 = line_number('main.c', '// malloc2 line')
         self.line_free = line_number('main.c', '// free line')

test/functionalities/attach_resume/TestAttachResume.py

 """
 Test process attach/resume.
 """
 
 import os, time
 import unittest2
 import lldb
 from lldbtest import *
 import lldbutil
 
 exe_name = "AttachResume"  # Must match Makefile
 
 class AttachResumeTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
+    @skipIfRemote
     @expectedFailureFreeBSD('llvm.org/pr19310')
     @expectedFlakeyLinux('llvm.org/pr19310')
     @expectedFailureWindows("llvm.org/pr24778")
-    @skipIfRemote
-    @dwarf_test
     def test_attach_continue_interrupt_detach(self):
         """Test attach/continue/interrupt/detach"""
-        self.buildDwarf()
+        self.build()
         self.process_attach_continue_interrupt_detach()
 
-    @skipIfRemote
     def process_attach_continue_interrupt_detach(self):
         """Test attach/continue/interrupt/detach"""
 
         exe = os.path.join(os.getcwd(), exe_name)
 
         popen = self.spawnSubprocess(exe)
         self.addTearDownHook(self.cleanupSubprocesses)
 

test/functionalities/avoids-fd-leak/TestFdLeak.py

class AvoidsFdLeakTestCase(TestBase):
 
     @expectedFailure(python_leaky_fd_version, "bugs.freebsd.org/197376")
     @skipIfWindows # The check for descriptor leakage needs to be implemented differently here.
     @skipIfTargetAndroid() # Android have some other file descriptors open by the shell
     def test_fd_leak_log (self):
         self.do_test(["log enable -f '/dev/null' lldb commands"])
 
     def do_test (self, commands):
-        self.buildDefault()
+        self.build()
         exe = os.path.join (os.getcwd(), "a.out")
 
         for c in commands:
             self.runCmd(c)
 
         target = self.dbg.CreateTarget(exe)
 
         process = target.LaunchSimple (None, None, self.get_process_working_directory())
         self.assertTrue(process, PROCESS_IS_VALID)
 
         self.assertTrue(process.GetState() == lldb.eStateExited, "Process should have exited.")
         self.assertTrue(process.GetExitStatus() == 0,
                 "Process returned non-zero status. Were incorrect file descriptors passed?")
 
     @expectedFailure(python_leaky_fd_version, "bugs.freebsd.org/197376")
     @expectedFlakeyLinux
     @skipIfWindows # The check for descriptor leakage needs to be implemented differently here.
     @skipIfTargetAndroid() # Android have some other file descriptors open by the shell
     def test_fd_leak_multitarget (self):
-        self.buildDefault()
+        self.build()
         exe = os.path.join (os.getcwd(), "a.out")
 
         target = self.dbg.CreateTarget(exe)
         breakpoint = target.BreakpointCreateBySourceRegex ('Set breakpoint here', lldb.SBFileSpec ("main.c", False))
         self.assertTrue(breakpoint, VALID_BREAKPOINT)
 
         process1 = target.LaunchSimple (None, None, self.get_process_working_directory())
         self.assertTrue(process1, PROCESS_IS_VALID)

test/functionalities/backticks/TestBackticksWithoutATarget.py

 """
 Test that backticks without a target should work (not infinite looping).
 """
 
 import os, time
 import unittest2
 import lldb
 from lldbtest import *
 
 class BackticksWithNoTargetTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
+    @no_debug_info_test
     def test_backticks_no_target(self):
         """A simple test of backticks without a target."""
         self.expect("print `1+2-3`",
             substrs = [' = 0'])
 
 if __name__ == '__main__':
     import atexit
     lldb.SBDebugger.Initialize()
     atexit.register(lambda: lldb.SBDebugger.Terminate())
     unittest2.main()

test/functionalities/breakpoint/breakpoint_command/TestBreakpointCommand.py

class BreakpointCommandTestCase(TestBase):
     mydir = TestBase.compute_mydir(__file__)
 
     @classmethod
     def classCleanup(cls):
         """Cleanup the test byproduct of breakpoint_command_sequence(self)."""
         cls.RemoveTempFile("output.txt")
         cls.RemoveTempFile("output2.txt")
 
-    @skipUnlessDarwin
-    @dsym_test
-    def test_with_dsym(self):
-        """Test a sequence of breakpoint command add, list, and delete."""
-        self.buildDsym()
-        self.breakpoint_command_sequence()
-        self.breakpoint_command_script_parameters ()
-
-    @dwarf_test
     @expectedFailureWindows("llvm.org/pr24528")
-    def test_with_dwarf(self):
+    def test(self):
         """Test a sequence of breakpoint command add, list, and delete."""
-        self.buildDwarf()
+        self.build()
         self.breakpoint_command_sequence()
         self.breakpoint_command_script_parameters ()
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number to break inside main().
         self.line = line_number('main.c', '// Set break point at this line.')

test/functionalities/breakpoint/breakpoint_command/TestBreakpointCommandsFromPython.py

 """
 Test that you can set breakpoint commands successfully with the Python API's:
 """
 
 import os
 import re
 import unittest2
 import lldb, lldbutil
 import sys
 from lldbtest import *
 
 class PythonBreakpointCommandSettingTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
     my_var = 10
 
-    @skipUnlessDarwin
     @python_api_test
-    @dsym_test
-    def test_step_out_with_dsym_python(self):
+    def test_step_out_python(self):
         """Test stepping out using avoid-no-debug with dsyms."""
-        self.buildDsym()
-        self.do_set_python_command_from_python()
-
-    @python_api_test
-    @dwarf_test
-    def test_step_out_with_dwarf_python(self):
-        """Test stepping out using avoid-no-debug with dsyms."""
-        self.buildDwarf()
+        self.build()
         self.do_set_python_command_from_python ()
 
     def setUp (self):
         TestBase.setUp(self)
         self.main_source = "main.c"
         self.main_source_spec = lldb.SBFileSpec(self.main_source)
 
 

test/functionalities/breakpoint/breakpoint_command/TestRegexpBreakCommand.py

 """
 Test _regexp-break command which uses regular expression matching to dispatch to other built in breakpoint commands.
 """
 
 import os, time
 import unittest2
 import lldb
 from lldbtest import *
 import lldbutil
 
 class RegexpBreakCommandTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @skipUnlessDarwin
-    @dsym_test
-    def test_with_dsym(self):
+    def test(self):
         """Test _regexp-break command."""
-        self.buildDsym()
-        self.regexp_break_command()
-
-    @dwarf_test
-    def test_with_dwarf(self):
-        """Test _regexp-break command."""
-        self.buildDwarf()
+        self.build()
         self.regexp_break_command()
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number to break inside main().
         self.source = 'main.c'
         self.line = line_number(self.source, '// Set break point at this line.')

test/functionalities/breakpoint/breakpoint_conditions/TestBreakpointConditions.py

 """
 Test breakpoint conditions with 'breakpoint modify -c <expr> id'.
 """
 
 import os, time
 import re
 import unittest2
 import lldb, lldbutil
 from lldbtest import *
 
 class BreakpointConditionsTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @skipUnlessDarwin
-    @dsym_test
-    def test_breakpoint_condition_with_dsym_and_run_command(self):
-        """Exercise breakpoint condition with 'breakpoint modify -c <expr> id'."""
-        self.buildDsym()
-        self.breakpoint_conditions()
-
-    @skipUnlessDarwin
-    @dsym_test
-    def test_breakpoint_condition_inline_with_dsym_and_run_command(self):
-        """Exercise breakpoint condition inline with 'breakpoint set'."""
-        self.buildDsym()
-        self.breakpoint_conditions(inline=True)
-
-    @skipUnlessDarwin
-    @python_api_test
-    @dsym_test
-    def test_breakpoint_condition_with_dsym_and_python_api(self):
-        """Use Python APIs to set breakpoint conditions."""
-        self.buildDsym()
-        self.breakpoint_conditions_python()
-
-    @dwarf_test
     @skipIfWindows # Requires EE to support COFF on Windows (http://llvm.org/pr22232)
-    def test_breakpoint_condition_with_dwarf_and_run_command(self):
+    def test_breakpoint_condition_and_run_command(self):
         """Exercise breakpoint condition with 'breakpoint modify -c <expr> id'."""
-        self.buildDwarf()
+        self.build()
         self.breakpoint_conditions()
 
-    @dwarf_test
     @skipIfWindows # Requires EE to support COFF on Windows (http://llvm.org/pr22232)
-    def test_breakpoint_condition_inline_with_dwarf_and_run_command(self):
+    def test_breakpoint_condition_inline_and_run_command(self):
         """Exercise breakpoint condition inline with 'breakpoint set'."""
-        self.buildDwarf()
+        self.build()
         self.breakpoint_conditions(inline=True)
 
-    @python_api_test
-    @dwarf_test
     @skipIfWindows # Requires EE to support COFF on Windows (http://llvm.org/pr22232)
-    def test_breakpoint_condition_with_dwarf_and_python_api(self):
+    @python_api_test
+    def test_breakpoint_condition_and_python_api(self):
         """Use Python APIs to set breakpoint conditions."""
-        self.buildDwarf()
+        self.build()
         self.breakpoint_conditions_python()
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number to of function 'c'.
         self.line1 = line_number('main.c', '// Find the line number of function "c" here.')
         self.line2 = line_number('main.c', "// Find the line number of c's parent call here.")

test/functionalities/breakpoint/breakpoint_ids/TestBreakpointIDs.py

 """
 Test lldb breakpoint ids.
 """
 
 import os, time
 import unittest2
 import lldb
 from lldbtest import *
 import lldbutil
 
 class BreakpointIDTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @skipUnlessDarwin
-    @dsym_test
-    def test_with_dsym (self):
-        self.buildDsym ()
-        self.breakpoint_id_tests ()
-
-    @dwarf_test
-    def test_with_dwarf (self):
-        self.buildDwarf ()
-        self.breakpoint_id_tests ()
+    def test (self):
+        self.build()
 
-    def breakpoint_id_tests (self):
         exe = os.path.join (os.getcwd(), "a.out")
         self.expect("file " + exe,
                     patterns = [ "Current executable set to .*a.out" ])
 
         
         bpno = lldbutil.run_break_set_by_symbol (self, 'product', num_expected_locations=-1, sym_exact=False)
         self.assertTrue (bpno == 1, "First breakpoint number is 1.")
 

test/functionalities/breakpoint/breakpoint_ignore_count/TestBreakpointIgnoreCount.py

 """
 Test breakpoint ignore count features.
 """
 
 import os, time
 import re
 import unittest2
 import lldb, lldbutil
 from lldbtest import *
 
 class BreakpointIgnoreCountTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @skipUnlessDarwin
-    @dsym_test
-    def test_with_dsym_and_run_command(self):
+    def test_with_run_command(self):
         """Exercise breakpoint ignore count with 'breakpoint set -i <count>'."""
-        self.buildDsym()
+        self.build()
         self.breakpoint_ignore_count()
 
-    @skipUnlessDarwin
     @python_api_test
-    @dsym_test
-    def test_with_dsym_and_python_api(self):
+    def test_with_python_api(self):
         """Use Python APIs to set breakpoint ignore count."""
-        self.buildDsym()
-        self.breakpoint_ignore_count_python()
-
-    @dwarf_test
-    def test_with_dwarf_and_run_command(self):
-        """Exercise breakpoint ignore count with 'breakpoint set -i <count>'."""
-        self.buildDwarf()
-        self.breakpoint_ignore_count()
-
-    @python_api_test
-    @dwarf_test
-    def test_with_dwarf_and_python_api(self):
-        """Use Python APIs to set breakpoint ignore count."""
-        self.buildDwarf()
+        self.build()
         self.breakpoint_ignore_count_python()
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number to of function 'c'.
         self.line1 = line_number('main.c', '// Find the line number of function "c" here.')
         self.line2 = line_number('main.c', '// b(2) -> c(2) Find the call site of b(2).')

test/functionalities/breakpoint/breakpoint_locations/TestBreakpointLocations.py

 """
 Test breakpoint commands for a breakpoint ID with multiple locations.
 """
 
 import os, time
 import unittest2
 import lldb
 from lldbtest import *
 import lldbutil
 
 class BreakpointLocationsTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @skipUnlessDarwin
-    @dsym_test
-    def test_with_dsym(self):
-        """Test breakpoint enable/disable for a breakpoint ID with multiple locations."""
-        self.buildDsym()
-        self.breakpoint_locations_test()
-
-    @dwarf_test
     @expectedFailureWindows("llvm.org/pr24528")
-    def test_with_dwarf(self):
+    def test(self):
         """Test breakpoint enable/disable for a breakpoint ID with multiple locations."""
-        self.buildDwarf()
+        self.build()
         self.breakpoint_locations_test()
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number to break inside main().
         self.line = line_number('main.c', '// Set break point at this line.')
 

test/functionalities/breakpoint/breakpoint_options/TestBreakpointOptions.py

 """
 Test breakpoint command for different options.
 """
 
 import os
 import unittest2
 import lldb
 from lldbtest import *
 import lldbutil
 
 class BreakpointOptionsTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @skipUnlessDarwin
-    @dsym_test
-    def test_with_dsym(self):
+    def test(self):
         """Test breakpoint command for different options."""
-        self.buildDsym()
-        self.breakpoint_options_test()
-
-    @dwarf_test
-    def test_with_dwarf(self):
-        """Test breakpoint command for different options."""
-        self.buildDwarf()
+        self.build()
         self.breakpoint_options_test()
 
     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.')
 

test/functionalities/breakpoint/comp_dir_symlink/TestCompDirSymLink.py

class CompDirSymLinkTestCase(TestBase):
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number to break inside main().
         self.line = line_number(_SRC_FILE, '// Set break point at this line.')
         self.src_path = os.path.join(os.getcwd(), _SRC_FILE)
 
-    @dwarf_test
     @skipIfHostWindows
     def test_symlink_paths_set(self):
         pwd_symlink = self.create_src_symlink()
-        self.build(pwd_symlink)
+        self.doBuild(pwd_symlink)
         self.runCmd("settings set %s %s" % (_COMP_DIR_SYM_LINK_PROP, pwd_symlink))
         lldbutil.run_break_set_by_file_and_line(self, self.src_path, self.line)
 
-    @dwarf_test
     @skipUnlessHostLinux
     def test_symlink_paths_set_procselfcwd(self):
         pwd_symlink = '/proc/self/cwd'
-        self.build(pwd_symlink)
+        self.doBuild(pwd_symlink)
         self.runCmd("settings set %s %s" % (_COMP_DIR_SYM_LINK_PROP, pwd_symlink))
         lldbutil.run_break_set_by_file_and_line(self, self.src_path, self.line)
 
-    @dwarf_test
     @skipIfHostWindows
     def test_symlink_paths_unset(self):
         pwd_symlink = self.create_src_symlink()
-        self.build(pwd_symlink)
+        self.doBuild(pwd_symlink)
         self.runCmd('settings clear ' + _COMP_DIR_SYM_LINK_PROP)
         self.assertRaises(AssertionError, lldbutil.run_break_set_by_file_and_line, self, self.src_path, self.line)
 
     def create_src_symlink(self):
         pwd_symlink = os.path.join(os.getcwd(), 'pwd_symlink')
         os.symlink(os.getcwd(), pwd_symlink)
         self.addTearDownHook(lambda: os.remove(pwd_symlink))
         return pwd_symlink
 
-    def build(self, pwd_symlink):
-        self.buildDwarf(None, None, {'PWD': pwd_symlink}, True)
+    def doBuild(self, pwd_symlink):
+        self.build(None, None, {'PWD': pwd_symlink}, True)
 
         exe = os.path.join(os.getcwd(), _EXE_NAME)
         self.runCmd('file ' + exe, CURRENT_EXECUTABLE_SET)
 
 
 if __name__ == '__main__':
     import atexit
     lldb.SBDebugger.Initialize()
     atexit.register(lambda: lldb.SBDebugger.Terminate())
     unittest2.main()

test/functionalities/breakpoint/consecutive_breakpoins/TestConsecutiveBreakpoints.py

 """
 Test continue from a breakpoint when there is a breakpoint on the next instruction also.
 """
 
 import unittest2
 import lldb, lldbutil
 from lldbtest import *
 
 class ConsecutiveBreakpoitsTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @skipUnlessDarwin
-    @dsym_test
     @unittest2.expectedFailure("llvm.org/pr23478")
-    def test_with_dsym (self):
-        self.buildDsym ()
-        self.consecutive_breakpoints_tests()
-
-    @dwarf_test
-    @unittest2.expectedFailure("llvm.org/pr23478")
-    def test_with_dwarf (self):
-        self.buildDwarf ()
+    def test (self):
+        self.build ()
         self.consecutive_breakpoints_tests()
 
     def consecutive_breakpoints_tests(self):
         exe = os.path.join (os.getcwd(), "a.out")
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)

test/functionalities/breakpoint/cpp/TestCPPBreakpointLocations.py

 """
 Test lldb breakpoint ids.
 """
 
 import os, time
 import unittest2
 import lldb
 from lldbtest import *
 import lldbutil
 
 class TestCPPBreakpointLocations(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @skipUnlessDarwin
-    @dsym_test
-    def test_with_dsym (self):
-        self.buildDsym ()
-        self.breakpoint_id_tests ()
-
-    @dwarf_test
     @expectedFailureWindows("llvm.org/pr24764")
     def test_with_dwarf (self):
-        self.buildDwarf ()
+        self.build ()
         self.breakpoint_id_tests ()
 
     def verify_breakpoint_locations(self, target, bp_dict):
         
         name = bp_dict['name']
         names = bp_dict['loc_names']
         bp = target.BreakpointCreateByName (name)
         self.assertTrue (bp.GetNumLocations() == len(names), "Make sure we find the right number of breakpoint locations")

test/functionalities/breakpoint/cpp_exception/TestCPPExceptionBreakpoint.py

 """
 Test that you can set breakpoint and hit the C++ language exception breakpoint
 """
 
 import os
 import re
 import unittest2
 import lldb, lldbutil
 import sys
 from lldbtest import *
 
 class TestCPPExceptionBreakpoint (TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
     my_var = 10
 
-    @skipUnlessDarwin
-    @python_api_test
-    @dsym_test
-    def test_cpp_exception_breakpoint (self):
-        """Test setting and hitting the C++ exception breakpoint."""
-        self.buildDsym()
-        self.do_cpp_exception_bkpt ()
-
     @python_api_test
     @expectedFailureWindows("llvm.org/pr24538") # clang-cl does not support throw or catch
-    @dwarf_test
-    def test_cpp_exception_breakpoint_with_dwarf(self):
+    def test_cpp_exception_breakpoint(self):
         """Test setting and hitting the C++ exception breakpoint."""
-        self.buildDwarf()
+        self.build()
         self.do_cpp_exception_bkpt ()
 
     def setUp (self):
         TestBase.setUp(self)
         self.main_source = "main.c"
         self.main_source_spec = lldb.SBFileSpec(self.main_source)
 
 

test/functionalities/breakpoint/dummy_target_breakpoints/TestBreakpointsWithNoTargets.py

 """
 Test breakpoint commands set before we have a target
 """
 
 import os, time
 import unittest2
 import lldb
 from lldbtest import *
 import lldbutil
 
 class BreakpointInDummyTarget (TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @skipUnlessDarwin
-    @dsym_test
-    def test_with_dsym(self):
+    def test(self):
         """Test breakpoint set before we have a target. """
-        self.buildDsym()
-        self.dummy_breakpoint_test()
-
-    @dwarf_test
-    def test_with_dwarf(self):
-        """Test breakpoint set before we have a target. """
-        self.buildDwarf()
+        self.build()
         self.dummy_breakpoint_test()
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number to break inside main().
         self.line = line_number('main.c', 'Set a breakpoint on this line.')
         self.line2 = line_number ('main.c', 'Set another on this line.')

test/functionalities/breakpoint/inlined_breakpoints/TestInlinedBreakpoints.py

 """
 Test that inlined breakpoints (breakpoint set on a file/line included from
 another source file) works correctly.
 """
 
 import os, time
 import unittest2
 import lldb
 from lldbtest import *
 import lldbutil
 
 class InlinedBreakpointsTestCase(TestBase):
     """Bug fixed: rdar://problem/8464339"""
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @skipUnlessDarwin
-    @dsym_test
-    def test_with_dsym_and_run_command(self):
+    def test_with_run_command(self):
         """Test 'b basic_types.cpp:176' does break (where int.cpp includes basic_type.cpp)."""
-        self.buildDsym()
-        self.inlined_breakpoints()
-
-    @dwarf_test
-    def test_with_dwarf_and_run_command(self):
-        """Test 'b basic_types.cpp:176' does break (where int.cpp includes basic_type.cpp)."""
-        self.buildDwarf()
+        self.build()
         self.inlined_breakpoints()
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number to break inside basic_type.cpp.
         self.line = line_number('basic_type.cpp', '// Set break point at this line.')
 

test/functionalities/breakpoint/objc/TestObjCBreakpoints.py

 import shutil
 import subprocess
 
 @skipUnlessDarwin
 class TestObjCBreakpoints(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @dsym_test
-    def test_break_with_dsym(self):
-        """Test setting Objective C specific breakpoints (dSYM)."""
-        self.buildDsym()
-        self.setTearDownCleanup()
-        self.check_objc_breakpoints(True)
-
-    @dwarf_test
-    def test_break_with_dwarf(self):
+    def test_break(self):
         """Test setting Objective C specific breakpoints (DWARF in .o files)."""
-        self.buildDwarf()
+        self.build()
         self.setTearDownCleanup()
         self.check_objc_breakpoints(False)
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number to break inside main().
         self.main_source = "main.m"

test/functionalities/command_history/TestCommandHistory.py

 """
 Test the command history mechanism
 """
 
 import os
 import unittest2
 import lldb
 from lldbtest import *
 
 class CommandHistoryTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
+    @no_debug_info_test
     def test_history(self):
         self.runCmd('command history --clear', inHistory=False)
         self.runCmd('breakpoint list', check=False, inHistory=True) #0
         self.runCmd('register read', check=False, inHistory=True) #1
         self.runCmd('apropos hello', check=False, inHistory=True) #2
         self.runCmd('memory write', check=False, inHistory=True) #3
         self.runCmd('log list', check=False, inHistory=True) #4
         self.runCmd('disassemble', check=False, inHistory=True) #5

test/functionalities/command_regex/TestCommandRegex.py

 """
 Test lldb 'commands regex' command which allows the user to create a regular expression command.
 """
 
 import os
 import unittest2
 import lldb
 from lldbtest import *
 
 class CommandRegexTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @expectedFailureHostWindows("llvm.org/pr22274: need a pexpect replacement for windows")
+    @no_debug_info_test
     def test_command_regex(self):
         """Test a simple scenario of 'command regex' invocation and subsequent use."""
         import pexpect
         prompt = "(lldb) "
         regex_prompt = "Enter one of more sed substitution commands in the form: 's/<regex>/<subst>/'.\r\nTerminate the substitution list with an empty line.\r\n"
         regex_prompt1 = "\r\n"
 
         child = pexpect.spawn('%s %s' % (lldbtest_config.lldbExec, self.lldbOption))

test/functionalities/command_script/TestCommandScript.py

 """
 Test lldb Python commands.
 """
 
 import os, time
 import unittest2
 import lldb
 from lldbtest import *
 
 class CmdPythonTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @skipUnlessDarwin
-    @dsym_test
-    def test_with_dsym (self):
-        self.buildDsym ()
-        self.pycmd_tests ()
-
-    @dwarf_test
-    def test_with_dwarf (self):
-        self.buildDwarf ()
+    def test (self):
+        self.build ()
         self.pycmd_tests ()
 
     def pycmd_tests (self):
         self.runCmd("command source py_import")
 
         # Verify command that specifies eCommandRequiresTarget returns failure
         # without a target.
         self.expect('targetname',

test/functionalities/command_script/import/TestImport.py

 """Test custom import command to import files by path."""
 
 import os, sys, time
 import unittest2
 import lldb
 from lldbtest import *
 
 class ImportTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @python_api_test
+    @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)
 

test/functionalities/command_script/import/rdar-12586188/TestRdar12586188.py

 """Check that we handle an ImportError in a special way when command script importing files."""
 
 import os, sys, time
 import unittest2
 import lldb
 from lldbtest import *
 
 class Rdar12586188TestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @python_api_test
+    @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)
 

test/functionalities/command_source/TestCommandSource.py

 """
 Test that lldb command "command source" works correctly.
 
 See also http://llvm.org/viewvc/llvm-project?view=rev&revision=109673.
 """
 
 import os, sys
 import unittest2
 import lldb
 from lldbtest import *
 
 class CommandSourceTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
+    @no_debug_info_test
     def test_command_source(self):
         """Test that lldb command "command source" works correctly."""
 
         # Sourcing .lldb in the current working directory, which in turn imports
         # the "my" package that defines the date() function.
         self.runCmd("command source .lldb")
 
         # Python should evaluate "my.date()" successfully.

test/functionalities/completion/TestCompletion.py

def classCleanup(cls):
         try:
             os.remove("child_send.txt")
             os.remove("child_read.txt")
         except:
             pass
 
     @expectedFailureHostWindows("llvm.org/pr24679")
     @skipIfFreeBSD # timing out on the FreeBSD buildbot
+    @no_debug_info_test
     def test_at(self):
         """Test that 'at' completes to 'attach '."""
         self.complete_from_to('at', 'attach ')
 
     @expectedFailureHostWindows("llvm.org/pr24679")
     @skipIfFreeBSD # timing out on the FreeBSD buildbot
+    @no_debug_info_test
     def test_de(self):
         """Test that 'de' completes to 'detach '."""
         self.complete_from_to('de', 'detach ')
 
     @expectedFailureHostWindows("llvm.org/pr24679")
     @skipIfFreeBSD # timing out on the FreeBSD buildbot
+    @no_debug_info_test
     def test_process_attach_dash_dash_con(self):
         """Test that 'process attach --con' completes to 'process attach --continue '."""
         self.complete_from_to('process attach --con', 'process attach --continue ')
 
     # <rdar://problem/11052829>
     @expectedFailureHostWindows("llvm.org/pr24679")
     @skipIfFreeBSD # timing out on the FreeBSD buildbot
+    @no_debug_info_test
     def test_infinite_loop_while_completing(self):
         """Test that 'process print hello\' completes to itself and does not infinite loop."""
         self.complete_from_to('process print hello\\', 'process print hello\\',
                               turn_off_re_match=True)
 
     @expectedFailureHostWindows("llvm.org/pr24679")
     @skipIfFreeBSD # timing out on the FreeBSD buildbot
+    @no_debug_info_test
     def test_watchpoint_co(self):
         """Test that 'watchpoint co' completes to 'watchpoint command '."""
         self.complete_from_to('watchpoint co', 'watchpoint command ')
 
     @expectedFailureHostWindows("llvm.org/pr24679")
     @skipIfFreeBSD # timing out on the FreeBSD buildbot
+    @no_debug_info_test
     def test_watchpoint_command_space(self):
         """Test that 'watchpoint command ' completes to ['Available completions:', 'add', 'delete', 'list']."""
         self.complete_from_to('watchpoint command ', ['Available completions:', 'add', 'delete', 'list'])
 
     @expectedFailureHostWindows("llvm.org/pr24679")
     @skipIfFreeBSD # timing out on the FreeBSD buildbot
+    @no_debug_info_test
     def test_watchpoint_command_a(self):
         """Test that 'watchpoint command a' completes to 'watchpoint command add '."""
         self.complete_from_to('watchpoint command a', 'watchpoint command add ')
 
     @expectedFailureHostWindows("llvm.org/pr24679")
     @skipIfFreeBSD # timing out on the FreeBSD buildbot
+    @no_debug_info_test
     def test_watchpoint_set_variable_dash_w(self):
         """Test that 'watchpoint set variable -w' completes to 'watchpoint set variable -w '."""
         self.complete_from_to('watchpoint set variable -w', 'watchpoint set variable -w ')
 
     @expectedFailureHostWindows("llvm.org/pr24679")
     @skipIfFreeBSD # timing out on the FreeBSD buildbot
+    @no_debug_info_test
     def test_watchpoint_set_variable_dash_w_space(self):
         """Test that 'watchpoint set variable -w ' completes to ['Available completions:', 'read', 'write', 'read_write']."""
         self.complete_from_to('watchpoint set variable -w ', ['Available completions:', 'read', 'write', 'read_write'])
 
     @expectedFailureHostWindows("llvm.org/pr24679")
     @skipIfFreeBSD # timing out on the FreeBSD buildbot
+    @no_debug_info_test
     def test_watchpoint_set_ex(self):
         """Test that 'watchpoint set ex' completes to 'watchpoint set expression '."""
         self.complete_from_to('watchpoint set ex', 'watchpoint set expression ')
 
     @expectedFailureHostWindows("llvm.org/pr24679")
     @skipIfFreeBSD # timing out on the FreeBSD buildbot
+    @no_debug_info_test
     def test_watchpoint_set_var(self):
         """Test that 'watchpoint set var' completes to 'watchpoint set variable '."""
         self.complete_from_to('watchpoint set var', 'watchpoint set variable ')
 
     @expectedFailureHostWindows("llvm.org/pr24679")
     @skipIfFreeBSD # timing out on the FreeBSD buildbot
+    @no_debug_info_test
     def test_watchpoint_set_variable_dash_w_read_underbar(self):
         """Test that 'watchpoint set variable -w read_' completes to 'watchpoint set variable -w read_write'."""
         self.complete_from_to('watchpoint set variable -w read_', 'watchpoint set variable -w read_write')
 
     @expectedFailureHostWindows("llvm.org/pr24679")
     @skipIfFreeBSD # timing out on the FreeBSD buildbot
+    @no_debug_info_test
     def test_help_fi(self):
         """Test that 'help fi' completes to ['Available completions:', 'file', 'finish']."""
         self.complete_from_to('help fi', ['Available completions:', 'file', 'finish'])
 
     @expectedFailureHostWindows("llvm.org/pr24679")
     @skipIfFreeBSD # timing out on the FreeBSD buildbot
+    @no_debug_info_test
     def test_help_watchpoint_s(self):
         """Test that 'help watchpoint s' completes to 'help watchpoint set '."""
         self.complete_from_to('help watchpoint s', 'help watchpoint set ')
 
     @expectedFailureHostWindows("llvm.org/pr24679")
     @skipIfFreeBSD # timing out on the FreeBSD buildbot
+    @no_debug_info_test
     def test_settings_append_target_er(self):
         """Test that 'settings append target.er' completes to 'settings append target.error-path'."""
         self.complete_from_to('settings append target.er', 'settings append target.error-path')
 
     @expectedFailureHostWindows("llvm.org/pr24679")
     @skipIfFreeBSD # timing out on the FreeBSD buildbot
+    @no_debug_info_test
     def test_settings_insert_after_target_en(self):
         """Test that 'settings insert-after target.env' completes to 'settings insert-after target.env-vars'."""
         self.complete_from_to('settings insert-after target.env', 'settings insert-after target.env-vars')
 
     @expectedFailureHostWindows("llvm.org/pr24679")
     @skipIfFreeBSD # timing out on the FreeBSD buildbot
+    @no_debug_info_test
     def test_settings_insert_before_target_en(self):
         """Test that 'settings insert-before target.env' completes to 'settings insert-before target.env-vars'."""
         self.complete_from_to('settings insert-before target.env', 'settings insert-before target.env-vars')
 
     @expectedFailureHostWindows("llvm.org/pr24679")
     @skipIfFreeBSD # timing out on the FreeBSD buildbot
+    @no_debug_info_test
     def test_settings_replace_target_ru(self):
         """Test that 'settings replace target.ru' completes to 'settings replace target.run-args'."""
         self.complete_from_to('settings replace target.ru', 'settings replace target.run-args')
 
     @expectedFailureHostWindows("llvm.org/pr24679")
     @skipIfFreeBSD # timing out on the FreeBSD buildbot
+    @no_debug_info_test
     def test_settings_s(self):
         """Test that 'settings s' completes to ['Available completions:', 'set', 'show']."""
         self.complete_from_to('settings s', ['Available completions:', 'set', 'show'])
 
     @expectedFailureHostWindows("llvm.org/pr24679")
     @skipIfFreeBSD # timing out on the FreeBSD buildbot
+    @no_debug_info_test
     def test_settings_set_th(self):
         """Test that 'settings set th' completes to 'settings set thread-format'."""
         self.complete_from_to('settings set th', 'settings set thread-format')
 
     @expectedFailureHostWindows("llvm.org/pr24679")
     @skipIfFreeBSD # timing out on the FreeBSD buildbot
+    @no_debug_info_test
     def test_settings_s_dash(self):
         """Test that 'settings set -' completes to 'settings set -g'."""
         self.complete_from_to('settings set -', 'settings set -g')
 
     @expectedFailureHostWindows("llvm.org/pr24679")
     @skipIfFreeBSD # timing out on the FreeBSD buildbot
+    @no_debug_info_test
     def test_settings_clear_th(self):
         """Test that 'settings clear th' completes to 'settings clear thread-format'."""
         self.complete_from_to('settings clear th', 'settings clear thread-format')
 
     @expectedFailureHostWindows("llvm.org/pr24679")
     @skipIfFreeBSD # timing out on the FreeBSD buildbot
+    @no_debug_info_test
     def test_settings_set_ta(self):
         """Test that 'settings set ta' completes to 'settings set target.'."""
         self.complete_from_to('settings set ta', 'settings set target.')
 
     @expectedFailureHostWindows("llvm.org/pr24679")
     @skipIfFreeBSD # timing out on the FreeBSD buildbot
+    @no_debug_info_test
     def test_settings_set_target_exec(self):
         """Test that 'settings set target.exec' completes to 'settings set target.exec-search-paths '."""
         self.complete_from_to('settings set target.exec', 'settings set target.exec-search-paths')
 
     @expectedFailureHostWindows("llvm.org/pr24679")
     @skipIfFreeBSD # timing out on the FreeBSD buildbot
+    @no_debug_info_test
     def test_settings_set_target_pr(self):
         """Test that 'settings set target.pr' completes to ['Available completions:',
         'target.prefer-dynamic-value', 'target.process.']."""
         self.complete_from_to('settings set target.pr',
                               ['Available completions:',
                                'target.prefer-dynamic-value',
                                'target.process.'])
 
     @expectedFailureHostWindows("llvm.org/pr24679")
     @skipIfFreeBSD # timing out on the FreeBSD buildbot
+    @no_debug_info_test
     def test_settings_set_target_process(self):
         """Test that 'settings set target.process' completes to 'settings set target.process.'."""
         self.complete_from_to('settings set target.process', 'settings set target.process.')
 
     @expectedFailureHostWindows("llvm.org/pr24679")
     @skipIfFreeBSD # timing out on the FreeBSD buildbot
+    @no_debug_info_test
     def test_settings_set_target_process_dot(self):
         """Test that 'settings set target.process.t' completes to 'settings set target.process.thread.'."""
         self.complete_from_to('settings set target.process.t', 'settings set target.process.thread.')
 
     @expectedFailureHostWindows("llvm.org/pr24679")
     @skipIfFreeBSD # timing out on the FreeBSD buildbot
+    @no_debug_info_test
     def test_settings_set_target_process_thread_dot(self):
         """Test that 'settings set target.process.thread.' completes to ['Available completions:',
         'target.process.thread.step-avoid-regexp', 'target.process.thread.trace-thread']."""
         self.complete_from_to('settings set target.process.thread.',
                               ['Available completions:',
                                'target.process.thread.step-avoid-regexp',
                                'target.process.thread.trace-thread'])
 
     @expectedFailureHostWindows("llvm.org/pr24679")
     @skipIfFreeBSD # timing out on the FreeBSD buildbot
+    @no_debug_info_test
     def test_target_space(self):
         """Test that 'target ' completes to ['Available completions:', 'create', 'delete', 'list',
         'modules', 'select', 'stop-hook', 'variable']."""
         self.complete_from_to('target ',
                               ['Available completions:', 'create', 'delete', 'list',
                                'modules', 'select', 'stop-hook', 'variable'])
 
     @expectedFailureHostWindows("llvm.org/pr24679")
     @skipIfFreeBSD # timing out on the FreeBSD buildbot
+    @no_debug_info_test
     def test_target_create_dash_co(self):
         """Test that 'target create --co' completes to 'target variable --core '."""
         self.complete_from_to('target create --co', 'target create --core ')
 
     @expectedFailureHostWindows("llvm.org/pr24679")
     @skipIfFreeBSD # timing out on the FreeBSD buildbot
+    @no_debug_info_test
     def test_target_va(self):
         """Test that 'target va' completes to 'target variable '."""
         self.complete_from_to('target va', 'target variable ')
 
-    @skipUnlessDarwin
-    @dsym_test
-    def test_symbol_name_dsym(self):
-        self.buildDsym()
-        self.complete_from_to('''file a.out
-                                 breakpoint set -n Fo''',
-                              'breakpoint set -n Foo::Bar(int,\\ int)',
-                              turn_off_re_match=True)
-
     @expectedFailureHostWindows("llvm.org/pr24679")
-    @dwarf_test
-    def test_symbol_name_dwarf(self):
-        self.buildDwarf()
+    def test_symbol_name(self):
+        self.build()
         self.complete_from_to('''file a.out
                                  breakpoint set -n Fo''',
                               'breakpoint set -n Foo::Bar(int,\\ int)',
                               turn_off_re_match=True)
 
     def complete_from_to(self, str_input, patterns, turn_off_re_match=False):
         """Test that the completion mechanism completes str_input to patterns,
         where patterns could be a pattern-string or a list of pattern-strings"""

test/functionalities/conditional_break/TestConditionalBreak.py

 # lldb not able to digest the clang-generated debug info correctly with respect to function name
 #
 # This class currently fails for clang as well as llvm-gcc.
 
 class ConditionalBreakTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @skipUnlessDarwin
-    @python_api_test
-    @dsym_test
-    def test_with_dsym_python(self):
-        """Exercise some thread and frame APIs to break if c() is called by a()."""
-        self.buildDsym()
-        self.do_conditional_break()
-
     @expectedFailureWindows("llvm.org/pr24778")
     @python_api_test
-    @dwarf_test
-    def test_with_dwarf_python(self):
+    def test_with_python(self):
         """Exercise some thread and frame APIs to break if c() is called by a()."""
-        self.buildDwarf()
+        self.build()
         self.do_conditional_break()
 
-    @skipUnlessDarwin
-    @dsym_test
-    def test_with_dsym_command(self):
-        """Simulate a user using lldb commands to break on c() if called from a()."""
-        self.buildDsym()
-        self.simulate_conditional_break_by_user()
-
-    @dwarf_test
-    def test_with_dwarf_command(self):
+    def test_with_command(self):
         """Simulate a user using lldb commands to break on c() if called from a()."""
-        self.buildDwarf()
+        self.build()
         self.simulate_conditional_break_by_user()
 
     def do_conditional_break(self):
         """Exercise some thread and frame APIs to break if c() is called by a()."""
         exe = os.path.join(os.getcwd(), "a.out")
 
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)

test/functionalities/connect_remote/TestConnectRemote.py

 
 class ConnectRemoteTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     @expectedFailureLinux("llvm.org/pr23475") # Test occasionally times out on the Linux build bot
     @skipIfLinux                              # Test occasionally times out on the Linux build bot
+    @no_debug_info_test
     def test_connect_remote(self):
         """Test "process connect connect:://localhost:[port]"."""
 
         import pexpect
         # First, we'll start a fake debugserver (a simple echo server).
         fakeserver = pexpect.spawn('./EchoServer.py')
 
         # Turn on logging for what the child sends back.

test/lldbtest.py

def wrapper(self, *args, **kwargs):
         except AttributeError:
             pass
         return func(self, *args, **kwargs)
 
     # Mark this function as such to separate them from the regular tests.
     wrapper.__benchmarks_test__ = True
     return wrapper
 
+def no_debug_info_test(func):
+    """Decorate the item as a test what don't use any debug info. If this annotation is specified
+       then the test runner won't generate a separate test for each debug info format. """
+    if isinstance(func, type) and issubclass(func, unittest2.TestCase):
+        raise Exception("@no_debug_info_test can only be used to decorate a test method")
+    @wraps(func)
+    def wrapper(self, *args, **kwargs):
+        return func(self, *args, **kwargs)
+
+    # Mark this function as such to separate them from the regular tests.
+    wrapper.__no_debug_info_test__ = True
+    return wrapper
+
 def dsym_test(func):
     """Decorate the item as a dsym test."""
     if isinstance(func, type) and issubclass(func, unittest2.TestCase):
         raise Exception("@dsym_test can only be used to decorate a test method")
     @wraps(func)
     def wrapper(self, *args, **kwargs):
         try:
             if lldb.dont_do_dsym_test:
def expectedFailure_impl(func):
         return wrapper
     # if bugnumber is not-callable(incluing None), that means decorator function is called with optional arguments
     # return decorator in this case, so it will be used to decorating original method
     if callable(bugnumber):
         return expectedFailure_impl(bugnumber)
     else:
         return expectedFailure_impl
 
-def expectedFailureCompiler(compiler, compiler_version=None, bugnumber=None):
-    if compiler_version is None:
-        compiler_version=['=', None]
-    def fn(self):
-        return compiler in self.getCompiler() and self.expectedCompilerVersion(compiler_version)
-    return expectedFailure(fn, bugnumber)
-
 # provide a function to xfail on defined oslist, compiler version, and archs
 # if none is specified for any argument, that argument won't be checked and thus means for all
 # for example,
 # @expectedFailureAll, xfail for all platform/compiler/arch,
 # @expectedFailureAll(compiler='gcc'), xfail for gcc on all platform/architecture
 # @expectedFailureAll(bugnumber, ["linux"], "gcc", ['>=', '4.9'], ['i386']), xfail for gcc>=4.9 on linux with i386
-def expectedFailureAll(bugnumber=None, oslist=None, compiler=None, compiler_version=None, archs=None, triple=None):
+def expectedFailureAll(bugnumber=None, oslist=None, compiler=None, compiler_version=None, archs=None, triple=None, debug_info=None):
     def fn(self):
         return ((oslist is None or self.getPlatform() in oslist) and
                 (compiler is None or (compiler in self.getCompiler() and self.expectedCompilerVersion(compiler_version))) and
                 self.expectedArch(archs) and
-                (triple is None or re.match(triple, lldb.DBG.GetSelectedPlatform().GetTriple())))
+                (triple is None or re.match(triple, lldb.DBG.GetSelectedPlatform().GetTriple())) and
+                (debug_info is None or self.debug_info in debug_info))
     return expectedFailure(fn, bugnumber)
 
+def expectedFailureDwarf(bugnumber=None):
+    return expectedFailureAll(bugnumber==bugnumber, debug_info="dwarf")
+
+def expectedFailureDsym(bugnumber=None):
+    return expectedFailureAll(bugnumber==bugnumber, debug_info="dsym")
+
+def expectedFailureCompiler(compiler, compiler_version=None, bugnumber=None):
+    if compiler_version is None:
+        compiler_version=['=', None]
+    return expectedFailureAll(bugnumber=bugnumber, compiler=compiler, compiler_version=compiler_version)
+
 # to XFAIL a specific clang versions, try this
 # @expectedFailureClang('bugnumber', ['<=', '3.4'])
 def expectedFailureClang(bugnumber=None, compiler_version=None):
     return expectedFailureCompiler('clang', compiler_version, bugnumber)
 
 def expectedFailureGcc(bugnumber=None, compiler_version=None):
     return expectedFailureCompiler('gcc', compiler_version, bugnumber)
 
 def expectedFailureIcc(bugnumber=None):
     return expectedFailureCompiler('icc', None, bugnumber)
 
 def expectedFailureArch(arch, bugnumber=None):
     def fn(self):
         return arch in self.getArchitecture()
     return expectedFailure(fn, bugnumber)
 
 def expectedFailurei386(bugnumber=None):
     return expectedFailureArch('i386', bugnumber)
 
 def expectedFailurex86_64(bugnumber=None):
     return expectedFailureArch('x86_64', bugnumber)
 
-def expectedFailureOS(oslist, bugnumber=None, compilers=None):
+def expectedFailureOS(oslist, bugnumber=None, compilers=None, debug_info=None):
     def fn(self):
         return (self.getPlatform() in oslist and
-                self.expectedCompiler(compilers))
+                self.expectedCompiler(compilers) and
+                (debug_info is None or self.debug_info in debug_info))
     return expectedFailure(fn, bugnumber)
 
 def expectedFailureHostOS(oslist, bugnumber=None, compilers=None):
     def fn(self):
         return (getHostPlatform() in oslist and
                 self.expectedCompiler(compilers))
     return expectedFailure(fn, bugnumber)
 
-def expectedFailureDarwin(bugnumber=None, compilers=None):
+def expectedFailureDarwin(bugnumber=None, compilers=None, debug_info=None):
     # For legacy reasons, we support both "darwin" and "macosx" as OS X triples.
-    return expectedFailureOS(getDarwinOSTriples(), bugnumber, compilers)
+    return expectedFailureOS(getDarwinOSTriples(), bugnumber, compilers, debug_info=debug_info)
 
-def expectedFailureFreeBSD(bugnumber=None, compilers=None):
-    return expectedFailureOS(['freebsd'], bugnumber, compilers)
+def expectedFailureFreeBSD(bugnumber=None, compilers=None, debug_info=None):
+    return expectedFailureOS(['freebsd'], bugnumber, compilers, debug_info=debug_info)
 
-def expectedFailureLinux(bugnumber=None, compilers=None):
-    return expectedFailureOS(['linux'], bugnumber, compilers)
+def expectedFailureLinux(bugnumber=None, compilers=None, debug_info=None):
+    return expectedFailureOS(['linux'], bugnumber, compilers, debug_info=debug_info)
 
-def expectedFailureWindows(bugnumber=None, compilers=None):
-    return expectedFailureOS(['windows'], bugnumber, compilers)
+def expectedFailureWindows(bugnumber=None, compilers=None, debug_info=None):
+    return expectedFailureOS(['windows'], bugnumber, compilers, debug_info=debug_info)
 
 def expectedFailureHostWindows(bugnumber=None, compilers=None):
     return expectedFailureHostOS(['windows'], bugnumber, compilers)
 
 def matchAndroid(api_levels=None, archs=None):
     def match(self):
         if not target_is_android():
             return False
def expectedFailure_impl(func):
         return wrapper
     # if bugnumber is not-callable(incluing None), that means decorator function is called with optional arguments
     # return decorator in this case, so it will be used to decorating original method
     if callable(bugnumber):
         return expectedFailure_impl(bugnumber)
     else:
         return expectedFailure_impl
 
+def expectedFlakeyDwarf(bugnumber=None):
+    def fn(self):
+        return self.debug_info == "dwarf"
+    return expectedFlakey(fn, bugnumber)
+
+def expectedFlakeyDsym(bugnumber=None):
+    def fn(self):
+        return self.debug_info == "dwarf"
+    return expectedFlakey(fn, bugnumber)
+
 def expectedFlakeyOS(oslist, bugnumber=None, compilers=None):
     def fn(self):
         return (self.getPlatform() in oslist and
                 self.expectedCompiler(compilers))
     return expectedFlakey(fn, bugnumber)
 
 def expectedFlakeyDarwin(bugnumber=None, compilers=None):
     # For legacy reasons, we support both "darwin" and "macosx" as OS X triples.

 # provide a function to skip on defined oslist, compiler version, and archs
 # if none is specified for any argument, that argument won't be checked and thus means for all
 # for example,
 # @skipIf, skip for all platform/compiler/arch,
 # @skipIf(compiler='gcc'), skip for gcc on all platform/architecture
 # @skipIf(bugnumber, ["linux"], "gcc", ['>=', '4.9'], ['i386']), skip for gcc>=4.9 on linux with i386
 
 # TODO: refactor current code, to make skipIfxxx functions to call this function
-def skipIf(bugnumber=None, oslist=None, compiler=None, compiler_version=None, archs=None):
+def skipIf(bugnumber=None, oslist=None, compiler=None, compiler_version=None, archs=None, debug_info=None):
     def fn(self):
         return ((oslist is None or self.getPlatform() in oslist) and
                 (compiler is None or (compiler in self.getCompiler() and self.expectedCompilerVersion(compiler_version))) and
-                self.expectedArch(archs))
-    return skipTestIfFn(fn, bugnumber, skipReason="skipping because os:%s compiler: %s %s arch: %s"%(oslist, compiler, compiler_version, archs))
+                self.expectedArch(archs) and
+                (debug_info is None or self.debug_info in debug_info))
+    return skipTestIfFn(fn, bugnumber, skipReason="skipping because os:%s compiler: %s %s arch: %s debug info: %s"%(oslist, compiler, compiler_version, archs, debug_info))
+
+def skipIfDebugInfo(bugnumber=None, debug_info=None):
+    return skipIf(bugnumber=bugnumber, debug_info=debug_info)
+
+def skipIfDwarf(bugnumber=None):
+    return skipIfDebugInfo(bugnumber, ["dwarf"])
+
+def skipIfDsym(bugnumber=None):
+    return skipIfDebugInfo(bugnumber, ["dsym"])
 
 def skipTestIfFn(expected_fn, bugnumber=None, skipReason=None):
     def skipTestIfFn_impl(func):
         @wraps(func)
         def wrapper(*args, **kwargs):
             from unittest2 import case
             self = args[0]
             if expected_fn(self):
def buildLibrary(self, sources, lib_name):
                  'DYLIB_NAME' : lib_name,
                  'CFLAGS_EXTRAS' : "%s -I%s -fPIC" % (stdflag, os.path.join(os.environ["LLDB_SRC"], "include")),
                  'LD_EXTRAS' : "-shared -l%s\liblldb.lib" % self.implib_dir}
         if self.TraceOn():
             print "Building LLDB Library (%s) from sources %s" % (lib_name, sources)
 
         self.buildDefault(dictionary=d)
 
-    def buildProgram(self, sources, exe_name):
-        """ Platform specific way to build an executable from C/C++ sources. """
-        d = {'CXX_SOURCES' : sources,
-             'EXE' : exe_name}
-        self.buildDefault(dictionary=d)
-
     def buildDefault(self, architecture=None, compiler=None, dictionary=None, clean=True):
         """Platform specific way to build the default binaries."""
         if lldb.skip_build_and_cleanup:
             return
         module = builder_module()
         if target_is_android():
             dictionary = append_android_envs(dictionary)
         if not module.buildDefault(self, architecture, compiler, dictionary, clean):
def getLLDBLibraryEnvVal(self):
             return self.lib_dir
 
     def getLibcPlusPlusLibs(self):
         if self.getPlatform() == 'freebsd' or self.getPlatform() == 'linux':
             return ['libc++.so.1']
         else:
             return ['libc++.1.dylib','libc++abi.dylib']
 
+# Metaclass for TestBase to change the list of test metods when a new TestCase is loaded.
+# We change the test methods to create a new test method for each test for each debug info we are
+# testing. The name of the new test method will be '<original-name>_<debug-info>' and with adding
+# the new test method we remove the old method at the same time.
+class LLDBTestCaseFactory(type):
+    def __new__(cls, name, bases, attrs):
+        newattrs = {}
+        for attrname, attrvalue in attrs.iteritems():
+            if attrname.startswith("test") and not getattr(attrvalue, "__no_debug_info_test__", False):
+                @dsym_test
+                def dsym_test_method(self, attrvalue=attrvalue):
+                    self.debug_info = "dsym"
+                    return attrvalue(self)
+                dsym_method_name = attrname + "_dsym"
+                dsym_test_method.__name__ = dsym_method_name
+                newattrs[dsym_method_name] = dsym_test_method
+
+                @dwarf_test
+                def dwarf_test_method(self, attrvalue=attrvalue):
+                    self.debug_info = "dwarf"
+                    return attrvalue(self)
+                dwarf_method_name = attrname + "_dwarf"
+                dwarf_test_method.__name__ = dwarf_method_name
+                newattrs[dwarf_method_name] = dwarf_test_method
+            else:
+                newattrs[attrname] = attrvalue
+        return super(LLDBTestCaseFactory, cls).__new__(cls, name, bases, newattrs)
+
 class TestBase(Base):
     """
     This abstract base class is meant to be subclassed.  It provides default
     implementations for setUpClass(), tearDownClass(), setUp(), and tearDown(),
     among other things.
 
     Important things for test class writers:
 
class TestBase(Base):
     # Maximum allowed attempts when launching the inferior process.
     # Can be overridden by the LLDB_MAX_LAUNCH_COUNT environment variable.
     maxLaunchCount = 3;
 
     # Time to wait before the next launching attempt in second(s).
     # Can be overridden by the LLDB_TIME_WAIT_NEXT_LAUNCH environment variable.
     timeWaitNextLaunch = 1.0;
 
+    # Setup the metaclass for this class to change the list of the test methods when a new class is loaded
+    __metaclass__ = LLDBTestCaseFactory
+
     def doDelay(self):
         """See option -w of dotest.py."""
         if ("LLDB_WAIT_BETWEEN_TEST_CASES" in os.environ and
             os.environ["LLDB_WAIT_BETWEEN_TEST_CASES"] == 'YES'):
             waitTime = 1.0
             if "LLDB_TIME_WAIT_BETWEEN_TEST_CASES" in os.environ:
                 waitTime = float(os.environ["LLDB_TIME_WAIT_BETWEEN_TEST_CASES"])
             time.sleep(waitTime)
def invoke(self, obj, name, trace=False):
         import inspect
         self.assertTrue(inspect.ismethod(method),
                         name + "is a method name of object: " + str(obj))
         result = method()
         with recording(self, trace) as sbuf:
             print >> sbuf, str(method) + ":",  result
         return result
 
+    def build(self, architecture=None, compiler=None, dictionary=None, clean=True):
+        """Platform specific way to build the default binaries."""
+        if lldb.skip_build_and_cleanup:
+            return
+        module = builder_module()
+        if target_is_android():
+            dictionary = append_android_envs(dictionary)
+        if self.debug_info is None:
+            return self.buildDefault(architecture, compiler, dictionary, clean)
+        elif self.debug_info == "dsym":
+            return self.buildDsym(architecture, compiler, dictionary, clean)
+        elif self.debug_info == "dwarf":
+            return self.buildDwarf(architecture, compiler, dictionary, clean)
+
     # =================================================
     # Misc. helper methods for debugging test execution
     # =================================================
 
     def DebugSBValue(self, val):
         """Debug print a SBValue object, if traceAlways is True."""
         from lldbutil import value_type_to_str
 

test/types/AbstractBase.py

class GenericTester(TestBase):
     #         False: testing vars of various basic types from a function       #
     # qd -> quotedDisplay (defaulted to False)                                 #
     #         True: the output from 'frame var' or 'expr var' contains a pair  #
     #               of single quotes around the value                          #
     #         False: no single quotes are to be found around the value of      #
     #                variable                                                  #
     #==========================================================================#
 
-    def build_and_run(self, source, atoms, dsym=True, bc=False, qd=False):
-        self.build_and_run_with_source_atoms_expr(source, atoms, expr=False, dsym=dsym, bc=bc, qd=qd)
+    def build_and_run(self, source, atoms, bc=False, qd=False):
+        self.build_and_run_with_source_atoms_expr(source, atoms, expr=False, bc=bc, qd=qd)
 
-    def build_and_run_expr(self, source, atoms, dsym=True, bc=False, qd=False):
-        self.build_and_run_with_source_atoms_expr(source, atoms, expr=True, dsym=dsym, bc=bc, qd=qd)
+    def build_and_run_expr(self, source, atoms, bc=False, qd=False):
+        self.build_and_run_with_source_atoms_expr(source, atoms, expr=True, bc=bc, qd=qd)
 
-    def build_and_run_with_source_atoms_expr(self, source, atoms, expr, dsym=True, bc=False, qd=False):
+    def build_and_run_with_source_atoms_expr(self, source, atoms, expr, bc=False, qd=False):
         # See also Makefile and basic_type.cpp:177.
         if bc:
             d = {'CXX_SOURCES': source, 'EXE': self.exe_name, 'CFLAGS_EXTRAS': '-DTEST_BLOCK_CAPTURED_VARS'}
         else:
             d = {'CXX_SOURCES': source, 'EXE': self.exe_name}
-        if dsym:
-            self.buildDsym(dictionary=d)
-        else:
-            self.buildDwarf(dictionary=d)
+        self.build(dictionary=d)
         self.setTearDownCleanup(dictionary=d)
         if expr:
             self.generic_type_expr_tester(self.exe_name, atoms, blockCaptured=bc, quotedDisplay=qd)
         else:
             self.generic_type_tester(self.exe_name, atoms, blockCaptured=bc, quotedDisplay=qd)
 
     def process_launch_o(self, localPath):
         # process launch command output redirect always goes to host the process is running on

test/types/TestFloatTypes.py

class FloatTypesTestCase(AbstractBase.GenericTester):
 
     def setUp(self):
         # Call super's setUp().
         AbstractBase.GenericTester.setUp(self)
         # disable "There is a running process, kill it and restart?" prompt
         self.runCmd("settings set auto-confirm true")
         self.addTearDownHook(lambda: self.runCmd("settings clear auto-confirm"))
 
-    @skipUnlessDarwin
-    @dsym_test
-    def test_float_type_with_dsym(self):
+    def test_float_type(self):
         """Test that float-type variables are displayed correctly."""
         self.build_and_run('float.cpp', set(['float']))
 
     @skipUnlessDarwin
-    @dsym_test
-    def test_float_type_from_block_with_dsym(self):
+    def test_float_type_from_block(self):
         """Test that float-type variables are displayed correctly from a block."""
         self.build_and_run('float.cpp', set(['float']), bc=True)
 
-    @dwarf_test
-    def test_float_type_with_dwarf(self):
-        """Test that float-type variables are displayed correctly."""
-        self.build_and_run('float.cpp', set(['float']), dsym=False)
-
-    @skipUnlessDarwin
-    @dsym_test
-    @expectedFlakeyDarwin # failed 1/140 runs 'frame variable --show-types a_union_nonzero_ref.u.a' matches the output (from compiled code): 11001110
-    def test_double_type_with_dsym(self):
+    @expectedFlakeyDsym # failed 1/140 runs 'frame variable --show-types a_union_nonzero_ref.u.a' matches the output (from compiled code): 11001110
+    def test_double_type(self):
         """Test that double-type variables are displayed correctly."""
         self.build_and_run('double.cpp', set(['double']))
 
     @skipUnlessDarwin
-    @dsym_test
-    def test_double_type_from_block_with_dsym(self):
+    def test_double_type_from_block(self):
         """Test that double-type variables are displayed correctly from a block."""
         self.build_and_run('double.cpp', set(['double']), bc=True)
 
-    @dwarf_test
-    def test_double_type_with_dwarf(self):
-        """Test that double-type variables are displayed correctly."""
-        self.build_and_run('double.cpp', set(['double']), dsym=False)
-
-
 if __name__ == '__main__':
     import atexit
     lldb.SBDebugger.Initialize()
     atexit.register(lambda: lldb.SBDebugger.Terminate())
     unittest2.main()

test/types/TestFloatTypesExpr.py

class FloatTypesExprTestCase(AbstractBase.GenericTester):
 
     def setUp(self):
         # Call super's setUp().
         AbstractBase.GenericTester.setUp(self)
         # disable "There is a running process, kill it and restart?" prompt
         self.runCmd("settings set auto-confirm true")
         self.addTearDownHook(lambda: self.runCmd("settings clear auto-confirm"))
 
-    @skipUnlessDarwin
-    @dsym_test
-    def test_float_type_with_dsym(self):
+    def test_float_type(self):
         """Test that float-type variable expressions are evaluated correctly."""
         self.build_and_run_expr('float.cpp', set(['float']))
 
     @skipUnlessDarwin
-    @dsym_test
-    def test_float_type_from_block_with_dsym(self):
+    def test_float_type_from_block(self):
         """Test that float-type variables are displayed correctly from a block."""
         self.build_and_run_expr('float.cpp', set(['float']), bc=True)
 
-    @dwarf_test
-    def test_float_type_with_dwarf(self):
-        """Test that float-type variable expressions are evaluated correctly."""
-        self.build_and_run_expr('float.cpp', set(['float']), dsym=False)
-
-    @skipUnlessDarwin
-    @dsym_test
-    def test_double_type_with_dsym(self):
+    def test_double_type(self):
         """Test that double-type variable expressions are evaluated correctly."""
         self.build_and_run_expr('double.cpp', set(['double']))
 
     @skipUnlessDarwin
-    @dsym_test
-    def test_double_type_from_block_with_dsym(self):
+    def test_double_type_from_block(self):
         """Test that double-type variables are displayed correctly from a block."""
         self.build_and_run_expr('double.cpp', set(['double']), bc=True)
 
-    @dwarf_test
-    def test_double_type_with_dwarf(self):
-        """Test that double-type variable expressions are evaluated correctly."""
-        self.build_and_run_expr('double.cpp', set(['double']), dsym=False)
-
-
 if __name__ == '__main__':
     import atexit
     lldb.SBDebugger.Initialize()
     atexit.register(lambda: lldb.SBDebugger.Terminate())
     unittest2.main()

test/types/TestIntegerTypes.py

class IntegerTypesTestCase(AbstractBase.GenericTester):
 
     def setUp(self):
         # Call super's setUp().
         AbstractBase.GenericTester.setUp(self)
         # disable "There is a running process, kill it and restart?" prompt
         self.runCmd("settings set auto-confirm true")
         self.addTearDownHook(lambda: self.runCmd("settings clear auto-confirm"))
 
-    @skipUnlessDarwin
-    @dsym_test
-    def test_char_type_with_dsym(self):
+    def test_char_type(self):
         """Test that char-type variables are displayed correctly."""
         self.build_and_run('char.cpp', set(['char']), qd=True)
 
     @skipUnlessDarwin
-    @dsym_test
-    def test_char_type_from_block_with_dsym(self):
+    def test_char_type_from_block(self):
         """Test that char-type variables are displayed correctly from a block."""
         self.build_and_run('char.cpp', set(['char']), bc=True, qd=True)
 
-    @dwarf_test
-    def test_char_type_with_dwarf(self):
-        """Test that char-type variables are displayed correctly."""
-        self.build_and_run('char.cpp', set(['char']), dsym=False, qd=True)
-
-    @skipUnlessDarwin
-    @dsym_test
-    def test_unsigned_char_type_with_dsym(self):
+    def test_unsigned_char_type(self):
         """Test that 'unsigned_char'-type variables are displayed correctly."""
         self.build_and_run('unsigned_char.cpp', set(['unsigned', 'char']), qd=True)
 
     @skipUnlessDarwin
-    @dsym_test
-    def test_unsigned_char_type_from_block_with_dsym(self):
+    def test_unsigned_char_type_from_block(self):
         """Test that 'unsigned char'-type variables are displayed correctly from a block."""
         self.build_and_run('unsigned_char.cpp', set(['unsigned', 'char']), bc=True, qd=True)
 
-    @dwarf_test
-    def test_unsigned_char_type_with_dwarf(self):
-        """Test that 'unsigned char'-type variables are displayed correctly."""
-        self.build_and_run('unsigned_char.cpp', set(['unsigned', 'char']), dsym=False, qd=True)
-
-    @skipUnlessDarwin
-    @dsym_test
-    def test_short_type_with_dsym(self):
+    def test_short_type(self):
         """Test that short-type variables are displayed correctly."""
         self.build_and_run('short.cpp', set(['short']))
 
     @skipUnlessDarwin
-    @dsym_test
-    def test_short_type_from_block_with_dsym(self):
+    def test_short_type_from_block(self):
         """Test that short-type variables are displayed correctly from a block."""
         self.build_and_run('short.cpp', set(['short']), bc=True)
 
-    @dwarf_test
-    def test_short_type_with_dwarf(self):
-        """Test that short-type variables are displayed correctly."""
-        self.build_and_run('short.cpp', set(['short']), dsym=False)
-
-    @skipUnlessDarwin
-    @dsym_test
-    def test_unsigned_short_type_with_dsym(self):
+    def test_unsigned_short_type(self):
         """Test that 'unsigned_short'-type variables are displayed correctly."""
         self.build_and_run('unsigned_short.cpp', set(['unsigned', 'short']))
 
     @skipUnlessDarwin
-    @dsym_test
-    def test_unsigned_short_type_from_block_with_dsym(self):
+    def test_unsigned_short_type_from_block(self):
         """Test that 'unsigned short'-type variables are displayed correctly from a block."""
         self.build_and_run('unsigned_short.cpp', set(['unsigned', 'short']), bc=True)
 
-    @dwarf_test
-    def test_unsigned_short_type_with_dwarf(self):
-        """Test that 'unsigned short'-type variables are displayed correctly."""
-        self.build_and_run('unsigned_short.cpp', set(['unsigned', 'short']), dsym=False)
-
-    @skipUnlessDarwin
-    @dsym_test
-    def test_int_type_with_dsym(self):
+    def test_int_type(self):
         """Test that int-type variables are displayed correctly."""
         self.build_and_run('int.cpp', set(['int']))
 
     @skipUnlessDarwin
-    @dsym_test
-    def test_int_type_from_block_with_dsym(self):
+    def test_int_type_from_block(self):
         """Test that int-type variables are displayed correctly from a block."""
-        self.build_and_run('int.cpp', set(['int']), dsym=False)
-
-    @dwarf_test
-    def test_int_type_with_dwarf(self):
-        """Test that int-type variables are displayed correctly."""
-        self.build_and_run('int.cpp', set(['int']), dsym=False)
+        self.build_and_run('int.cpp', set(['int']))
 
-    @skipUnlessDarwin
-    @dsym_test
-    def test_unsigned_int_type_with_dsym(self):
+    def test_unsigned_int_type(self):
         """Test that 'unsigned_int'-type variables are displayed correctly."""
         self.build_and_run('unsigned_int.cpp', set(['unsigned', 'int']))
 
     @skipUnlessDarwin
-    @dsym_test
-    def test_unsigned_int_type_from_block_with_dsym(self):
+    def test_unsigned_int_type_from_block(self):
         """Test that 'unsigned int'-type variables are displayed correctly from a block."""
         self.build_and_run('unsigned_int.cpp', set(['unsigned', 'int']), bc=True)
 
-    @dwarf_test
-    def test_unsigned_int_type_with_dwarf(self):
-        """Test that 'unsigned int'-type variables are displayed correctly."""
-        self.build_and_run('unsigned_int.cpp', set(['unsigned', 'int']), dsym=False)
-
-    @skipUnlessDarwin
-    @dsym_test
-    def test_long_type_with_dsym(self):
+    def test_long_type(self):
         """Test that long-type variables are displayed correctly."""
         self.build_and_run('long.cpp', set(['long']))
 
     @skipUnlessDarwin
-    @dsym_test
-    def test_long_type_from_block_with_dsym(self):
+    def test_long_type_from_block(self):
         """Test that long-type variables are displayed correctly from a block."""
         self.build_and_run('long.cpp', set(['long']), bc=True)
 
-    @dwarf_test
-    def test_long_type_with_dwarf(self):
-        """Test that long-type variables are displayed correctly."""
-        self.build_and_run('long.cpp', set(['long']), dsym=False)
-
-    @skipUnlessDarwin
-    @dsym_test
-    def test_unsigned_long_type_with_dsym(self):
+    def test_unsigned_long_type(self):
         """Test that 'unsigned long'-type variables are displayed correctly."""
         self.build_and_run('unsigned_long.cpp', set(['unsigned', 'long']))
 
     @skipUnlessDarwin
-    @dsym_test
-    def test_unsigned_long_type_from_block_with_dsym(self):
+    def test_unsigned_long_type_from_block(self):
         """Test that 'unsigned_long'-type variables are displayed correctly from a block."""
         self.build_and_run('unsigned_long.cpp', set(['unsigned', 'long']), bc=True)
 
-    @dwarf_test
-    def test_unsigned_long_type_with_dwarf(self):
-        """Test that 'unsigned long'-type variables are displayed correctly."""
-        self.build_and_run('unsigned_long.cpp', set(['unsigned', 'long']), dsym=False)
-
-    # rdar://problem/8482903
-    # test suite failure for types dir -- "long long" and "unsigned long long"
-
-    @skipUnlessDarwin
-    @dsym_test
-    def test_long_long_type_with_dsym(self):
+    def test_long_long_type(self):
         """Test that 'long long'-type variables are displayed correctly."""
         self.build_and_run('long_long.cpp', set(['long long']))
 
     @skipUnlessDarwin
-    @dsym_test
-    def test_long_long_type_from_block_with_dsym(self):
+    def test_long_long_type_from_block(self):
         """Test that 'long_long'-type variables are displayed correctly from a block."""
         self.build_and_run('long_long.cpp', set(['long long']), bc=True)
 
-    @dwarf_test
-    def test_long_long_type_with_dwarf(self):
-        """Test that 'long long'-type variables are displayed correctly."""
-        self.build_and_run('long_long.cpp', set(['long long']), dsym=False)
-
-    @skipUnlessDarwin
-    @dsym_test
-    def test_unsigned_long_long_type_with_dsym(self):
+    def test_unsigned_long_long_type(self):
         """Test that 'unsigned long long'-type variables are displayed correctly."""
         self.build_and_run('unsigned_long_long.cpp', set(['unsigned', 'long long']))
 
     @skipUnlessDarwin
-    @dsym_test
-    def test_unsigned_long_long_type_from_block_with_dsym(self):
+    def test_unsigned_long_long_type_from_block(self):
         """Test that 'unsigned_long_long'-type variables are displayed correctly from a block."""
         self.build_and_run('unsigned_long_long.cpp', set(['unsigned', 'long long']), bc=True)
 
-    @dwarf_test
-    def test_unsigned_long_long_type_with_dwarf(self):
-        """Test that 'unsigned long long'-type variables are displayed correctly."""
-        self.build_and_run('unsigned_long_long.cpp', set(['unsigned', 'long long']), dsym=False)
-
 
 if __name__ == '__main__':
     import atexit
     lldb.SBDebugger.Initialize()
     atexit.register(lambda: lldb.SBDebugger.Terminate())
     unittest2.main()

test/types/TestIntegerTypesExpr.py

class IntegerTypesExprTestCase(AbstractBase.GenericTester):
 
     def setUp(self):
         # Call super's setUp().
         AbstractBase.GenericTester.setUp(self)
         # disable "There is a running process, kill it and restart?" prompt
         self.runCmd("settings set auto-confirm true")
         self.addTearDownHook(lambda: self.runCmd("settings clear auto-confirm"))
 
-    @skipUnlessDarwin
-    @dsym_test
-    def test_char_type_with_dsym(self):
+    def test_char_type(self):
         """Test that char-type variable expressions are evaluated correctly."""
         self.build_and_run_expr('char.cpp', set(['char']), qd=True)
 
     @skipUnlessDarwin
-    @dsym_test
-    def test_char_type_from_block_with_dsym(self):
+    def test_char_type_from_block(self):
         """Test that char-type variables are displayed correctly from a block."""
         self.build_and_run_expr('char.cpp', set(['char']), bc=True, qd=True)
 
-    @dwarf_test
-    def test_char_type_with_dwarf(self):
-        """Test that char-type variable expressions are evaluated correctly."""
-        self.build_and_run_expr('char.cpp', set(['char']), dsym=False, qd=True)
-
-    @skipUnlessDarwin
-    @dsym_test
-    def test_unsigned_char_type_with_dsym(self):
+    def test_unsigned_char_type(self):
         """Test that 'unsigned_char'-type variable expressions are evaluated correctly."""
         self.build_and_run_expr('unsigned_char.cpp', set(['unsigned', 'char']), qd=True)
 
     @skipUnlessDarwin
-    @dsym_test
-    def test_unsigned_char_type_from_block_with_dsym(self):
+    def test_unsigned_char_type_from_block(self):
         """Test that 'unsigned char'-type variables are displayed correctly from a block."""
         self.build_and_run_expr('unsigned_char.cpp', set(['unsigned', 'char']), bc=True, qd=True)
 
-    @dwarf_test
-    def test_unsigned_char_type_with_dwarf(self):
-        """Test that 'unsigned char'-type variable expressions are evaluated correctly."""
-        self.build_and_run_expr('unsigned_char.cpp', set(['unsigned', 'char']), dsym=False, qd=True)
-
-    @skipUnlessDarwin
-    @dsym_test
-    def test_short_type_with_dsym(self):
+    def test_short_type(self):
         """Test that short-type variable expressions are evaluated correctly."""
         self.build_and_run_expr('short.cpp', set(['short']))
 
     @skipUnlessDarwin
-    @dsym_test
-    def test_short_type_from_block_with_dsym(self):
+    def test_short_type_from_block(self):
         """Test that short-type variables are displayed correctly from a block."""
         self.build_and_run_expr('short.cpp', set(['short']), bc=True)
 
-    @dwarf_test
-    def test_short_type_with_dwarf(self):
-        """Test that short-type variable expressions are evaluated correctly."""
-        self.build_and_run_expr('short.cpp', set(['short']), dsym=False)
-
-    @skipUnlessDarwin
-    @dsym_test
-    def test_unsigned_short_type_with_dsym(self):
+    def test_unsigned_short_type(self):
         """Test that 'unsigned_short'-type variable expressions are evaluated correctly."""
         self.build_and_run_expr('unsigned_short.cpp', set(['unsigned', 'short']))
 
     @skipUnlessDarwin
-    @dsym_test
-    def test_unsigned_short_type_from_block_with_dsym(self):
+    def test_unsigned_short_type_from_block(self):
         """Test that 'unsigned short'-type variables are displayed correctly from a block."""
         self.build_and_run_expr('unsigned_short.cpp', set(['unsigned', 'short']), bc=True)
 
-    @dwarf_test
-    def test_unsigned_short_type_with_dwarf(self):
-        """Test that 'unsigned short'-type variable expressions are evaluated correctly."""
-        self.build_and_run_expr('unsigned_short.cpp', set(['unsigned', 'short']), dsym=False)
-
-    @skipUnlessDarwin
-    @dsym_test
-    def test_int_type_with_dsym(self):
+    def test_int_type(self):
         """Test that int-type variable expressions are evaluated correctly."""
         self.build_and_run_expr('int.cpp', set(['int']))
 
     @skipUnlessDarwin
-    @dsym_test
-    def test_int_type_from_block_with_dsym(self):
+    def test_int_type_from_block(self):
         """Test that int-type variables are displayed correctly from a block."""
-        self.build_and_run_expr('int.cpp', set(['int']), dsym=False)
-
-    @dwarf_test
-    def test_int_type_with_dwarf(self):
-        """Test that int-type variable expressions are evaluated correctly."""
-        self.build_and_run_expr('int.cpp', set(['int']), dsym=False)
+        self.build_and_run_expr('int.cpp', set(['int']))
 
-    @skipUnlessDarwin
-    @dsym_test
-    def test_unsigned_int_type_with_dsym(self):
+    def test_unsigned_int_type(self):
         """Test that 'unsigned_int'-type variable expressions are evaluated correctly."""
         self.build_and_run_expr('unsigned_int.cpp', set(['unsigned', 'int']))
 
     @skipUnlessDarwin
-    @dsym_test
-    def test_unsigned_int_type_from_block_with_dsym(self):
+    def test_unsigned_int_type_from_block(self):
         """Test that 'unsigned int'-type variables are displayed correctly from a block."""
         self.build_and_run_expr('unsigned_int.cpp', set(['unsigned', 'int']), bc=True)
 
-    @dwarf_test
-    def test_unsigned_int_type_with_dwarf(self):
-        """Test that 'unsigned int'-type variable expressions are evaluated correctly."""
-        self.build_and_run_expr('unsigned_int.cpp', set(['unsigned', 'int']), dsym=False)
-
-    @skipUnlessDarwin
-    @dsym_test
-    def test_long_type_with_dsym(self):
+    def test_long_type(self):
         """Test that long-type variable expressions are evaluated correctly."""
         self.build_and_run_expr('long.cpp', set(['long']))
 
     @skipUnlessDarwin
-    @dsym_test
-    def test_long_type_from_block_with_dsym(self):
+    def test_long_type_from_block(self):
         """Test that long-type variables are displayed correctly from a block."""
         self.build_and_run_expr('long.cpp', set(['long']), bc=True)
 
-    @dwarf_test
-    def test_long_type_with_dwarf(self):
-        """Test that long-type variable expressions are evaluated correctly."""
-        self.build_and_run_expr('long.cpp', set(['long']), dsym=False)
-
-    @skipUnlessDarwin
-    @dsym_test
-    def test_unsigned_long_type_with_dsym(self):
+    def test_unsigned_long_type(self):
         """Test that 'unsigned long'-type variable expressions are evaluated correctly."""
         self.build_and_run_expr('unsigned_long.cpp', set(['unsigned', 'long']))
 
     @skipUnlessDarwin
-    @dsym_test
-    def test_unsigned_long_type_from_block_with_dsym(self):
+    def test_unsigned_long_type_from_block(self):
         """Test that 'unsigned_long'-type variables are displayed correctly from a block."""
         self.build_and_run_expr('unsigned_long.cpp', set(['unsigned', 'long']), bc=True)
 
-    @dwarf_test
-    def test_unsigned_long_type_with_dwarf(self):
-        """Test that 'unsigned long'-type variable expressions are evaluated correctly."""
-        self.build_and_run_expr('unsigned_long.cpp', set(['unsigned', 'long']), dsym=False)
-
-    # rdar://problem/8482903
-    # test suite failure for types dir -- "long long" and "unsigned long long"
-
-    @skipUnlessDarwin
-    @dsym_test
-    def test_long_long_type_with_dsym(self):
+    def test_long_long_type(self):
         """Test that 'long long'-type variable expressions are evaluated correctly."""
         self.build_and_run_expr('long_long.cpp', set(['long long']))
 
     @skipUnlessDarwin
-    @dsym_test
-    def test_long_long_type_from_block_with_dsym(self):
+    def test_long_long_type_from_block(self):
         """Test that 'long_long'-type variables are displayed correctly from a block."""
         self.build_and_run_expr('long_long.cpp', set(['long long']), bc=True)
 
-    @dwarf_test
-    def test_long_long_type_with_dwarf(self):
-        """Test that 'long long'-type variable expressions are evaluated correctly."""
-        self.build_and_run_expr('long_long.cpp', set(['long long']), dsym=False)
-
-    @skipUnlessDarwin
-    @dsym_test
-    def test_unsigned_long_long_type_with_dsym(self):
+    def test_unsigned_long_long_type(self):
         """Test that 'unsigned long long'-type variable expressions are evaluated correctly."""
         self.build_and_run_expr('unsigned_long_long.cpp', set(['unsigned', 'long long']))
 
     @skipUnlessDarwin
-    @dsym_test
-    def test_unsigned_long_long_type_from_block_with_dsym(self):
+    def test_unsigned_long_long_type_from_block(self):
         """Test that 'unsigned_long_long'-type variables are displayed correctly from a block."""
         self.build_and_run_expr('unsigned_long_long.cpp', set(['unsigned', 'long long']), bc=True)
 
-    @dwarf_test
-    def test_unsigned_long_long_type_with_dwarf(self):
-        """Test that 'unsigned long long'-type variable expressions are evaluated correctly."""
-        self.build_and_run_expr('unsigned_long_long.cpp', set(['unsigned', 'long long']), dsym=False)
-
 
 if __name__ == '__main__':
     import atexit
     lldb.SBDebugger.Initialize()
     atexit.register(lambda: lldb.SBDebugger.Terminate())
     unittest2.main()

test/types/TestRecursiveTypes.py

def setUp(self):
         self.addTearDownHook(lambda: self.runCmd("settings clear auto-confirm"))
         # Find the line number to break for main.c.
         self.line = line_number('recursive_type_main.cpp',
                                 '// Test at this line.')
 
         self.d1 = {'CXX_SOURCES': 'recursive_type_main.cpp recursive_type_1.cpp'}
         self.d2 = {'CXX_SOURCES': 'recursive_type_main.cpp recursive_type_2.cpp'}
 
-    @unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin")
-    @dsym_test
-    def test_recursive_dsym_type_1(self):
+    def test_recursive_type_1(self):
         """Test that recursive structs are displayed correctly."""
-        self.buildDsym(dictionary=self.d1)
+        self.build(dictionary=self.d1)
         self.setTearDownCleanup(dictionary=self.d1)
         self.print_struct()
 
-    @dwarf_test
-    def test_recursive_dwarf_type_1(self):
+    def test_recursive_type_2(self):
         """Test that recursive structs are displayed correctly."""
-        self.buildDwarf(dictionary=self.d1)
-        self.setTearDownCleanup(dictionary=self.d1)
-        self.print_struct()
-
-    @unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin")
-    @dsym_test
-    def test_recursive_dsym_type_2(self):
-        """Test that recursive structs are displayed correctly."""
-        self.buildDsym(dictionary=self.d2)
-        self.setTearDownCleanup(dictionary=self.d2)
-        self.print_struct()
-
-    @dwarf_test
-    def test_recursive_dwarf_type_2(self):
-        """Test that recursive structs are displayed correctly."""
-        self.buildDwarf(dictionary=self.d2)
+        self.build(dictionary=self.d1)
         self.setTearDownCleanup(dictionary=self.d2)
         self.print_struct()
 
     def print_struct(self):
         self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
 
         lldbutil.run_break_set_by_file_and_line (self, "recursive_type_main.cpp", self.line, num_expected_locations=-1, loc_exact=True)