Vendor import of lldb release_39 branch r276489:vendor/lldb/lldb-release_39-r276489

https://llvm.org/svn/llvm-project/lldb/branches/release_39@276489

262 files changed, 4239 insertions, 1232 deletions

diff --git a/packages/Python/lldbsuite/test/functionalities/abbreviation/TestAbbreviations.py b/packages/Python/lldbsuite/test/functionalities/abbreviation/TestAbbreviations.py
index 1bce5bed491f..6423ecf27aeb 100644
--- a/packages/Python/lldbsuite/test/functionalities/abbreviation/TestAbbreviations.py
+++ b/packages/Python/lldbsuite/test/functionalities/abbreviation/TestAbbreviations.py
@@ -8,14 +8,14 @@ from __future__ import print_function
 
 import os, time
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test 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()
diff --git a/packages/Python/lldbsuite/test/functionalities/abbreviation/TestCommonShortSpellings.py b/packages/Python/lldbsuite/test/functionalities/abbreviation/TestCommonShortSpellings.py
index 9edbf212278c..fa6f3f306898 100644
--- a/packages/Python/lldbsuite/test/functionalities/abbreviation/TestCommonShortSpellings.py
+++ b/packages/Python/lldbsuite/test/functionalities/abbreviation/TestCommonShortSpellings.py
@@ -9,8 +9,9 @@ from __future__ import print_function
 
 import os, time
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbutil
 
 class CommonShortSpellingsTestCase(TestBase):
     
diff --git a/packages/Python/lldbsuite/test/functionalities/apropos_with_process/Makefile b/packages/Python/lldbsuite/test/functionalities/apropos_with_process/Makefile
new file mode 100644
index 000000000000..8a7102e347af
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/apropos_with_process/Makefile
@@ -0,0 +1,5 @@
+LEVEL = ../../make
+
+CXX_SOURCES := main.cpp
+
+include $(LEVEL)/Makefile.rules
diff --git a/packages/Python/lldbsuite/test/functionalities/apropos_with_process/TestAproposWithProcess.py b/packages/Python/lldbsuite/test/functionalities/apropos_with_process/TestAproposWithProcess.py
new file mode 100644
index 000000000000..66ed3ff73298
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/apropos_with_process/TestAproposWithProcess.py
@@ -0,0 +1,44 @@
+"""
+Test that apropos env doesn't crash trying to touch the process plugin commmand
+"""
+
+from __future__ import print_function
+
+
+
+import os, time
+import re
+import lldb
+from lldbsuite.test.lldbtest import *
+import lldbsuite.test.lldbutil as lldbutil
+
+class AproposWithProcessTestCase(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    def setUp(self):
+        # Call super's setUp().
+        TestBase.setUp(self)
+        # Find the line number to break inside main().
+        self.line = line_number('main.cpp', '// break here')
+
+    def test_apropos_with_process(self):
+        """Test that apropos env doesn't crash trying to touch the process plugin commmand."""
+        self.build()
+        exe = os.path.join(os.getcwd(), "a.out")
+        self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
+
+        # Break in main() aftre the variables are assigned values.
+        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)
+
+        # The stop reason of the thread should be breakpoint.
+        self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
+            substrs = ['stopped', 'stop reason = breakpoint'])
+
+        # The breakpoint should have a hit count of 1.
+        self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
+            substrs = [' resolved, hit count = 1'])
+
+        self.runCmd('apropos env')
diff --git a/packages/Python/lldbsuite/test/functionalities/apropos_with_process/main.cpp b/packages/Python/lldbsuite/test/functionalities/apropos_with_process/main.cpp
new file mode 100644
index 000000000000..44c149687f21
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/apropos_with_process/main.cpp
@@ -0,0 +1,15 @@
+//===-- main.cpp ------------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#include <stdio.h>
+
+int main (int argc, char const *argv[])
+{
+  return 0; // break here
+}
+
diff --git a/packages/Python/lldbsuite/test/functionalities/archives/TestBSDArchives.py b/packages/Python/lldbsuite/test/functionalities/archives/TestBSDArchives.py
index 02e1b9551853..b419ad97a694 100644
--- a/packages/Python/lldbsuite/test/functionalities/archives/TestBSDArchives.py
+++ b/packages/Python/lldbsuite/test/functionalities/archives/TestBSDArchives.py
@@ -6,8 +6,9 @@ from __future__ import print_function
 
 import os, time
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbutil
 
 class BSDArchivesTestCase(TestBase):
 
@@ -19,7 +20,8 @@ class BSDArchivesTestCase(TestBase):
         # Find the line number in a(int) to break at.
         self.line = line_number('a.c', '// Set file and line breakpoint inside a().')
 
-    @expectedFailureWindows("llvm.org/pr24527") # Makefile.rules doesn't know how to build static libs on Windows.
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24527.  Makefile.rules doesn't know how to build static libs on Windows")
+    @expectedFailureAll(oslist=["linux"], archs=["arm", "aarch64"], bugnumber="llvm.org/pr27795")
     def test(self):
         """Break inside a() and b() defined within libfoo.a."""
         self.build()
diff --git a/packages/Python/lldbsuite/test/functionalities/asan/TestMemoryHistory.py b/packages/Python/lldbsuite/test/functionalities/asan/TestMemoryHistory.py
index e92b967d8adf..6416bccc483d 100644
--- a/packages/Python/lldbsuite/test/functionalities/asan/TestMemoryHistory.py
+++ b/packages/Python/lldbsuite/test/functionalities/asan/TestMemoryHistory.py
@@ -8,18 +8,19 @@ from __future__ import print_function
 
 import os, time
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbplatform
+from lldbsuite.test import lldbutil
 
 class AsanTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @expectedFailureLinux # non-core functionality, need to reenable and fix later (DES 2014.11.07)
+    @expectedFailureAll(oslist=["linux"], bugnumber="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
-    @expectedFailureDarwin
     def test (self):
         self.build ()
         self.asan_tests ()
@@ -45,11 +46,10 @@ class AsanTestCase(TestBase):
 
         self.runCmd("run")
 
-        # ASan will relaunch the process to insert its library.
-        self.expect("thread list", "Process should be stopped due to exec.",
-            substrs = ['stopped', 'stop reason = '])
-
-        self.runCmd("continue")
+        stop_reason = self.dbg.GetSelectedTarget().process.GetSelectedThread().GetStopReason()
+        if stop_reason == lldb.eStopReasonExec:
+            # On OS X 10.10 and older, we need to re-exec to enable interceptors.
+            self.runCmd("continue")
 
         # the stop reason of the thread should be breakpoint.
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
@@ -62,8 +62,8 @@ class AsanTestCase(TestBase):
         # test the 'memory history' command
         self.expect("memory history 'pointer'",
             substrs = [
-                'Memory allocated at', 'a.out`f1', 'main.c:%d' % self.line_malloc,
-                'Memory deallocated at', 'a.out`f2', 'main.c:%d' % self.line_free])
+                'Memory allocated by Thread', 'a.out`f1', 'main.c:%d' % self.line_malloc,
+                'Memory deallocated by Thread', 'a.out`f2', 'main.c:%d' % self.line_free])
 
         # do the same using SB API
         process = self.dbg.GetSelectedTarget().process
@@ -87,17 +87,14 @@ class AsanTestCase(TestBase):
         self.assertTrue(history_thread.num_frames >= 2)
         self.assertEqual(history_thread.frames[1].GetLineEntry().GetFileSpec().GetFilename(), "main.c")
         self.assertEqual(history_thread.frames[1].GetLineEntry().GetLine(), self.line_malloc)
-
-        # now let's break when an ASan report occurs and try the API then
-        self.runCmd("breakpoint set -n __asan_report_error")
-
+        
+        # ASan will break when a report occurs and we'll try the API then
         self.runCmd("continue")
 
-        # the stop reason of the thread should be breakpoint.
-        self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
-            substrs = ['stopped', 'stop reason = breakpoint'])
+        self.expect("thread list", "Process should be stopped due to ASan report",
+            substrs = ['stopped', 'stop reason = Use of deallocated memory detected'])
 
         # make sure the 'memory history' command still works even when we're generating a report now
         self.expect("memory history 'another_pointer'",
             substrs = [
-                'Memory allocated at', 'a.out`f1', 'main.c:%d' % self.line_malloc2])
+                'Memory allocated by Thread', 'a.out`f1', 'main.c:%d' % self.line_malloc2])
diff --git a/packages/Python/lldbsuite/test/functionalities/asan/TestReportData.py b/packages/Python/lldbsuite/test/functionalities/asan/TestReportData.py
index 4ef587895196..b02732ddeddf 100644
--- a/packages/Python/lldbsuite/test/functionalities/asan/TestReportData.py
+++ b/packages/Python/lldbsuite/test/functionalities/asan/TestReportData.py
@@ -7,20 +7,20 @@ from __future__ import print_function
 
 
 import os, time
+import json
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
-import json
+from lldbsuite.test import lldbutil
 
 class AsanTestReportDataCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @expectedFailureLinux # non-core functionality, need to reenable and fix later (DES 2014.11.07)
+    @expectedFailureAll(oslist=["linux"], bugnumber="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
-    @expectedFailureDarwin
     def test(self):
         self.build ()
         self.asan_tests ()
@@ -39,16 +39,10 @@ class AsanTestReportDataCase(TestBase):
         self.expect("file " + exe, patterns = [ "Current executable set to .*a.out" ])
         self.runCmd("run")
 
-        # ASan will relaunch the process to insert its library.
-        self.expect("thread list", "Process should be stopped due to exec.",
-            substrs = ['stopped', 'stop reason = '])
-
-        # no extended info when we have no ASan report
-        thread = self.dbg.GetSelectedTarget().process.GetSelectedThread()
-        s = lldb.SBStream()
-        self.assertFalse(thread.GetStopReasonExtendedInfoAsJSON(s))
-
-        self.runCmd("continue")
+        stop_reason = self.dbg.GetSelectedTarget().process.GetSelectedThread().GetStopReason()
+        if stop_reason == lldb.eStopReasonExec:
+            # On OS X 10.10 and older, we need to re-exec to enable interceptors.
+            self.runCmd("continue")
 
         self.expect("thread list", "Process should be stopped due to ASan report",
             substrs = ['stopped', 'stop reason = Use of deallocated memory detected'])
@@ -62,7 +56,7 @@ class AsanTestReportDataCase(TestBase):
             substrs = ["access_size", "access_type", "address", "pc", "description", "heap-use-after-free"])
 
         output_lines = self.res.GetOutput().split('\n')
-        json_line = output_lines[2]
+        json_line = '\n'.join(output_lines[2:])
         data = json.loads(json_line)
         self.assertEqual(data["description"], "heap-use-after-free")
         self.assertEqual(data["instrumentation_class"], "AddressSanitizer")
diff --git a/packages/Python/lldbsuite/test/functionalities/attach_resume/TestAttachResume.py b/packages/Python/lldbsuite/test/functionalities/attach_resume/TestAttachResume.py
index 693c0a70fd62..54463c56827a 100644
--- a/packages/Python/lldbsuite/test/functionalities/attach_resume/TestAttachResume.py
+++ b/packages/Python/lldbsuite/test/functionalities/attach_resume/TestAttachResume.py
@@ -8,8 +8,9 @@ from __future__ import print_function
 
 import os, time
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbutil
 
 exe_name = "AttachResume"  # Must match Makefile
 
@@ -18,8 +19,8 @@ class AttachResumeTestCase(TestBase):
     mydir = TestBase.compute_mydir(__file__)
 
     @skipIfRemote
-    @expectedFailureFreeBSD('llvm.org/pr19310')
-    @expectedFailureWindows("llvm.org/pr24778")
+    @expectedFailureAll(oslist=['freebsd'], bugnumber='llvm.org/pr19310')
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778")
     def test_attach_continue_interrupt_detach(self):
         """Test attach/continue/interrupt/detach"""
         self.build()
@@ -37,19 +38,20 @@ class AttachResumeTestCase(TestBase):
 
         self.setAsync(True)
         listener = self.dbg.GetListener()
+        process = self.dbg.GetSelectedTarget().GetProcess()
 
         self.runCmd("c")
-        lldbutil.expect_state_changes(self, listener, [lldb.eStateRunning])
+        lldbutil.expect_state_changes(self, listener, process, [lldb.eStateRunning])
 
         self.runCmd("process interrupt")
-        lldbutil.expect_state_changes(self, listener, [lldb.eStateStopped])
+        lldbutil.expect_state_changes(self, listener, process, [lldb.eStateStopped])
 
         # be sure to continue/interrupt/continue (r204504)
         self.runCmd("c")
-        lldbutil.expect_state_changes(self, listener, [lldb.eStateRunning])
+        lldbutil.expect_state_changes(self, listener, process, [lldb.eStateRunning])
 
         self.runCmd("process interrupt")
-        lldbutil.expect_state_changes(self, listener, [lldb.eStateStopped])
+        lldbutil.expect_state_changes(self, listener, process, [lldb.eStateStopped])
 
         # Second interrupt should have no effect.
         self.expect("process interrupt", patterns=["Process is not running"], error=True)
@@ -58,7 +60,7 @@ class AttachResumeTestCase(TestBase):
         self.runCmd("br set -f main.cpp -l %u" % (line_number('main.cpp', '// Set breakpoint here')))
 
         self.runCmd("c")
-        lldbutil.expect_state_changes(self, listener, [lldb.eStateRunning, lldb.eStateStopped])
+        lldbutil.expect_state_changes(self, listener, process, [lldb.eStateRunning, lldb.eStateStopped])
         self.expect('br list', 'Breakpoint not hit',
             substrs = ['hit count = 1'])
 
@@ -66,8 +68,8 @@ class AttachResumeTestCase(TestBase):
         self.expect("expr debugger_flag = false", substrs=[" = false"]);
 
         self.runCmd("c")
-        lldbutil.expect_state_changes(self, listener, [lldb.eStateRunning])
+        lldbutil.expect_state_changes(self, listener, process, [lldb.eStateRunning])
 
         # make sure to detach while in running state (r204759)
         self.runCmd("detach")
-        lldbutil.expect_state_changes(self, listener, [lldb.eStateDetached])
+        lldbutil.expect_state_changes(self, listener, process, [lldb.eStateDetached])
diff --git a/packages/Python/lldbsuite/test/functionalities/avoids-fd-leak/TestFdLeak.py b/packages/Python/lldbsuite/test/functionalities/avoids-fd-leak/TestFdLeak.py
index e4bc08711f4c..e31eac48ad7a 100644
--- a/packages/Python/lldbsuite/test/functionalities/avoids-fd-leak/TestFdLeak.py
+++ b/packages/Python/lldbsuite/test/functionalities/avoids-fd-leak/TestFdLeak.py
@@ -8,29 +8,34 @@ from __future__ import print_function
 
 import os
 import lldb
+from lldbsuite.test import lldbutil
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test.decorators import *
 
 
 def python_leaky_fd_version(test):
     import sys
     # Python random module leaks file descriptors on some versions.
-    return sys.version_info >= (2, 7, 8) and sys.version_info < (2, 7, 10)
+    if sys.version_info >= (2, 7, 8) and sys.version_info < (2, 7, 10):
+        return "Python random module leaks file descriptors in this python version"
+    return None
 
 
 class AvoidsFdLeakTestCase(TestBase):
 
+    NO_DEBUG_INFO_TESTCASE = True
+
     mydir = TestBase.compute_mydir(__file__)
 
     @expectedFailure(python_leaky_fd_version, "bugs.freebsd.org/197376")
-    @expectedFailureFreeBSD("llvm.org/pr25624 still failing with Python 2.7.10")
+    @expectedFailureAll(oslist=['freebsd'], bugnumber="llvm.org/pr25624 still failing with Python 2.7.10")
     @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_basic (self):
         self.do_test([])
 
     @expectedFailure(python_leaky_fd_version, "bugs.freebsd.org/197376")
-    @expectedFailureFreeBSD("llvm.org/pr25624 still failing with Python 2.7.10")
+    @expectedFailureAll(oslist=['freebsd'], bugnumber="llvm.org/pr25624 still failing with Python 2.7.10")
     @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):
@@ -53,8 +58,7 @@ class AvoidsFdLeakTestCase(TestBase):
                 "Process returned non-zero status. Were incorrect file descriptors passed?")
 
     @expectedFailure(python_leaky_fd_version, "bugs.freebsd.org/197376")
-    @expectedFailureFreeBSD("llvm.org/pr25624 still failing with Python 2.7.10")
-    @expectedFlakeyLinux
+    @expectedFailureAll(oslist=['freebsd'], bugnumber="llvm.org/pr25624 still failing with Python 2.7.10")
     @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):
diff --git a/packages/Python/lldbsuite/test/functionalities/backticks/TestBackticksWithoutATarget.py b/packages/Python/lldbsuite/test/functionalities/backticks/TestBackticksWithoutATarget.py
index d31412bc783c..851e4d376b38 100644
--- a/packages/Python/lldbsuite/test/functionalities/backticks/TestBackticksWithoutATarget.py
+++ b/packages/Python/lldbsuite/test/functionalities/backticks/TestBackticksWithoutATarget.py
@@ -8,7 +8,9 @@ from __future__ import print_function
 
 import os, time
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
 
 class BackticksWithNoTargetTestCase(TestBase):
 
diff --git a/packages/Python/lldbsuite/test/functionalities/breakpoint/address_breakpoints/TestBadAddressBreakpoints.py b/packages/Python/lldbsuite/test/functionalities/breakpoint/address_breakpoints/TestBadAddressBreakpoints.py
new file mode 100644
index 000000000000..73b3ef5eae28
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/breakpoint/address_breakpoints/TestBadAddressBreakpoints.py
@@ -0,0 +1,77 @@
+"""
+Test that breakpoints set on a bad address say they are bad.
+"""
+
+from __future__ import print_function
+
+
+
+import os, time
+import re
+import lldb
+import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test.lldbtest import *
+
+class BadAddressBreakpointTestCase(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    def test_bad_address_breakpoints (self):
+        """Test that breakpoints set on a bad address say they are bad."""
+        self.build()
+        self.address_breakpoints()
+
+    def setUp(self):
+        # Call super's setUp().
+        TestBase.setUp(self)
+
+    def address_breakpoints(self):
+        """Test that breakpoints set on a bad address say they are bad."""
+        exe = os.path.join(os.getcwd(), "a.out")
+
+        # Create a target by the debugger.
+        target = self.dbg.CreateTarget(exe)
+        self.assertTrue(target, VALID_TARGET)
+
+        # Now create a breakpoint on main.c by name 'c'.
+        breakpoint = target.BreakpointCreateBySourceRegex("Set a breakpoint here", lldb.SBFileSpec("main.c"))
+        self.assertTrue(breakpoint and
+                        breakpoint.GetNumLocations() == 1,
+                        VALID_BREAKPOINT)
+
+        # Get the breakpoint location from breakpoint after we verified that,
+        # indeed, it has one location.
+        location = breakpoint.GetLocationAtIndex(0)
+        self.assertTrue(location and
+                        location.IsEnabled(),
+                        VALID_BREAKPOINT_LOCATION)
+
+        launch_info = lldb.SBLaunchInfo(None)
+        
+        error = lldb.SBError()
+
+        process = target.Launch (launch_info, error)
+        self.assertTrue(process, PROCESS_IS_VALID)
+
+        # Did we hit our breakpoint?
+        from lldbsuite.test.lldbutil import get_threads_stopped_at_breakpoint 
+        threads = get_threads_stopped_at_breakpoint (process, breakpoint)
+        self.assertTrue(len(threads) == 1, "There should be a thread stopped at our breakpoint")
+
+        # The hit count for the breakpoint should be 1.
+        self.assertTrue(breakpoint.GetHitCount() == 1)
+
+        # Now see if we can read from 0.  If I can't do that, I don't have a good way to know
+        # what an illegal address is...
+        error.Clear()
+
+        ptr = process.ReadPointerFromMemory(0x0, error)
+
+        if not error.Success():
+            bkpt = target.BreakpointCreateByAddress(0x0)
+            for bp_loc in bkpt:
+                self.assertTrue(bp_loc.IsResolved() == False)
+        else:
+            self.fail("Could not find an illegal address at which to set a bad breakpoint.")
+            
+            
diff --git a/packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_case_sensitivity/Makefile b/packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_case_sensitivity/Makefile
new file mode 100644
index 000000000000..6067ee45e984
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_case_sensitivity/Makefile
@@ -0,0 +1,6 @@
+LEVEL = ../../../make
+
+C_SOURCES := main.c
+CFLAGS_EXTRAS += -std=c99
+
+include $(LEVEL)/Makefile.rules
diff --git a/packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_case_sensitivity/TestBreakpointCaseSensitivity.py b/packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_case_sensitivity/TestBreakpointCaseSensitivity.py
new file mode 100644
index 000000000000..aa4ee14ffc5a
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_case_sensitivity/TestBreakpointCaseSensitivity.py
@@ -0,0 +1,121 @@
+"""
+Test case sensitivity of paths on Windows / POSIX
+llvm.org/pr22667
+"""
+
+import os
+import lldb
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test.decorators import *
+from lldbsuite.test import lldbplatform, lldbplatformutil
+
+class BreakpointCaseSensitivityTestCase(TestBase):
+    mydir = TestBase.compute_mydir(__file__)
+    BREAKPOINT_TEXT = 'Set a breakpoint here'
+
+    def setUp(self):
+        # Call super's setUp().
+        TestBase.setUp(self)
+        self.line = line_number('main.c', self.BREAKPOINT_TEXT)
+
+    @skipIf(oslist=no_match(['windows']))  # Skip for non-windows platforms
+    def test_breakpoint_matches_file_with_different_case(self):
+        """Set breakpoint on file, should match files with different case on Windows"""
+        self.build()
+        self.case_sensitivity_breakpoint(True)
+
+    @skipIf(oslist=['windows']) # Skip for windows platforms
+    @expectedFailureAll() # Failing for unknown reason on non-Windows platforms.
+    def test_breakpoint_doesnt_match_file_with_different_case(self):
+        """Set breakpoint on file, shouldn't match files with different case on POSIX systems"""
+        self.build()
+        self.case_sensitivity_breakpoint(False)
+
+    def case_sensitivity_breakpoint(self, case_insensitive):
+        """Set breakpoint on file, should match files with different case if case_insensitive is True"""
+        
+        # use different case to check CreateTarget
+        exe = 'a.out'
+        if case_insensitive:
+            exe = exe.upper()
+            
+        exe = os.path.join(os.getcwd(), exe)
+
+        # Create a target by the debugger.
+        self.target = self.dbg.CreateTarget(exe)
+        self.assertTrue(self.target, VALID_TARGET)
+        cwd = self.get_process_working_directory();
+                
+        # try both BreakpointCreateByLocation and BreakpointCreateBySourceRegex
+        for regex in [False, True]:
+            # should always hit
+            self.check_breakpoint('main.c', regex, True)
+            # should always hit
+            self.check_breakpoint(os.path.join(cwd, 'main.c'), regex, True)
+            # different case for directory
+            self.check_breakpoint(os.path.join(cwd.upper(), 'main.c'),
+                                  regex,
+                                  case_insensitive)
+            # different case for file
+            self.check_breakpoint('Main.c',
+                                  regex,
+                                  case_insensitive)
+            # different case for both
+            self.check_breakpoint(os.path.join(cwd.upper(), 'Main.c'),
+                                  regex,
+                                  case_insensitive)
+
+    def check_breakpoint(self, file, source_regex, should_hit):
+        """
+        Check breakpoint hit at given file set by given method
+        
+        file:
+            File where insert the breakpoint
+        
+        source_regex:
+            True for testing using BreakpointCreateBySourceRegex,
+            False for  BreakpointCreateByLocation
+            
+        should_hit:
+            True if the breakpoint should hit, False otherwise
+        """
+        
+        desc = ' file %s set by %s' % (file, 'regex' if source_regex else 'location')
+        if source_regex:
+            breakpoint = self.target.BreakpointCreateBySourceRegex(self.BREAKPOINT_TEXT,
+                                                                   lldb.SBFileSpec(file))
+        else:    
+            breakpoint = self.target.BreakpointCreateByLocation(file, self.line)
+        
+        self.assertEqual(breakpoint and breakpoint.GetNumLocations() == 1,
+                    should_hit,
+                    VALID_BREAKPOINT + desc)
+
+        # Get the breakpoint location from breakpoint after we verified that,
+        # indeed, it has one location.
+        location = breakpoint.GetLocationAtIndex(0)
+        self.assertEqual(location and location.IsEnabled(),
+                    should_hit,
+                    VALID_BREAKPOINT_LOCATION + desc)
+        
+        process = self.target.LaunchSimple(None, None, self.get_process_working_directory())
+        self.assertTrue(process, PROCESS_IS_VALID + desc)
+
+        if should_hit:
+            # Did we hit our breakpoint?
+            from lldbsuite.test.lldbutil import get_threads_stopped_at_breakpoint 
+            threads = get_threads_stopped_at_breakpoint (process, breakpoint)
+            self.assertEqual(len(threads), 1, "There should be a thread stopped at breakpoint" + desc)
+            # The hit count for the breakpoint should be 1.
+            self.assertEqual(breakpoint.GetHitCount(), 1)
+            
+        else:
+            # check the breakpoint was not hit
+            self.assertEqual(lldb.eStateExited, process.GetState())
+            self.assertEqual(breakpoint.GetHitCount(), 0)
+
+        # let process finish
+        process.Continue()
+        
+        # cleanup
+        self.target.BreakpointDelete(breakpoint.GetID())
diff --git a/packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_case_sensitivity/main.c b/packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_case_sensitivity/main.c
new file mode 100644
index 000000000000..281ddfe7ef67
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_case_sensitivity/main.c
@@ -0,0 +1,8 @@
+#include <stdio.h>
+
+int
+main()
+{
+    printf("Set a breakpoint here.\n");
+    return 0;
+}
diff --git a/packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_command/TestBreakpointCommand.py b/packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_command/TestBreakpointCommand.py
index 8cf7539432ba..78d14b7d7705 100644
--- a/packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_command/TestBreakpointCommand.py
+++ b/packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_command/TestBreakpointCommand.py
@@ -8,8 +8,9 @@ from __future__ import print_function
 
 import os, time
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbutil
 
 class BreakpointCommandTestCase(TestBase):
 
@@ -21,7 +22,7 @@ class BreakpointCommandTestCase(TestBase):
         cls.RemoveTempFile("output.txt")
         cls.RemoveTempFile("output2.txt")
 
-    @expectedFailureWindows("llvm.org/pr24528")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24528")
     def test(self):
         """Test a sequence of breakpoint command add, list, and delete."""
         self.build()
@@ -142,7 +143,7 @@ class BreakpointCommandTestCase(TestBase):
         self.expect("breakpoint command list 1",
             startstr = "Breakpoint 1 does not have an associated command.")
         self.expect("breakpoint command list 2", error=True,
-            startstr = "error: '2' is not a currently valid breakpoint id.")
+            startstr = "error: '2' is not a currently valid breakpoint ID.")
 
         # The breakpoint list now only contains breakpoint 1.
         self.expect("breakpoint list -f", "Breakpoint 1 exists",
diff --git a/packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_command/TestBreakpointCommandsFromPython.py b/packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_command/TestBreakpointCommandsFromPython.py
index 7a9cc744d528..4f8ab9e115de 100644
--- a/packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_command/TestBreakpointCommandsFromPython.py
+++ b/packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_command/TestBreakpointCommandsFromPython.py
@@ -8,10 +8,11 @@ from __future__ import print_function
 
 import os
 import re
-import lldb
-import lldbsuite.test.lldbutil as lldbutil
 import sys
+import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
 
 class PythonBreakpointCommandSettingTestCase(TestBase):
 
diff --git a/packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_conditions/TestBreakpointConditions.py b/packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_conditions/TestBreakpointConditions.py
index 8c22c8fe869c..0d34dd85dc50 100644
--- a/packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_conditions/TestBreakpointConditions.py
+++ b/packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_conditions/TestBreakpointConditions.py
@@ -9,8 +9,9 @@ from __future__ import print_function
 import os, time
 import re
 import lldb
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
 
 class BreakpointConditionsTestCase(TestBase):
 
@@ -107,11 +108,13 @@ class BreakpointConditionsTestCase(TestBase):
         if arch in ['x86_64', 'i386']:
             self.runCmd("breakpoint modify -c ($eax&&i)")
         elif arch in ['aarch64']:
-            self.runCmd("breakpoint modify -c ($x1&&i)")
+            self.runCmd("breakpoint modify -c ($x0&&i)")
         elif arch in ['arm']:
             self.runCmd("breakpoint modify -c ($r0&&i)")
         elif re.match("mips",arch):
             self.runCmd("breakpoint modify -c ($r2&&i)")
+        elif arch in ['s390x']:
+            self.runCmd("breakpoint modify -c ($r2&&i)")
         self.runCmd("run")
 
         self.expect("process status", PROCESS_STOPPED,
@@ -178,4 +181,8 @@ class BreakpointConditionsTestCase(TestBase):
         # The hit count for the breakpoint should be 1.
         self.assertTrue(breakpoint.GetHitCount() == 1)
 
+        # Test that the condition expression didn't create a result variable:
+        options = lldb.SBExpressionOptions()
+        value = frame0.EvaluateExpression("$0", options)
+        self.assertTrue(value.GetError().Fail(), "Conditions should not make result variables.")
         process.Continue()
diff --git a/packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_ignore_count/TestBreakpointIgnoreCount.py b/packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_ignore_count/TestBreakpointIgnoreCount.py
index 8a83cb627f7a..05ef1c6d94c7 100644
--- a/packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_ignore_count/TestBreakpointIgnoreCount.py
+++ b/packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_ignore_count/TestBreakpointIgnoreCount.py
@@ -9,8 +9,9 @@ from __future__ import print_function
 import os, time
 import re
 import lldb
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
 
 class BreakpointIgnoreCountTestCase(TestBase):
 
diff --git a/packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_in_delayslot/TestAvoidBreakpointInDelaySlot.py b/packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_in_delayslot/TestAvoidBreakpointInDelaySlot.py
index 324401ff44e1..b1e0d3deeae7 100644
--- a/packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_in_delayslot/TestAvoidBreakpointInDelaySlot.py
+++ b/packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_in_delayslot/TestAvoidBreakpointInDelaySlot.py
@@ -8,14 +8,15 @@ import os, time
 import re
 import unittest2
 import lldb
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
 
 class AvoidBreakpointInDelaySlotAPITestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @skipUnlessArch(archs=re.compile('mips*'))
+    @skipIf(archs=no_match(re.compile('mips*')))
     def test(self):
         self.build()
         exe = os.path.join(os.getcwd(), "a.out")
diff --git a/packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_locations/TestBreakpointLocations.py b/packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_locations/TestBreakpointLocations.py
index 5c4dc219a106..707b6502e91c 100644
--- a/packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_locations/TestBreakpointLocations.py
+++ b/packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_locations/TestBreakpointLocations.py
@@ -8,15 +8,15 @@ from __future__ import print_function
 
 import os, time
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbutil
 
 class BreakpointLocationsTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @expectedFailureWindows("llvm.org/pr24528")
-    @expectedFailureAll(oslist=["linux"], compiler="clang", compiler_version=["=", "3.8"], archs=["i386"], debug_info="dwo")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24528")
     def test(self):
         """Test breakpoint enable/disable for a breakpoint ID with multiple locations."""
         self.build()
diff --git a/packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_set_restart/Makefile b/packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_set_restart/Makefile
new file mode 100644
index 000000000000..314f1cb2f077
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_set_restart/Makefile
@@ -0,0 +1,5 @@
+LEVEL = ../../../make
+
+CXX_SOURCES := main.cpp
+
+include $(LEVEL)/Makefile.rules
diff --git a/packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_set_restart/TestBreakpointSetRestart.py b/packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_set_restart/TestBreakpointSetRestart.py
new file mode 100644
index 000000000000..4ca93765b656
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_set_restart/TestBreakpointSetRestart.py
@@ -0,0 +1,43 @@
+"""
+Test inferior restart when breakpoint is set on running target.
+"""
+
+import os
+import lldb
+from lldbsuite.test.lldbtest import *
+
+class BreakpointSetRestart(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+    BREAKPOINT_TEXT = 'Set a breakpoint here'
+
+    def test_breakpoint_set_restart(self):
+        self.build()
+
+        cwd = os.getcwd()
+        exe = os.path.join(cwd, 'a.out')
+        
+        target = self.dbg.CreateTarget(exe)
+        self.assertTrue(target, VALID_TARGET)
+
+        self.dbg.SetAsync(True)
+        process = target.LaunchSimple(None, None, self.get_process_working_directory())
+        self.assertTrue(process, PROCESS_IS_VALID)
+
+        event = lldb.SBEvent()
+        # Wait for inferior to transition to running state
+        while self.dbg.GetListener().WaitForEvent(2, event):
+            if lldb.SBProcess.GetStateFromEvent(event) == lldb.eStateRunning:
+                break
+        
+        bp = target.BreakpointCreateBySourceRegex(self.BREAKPOINT_TEXT,
+                                                  lldb.SBFileSpec(os.path.join(cwd, 'main.cpp')))
+        self.assertTrue(bp.IsValid() and bp.GetNumLocations() == 1, VALID_BREAKPOINT)
+
+        while self.dbg.GetListener().WaitForEvent(2, event):
+            if lldb.SBProcess.GetStateFromEvent(event) == lldb.eStateStopped and lldb.SBProcess.GetRestartedFromEvent(event):
+                continue
+            if lldb.SBProcess.GetStateFromEvent(event) == lldb.eStateRunning:
+                continue
+            self.fail("Setting a breakpoint generated an unexpected event: %s" % lldb.SBDebugger.StateAsCString(lldb.SBProcess.GetStateFromEvent(event)))
+
diff --git a/packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_set_restart/main.cpp b/packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_set_restart/main.cpp
new file mode 100644
index 000000000000..e6d3a95d017f
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_set_restart/main.cpp
@@ -0,0 +1,25 @@
+//===-- main.cpp ------------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include <chrono>
+#include <stdio.h>
+#include <thread>
+
+
+int main(int argc, char const *argv[])
+{
+    static bool done = false;
+    while (!done)
+    {
+      std::this_thread::sleep_for(std::chrono::milliseconds{100});
+    }
+    printf("Set a breakpoint here.\n");
+    return 0;
+}
+
diff --git a/packages/Python/lldbsuite/test/functionalities/breakpoint/comp_dir_symlink/TestCompDirSymLink.py b/packages/Python/lldbsuite/test/functionalities/breakpoint/comp_dir_symlink/TestCompDirSymLink.py
index e1de38bcad8c..4933d6d01d44 100644
--- a/packages/Python/lldbsuite/test/functionalities/breakpoint/comp_dir_symlink/TestCompDirSymLink.py
+++ b/packages/Python/lldbsuite/test/functionalities/breakpoint/comp_dir_symlink/TestCompDirSymLink.py
@@ -6,10 +6,11 @@ from __future__ import print_function
 
 
 import os
+import shutil
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
-import shutil
+from lldbsuite.test import lldbutil
 
 
 _EXE_NAME = 'CompDirSymLink'  # Must match Makefile
@@ -27,21 +28,21 @@ class CompDirSymLinkTestCase(TestBase):
         self.line = line_number(_SRC_FILE, '// Set break point at this line.')
         self.src_path = os.path.join(os.getcwd(), _SRC_FILE)
 
-    @skipIfHostWindows
+    @skipIf(hostoslist=["windows"])
     def test_symlink_paths_set(self):
         pwd_symlink = self.create_src_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)
 
-    @skipUnlessHostLinux
+    @skipIf(hostoslist=no_match(["linux"]))
     def test_symlink_paths_set_procselfcwd(self):
         pwd_symlink = '/proc/self/cwd'
         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)
 
-    @skipIfHostWindows
+    @skipIf(hostoslist=["windows"])
     def test_symlink_paths_unset(self):
         pwd_symlink = self.create_src_symlink()
         self.doBuild(pwd_symlink)
diff --git a/packages/Python/lldbsuite/test/functionalities/breakpoint/consecutive_breakpoins/TestConsecutiveBreakpoints.py b/packages/Python/lldbsuite/test/functionalities/breakpoint/consecutive_breakpoins/TestConsecutiveBreakpoints.py
deleted file mode 100644
index af6df3764829..000000000000
--- a/packages/Python/lldbsuite/test/functionalities/breakpoint/consecutive_breakpoins/TestConsecutiveBreakpoints.py
+++ /dev/null
@@ -1,59 +0,0 @@
-"""
-Test continue from a breakpoint when there is a breakpoint on the next instruction also.
-"""
-
-from __future__ import print_function
-
-
-
-import unittest2
-import lldb
-import lldbsuite.test.lldbutil as lldbutil
-from lldbsuite.test.lldbtest import *
-
-class ConsecutiveBreakpoitsTestCase(TestBase):
-
-    mydir = TestBase.compute_mydir(__file__)
-
-    @expectedFailureAll("llvm.org/pr23478", oslist = not_in(["macosx"]))
-    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)
-
-        breakpoint = target.BreakpointCreateBySourceRegex("Set breakpoint here", lldb.SBFileSpec("main.cpp"))
-        self.assertTrue(breakpoint and
-                        breakpoint.GetNumLocations() == 1,
-                        VALID_BREAKPOINT)
-
-        # Now launch the process, and do not stop at entry point.
-        process = target.LaunchSimple (None, None, self.get_process_working_directory())
-        self.assertTrue(process, PROCESS_IS_VALID)
-
-        # We should be stopped at the first breakpoint
-        thread = process.GetThreadAtIndex(0)
-        self.assertEqual(thread.GetStopReason(), lldb.eStopReasonBreakpoint)
-
-        # Set breakpoint to the next instruction
-        frame = thread.GetFrameAtIndex(0)
-        
-        address = frame.GetPCAddress()
-        instructions = target.ReadInstructions(address, 2)
-        self.assertTrue(len(instructions) == 2)
-        address = instructions[1].GetAddress()
-        
-        target.BreakpointCreateByAddress(address.GetLoadAddress(target))
-        process.Continue()
-
-        # We should be stopped at the second breakpoint
-        thread = process.GetThreadAtIndex(0)
-        self.assertEqual(thread.GetStopReason(), lldb.eStopReasonBreakpoint)
-
-        # Run the process until termination
-        process.Continue()
diff --git a/packages/Python/lldbsuite/test/functionalities/breakpoint/consecutive_breakpoins/Makefile b/packages/Python/lldbsuite/test/functionalities/breakpoint/consecutive_breakpoints/Makefile
index f89b52a972e9..f89b52a972e9 100644
--- a/packages/Python/lldbsuite/test/functionalities/breakpoint/consecutive_breakpoins/Makefile
+++ b/packages/Python/lldbsuite/test/functionalities/breakpoint/consecutive_breakpoints/Makefile
diff --git a/packages/Python/lldbsuite/test/functionalities/breakpoint/consecutive_breakpoints/TestConsecutiveBreakpoints.py b/packages/Python/lldbsuite/test/functionalities/breakpoint/consecutive_breakpoints/TestConsecutiveBreakpoints.py
new file mode 100644
index 000000000000..472479391c02
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/breakpoint/consecutive_breakpoints/TestConsecutiveBreakpoints.py
@@ -0,0 +1,101 @@
+"""
+Test that we handle breakpoints on consecutive instructions correctly.
+"""
+
+from __future__ import print_function
+
+
+
+import unittest2
+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+class ConsecutiveBreakpointsTestCase(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    def prepare_test(self):
+        self.build()
+        exe = os.path.join (os.getcwd(), "a.out")
+
+        # Create a target by the debugger.
+        self.target = self.dbg.CreateTarget(exe)
+        self.assertTrue(self.target, VALID_TARGET)
+
+        breakpoint1 = self.target.BreakpointCreateBySourceRegex("Set breakpoint here", lldb.SBFileSpec("main.cpp"))
+        self.assertTrue(breakpoint1 and breakpoint1.GetNumLocations() == 1, VALID_BREAKPOINT)
+
+        # Now launch the process, and do not stop at entry point.
+        self.process = self.target.LaunchSimple (None, None, self.get_process_working_directory())
+        self.assertIsNotNone(self.process, PROCESS_IS_VALID)
+
+        # We should be stopped at the first breakpoint
+        self.thread = lldbutil.get_one_thread_stopped_at_breakpoint(self.process, breakpoint1)
+        self.assertIsNotNone(self.thread, "Expected one thread to be stopped at breakpoint 1")
+
+        # Set breakpoint to the next instruction
+        frame = self.thread.GetFrameAtIndex(0)
+
+        address = frame.GetPCAddress()
+        instructions = self.target.ReadInstructions(address, 2)
+        self.assertTrue(len(instructions) == 2)
+        self.bkpt_address = instructions[1].GetAddress()
+        self.breakpoint2 = self.target.BreakpointCreateByAddress(self.bkpt_address.GetLoadAddress(self.target))
+        self.assertTrue(self.breakpoint2 and self.breakpoint2.GetNumLocations() == 1, VALID_BREAKPOINT)
+
+    def finish_test(self):
+        # Run the process until termination
+        self.process.Continue()
+        self.assertEquals(self.process.GetState(), lldb.eStateExited)
+
+    @no_debug_info_test
+    def test_continue(self):
+        """Test that continue stops at the second breakpoint."""
+        self.prepare_test()
+
+        self.process.Continue()
+        self.assertEquals(self.process.GetState(), lldb.eStateStopped)
+        # We should be stopped at the second breakpoint
+        self.thread = lldbutil.get_one_thread_stopped_at_breakpoint(self.process, self.breakpoint2)
+        self.assertIsNotNone(self.thread, "Expected one thread to be stopped at breakpoint 2")
+
+        self.finish_test()
+
+    @no_debug_info_test
+    def test_single_step(self):
+        """Test that single step stops at the second breakpoint."""
+        self.prepare_test()
+
+        step_over = False
+        self.thread.StepInstruction(step_over)
+
+        self.assertEquals(self.process.GetState(), lldb.eStateStopped)
+        self.assertEquals(self.thread.GetFrameAtIndex(0).GetPCAddress().GetLoadAddress(self.target),
+                self.bkpt_address.GetLoadAddress(self.target))
+        self.thread = lldbutil.get_one_thread_stopped_at_breakpoint(self.process, self.breakpoint2)
+        self.assertIsNotNone(self.thread, "Expected one thread to be stopped at breakpoint 2")
+
+        self.finish_test()
+
+    @no_debug_info_test
+    def test_single_step_thread_specific(self):
+        """Test that single step stops, even though the second breakpoint is not valid."""
+        self.prepare_test()
+
+        # Choose a thread other than the current one. A non-existing thread is fine.
+        thread_index = self.process.GetNumThreads()+1
+        self.assertFalse(self.process.GetThreadAtIndex(thread_index).IsValid())
+        self.breakpoint2.SetThreadIndex(thread_index)
+
+        step_over = False
+        self.thread.StepInstruction(step_over)
+
+        self.assertEquals(self.process.GetState(), lldb.eStateStopped)
+        self.assertEquals(self.thread.GetFrameAtIndex(0).GetPCAddress().GetLoadAddress(self.target),
+                self.bkpt_address.GetLoadAddress(self.target))
+        self.assertEquals(self.thread.GetStopReason(), lldb.eStopReasonPlanComplete,
+                "Stop reason should be 'plan complete'")
+
+        self.finish_test()
diff --git a/packages/Python/lldbsuite/test/functionalities/breakpoint/consecutive_breakpoins/main.cpp b/packages/Python/lldbsuite/test/functionalities/breakpoint/consecutive_breakpoints/main.cpp
index c1943f03dbf1..c1943f03dbf1 100644
--- a/packages/Python/lldbsuite/test/functionalities/breakpoint/consecutive_breakpoins/main.cpp
+++ b/packages/Python/lldbsuite/test/functionalities/breakpoint/consecutive_breakpoints/main.cpp
diff --git a/packages/Python/lldbsuite/test/functionalities/breakpoint/cpp/TestCPPBreakpointLocations.py b/packages/Python/lldbsuite/test/functionalities/breakpoint/cpp/TestCPPBreakpointLocations.py
index dea206b9e9d2..c2aa597214ed 100644
--- a/packages/Python/lldbsuite/test/functionalities/breakpoint/cpp/TestCPPBreakpointLocations.py
+++ b/packages/Python/lldbsuite/test/functionalities/breakpoint/cpp/TestCPPBreakpointLocations.py
@@ -8,14 +8,15 @@ from __future__ import print_function
 
 import os, time
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbutil
 
 class TestCPPBreakpointLocations(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @expectedFailureWindows("llvm.org/pr24764")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24764")
     def test (self):
         self.build ()
         self.breakpoint_id_tests ()
@@ -25,7 +26,7 @@ class TestCPPBreakpointLocations(TestBase):
         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")
+        self.assertEquals(bp.GetNumLocations(), len(names), "Make sure we find the right number of breakpoint locations")
         
         bp_loc_names = list()
         for bp_loc in bp:
@@ -60,3 +61,35 @@ class TestCPPBreakpointLocations(TestBase):
         
         for bp_dict in bp_dicts:
             self.verify_breakpoint_locations(target, bp_dict)
+
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24764")
+    def test_destructors(self):
+        self.build()
+        exe = os.path.join(os.getcwd(), "a.out")
+        target = self.dbg.CreateTarget(exe)
+
+        # Don't skip prologue, so we can check the breakpoint address more easily
+        self.runCmd("settings set target.skip-prologue false")
+        try:
+            names = ['~c', 'c::~c', 'c::~c()']
+            loc_names = {'a::c::~c()', 'b::c::~c()'}
+            # TODO: For windows targets we should put windows mangled names here
+            symbols = ['_ZN1a1cD1Ev', '_ZN1a1cD2Ev', '_ZN1b1cD1Ev', '_ZN1b1cD2Ev']
+
+            for name in names:
+                bp = target.BreakpointCreateByName(name)
+
+                bp_loc_names = { bp_loc.GetAddress().GetFunction().GetName() for bp_loc in bp }
+                self.assertEquals(bp_loc_names, loc_names, "Breakpoint set on the correct symbol")
+
+                bp_addresses = { bp_loc.GetLoadAddress() for bp_loc in bp }
+                symbol_addresses = set()
+                for symbol in symbols:
+                    sc_list = target.FindSymbols(symbol, lldb.eSymbolTypeCode)
+                    self.assertEquals(sc_list.GetSize(), 1, "Found symbol " + symbol)
+                    symbol = sc_list.GetContextAtIndex(0).GetSymbol()
+                    symbol_addresses.add(symbol.GetStartAddress().GetLoadAddress(target))
+
+                self.assertEquals(symbol_addresses, bp_addresses, "Breakpoint set on correct address")
+        finally:
+            self.runCmd("settings clear target.skip-prologue")
diff --git a/packages/Python/lldbsuite/test/functionalities/breakpoint/cpp/main.cpp b/packages/Python/lldbsuite/test/functionalities/breakpoint/cpp/main.cpp
index ef582aa36ebb..01f679139249 100644
--- a/packages/Python/lldbsuite/test/functionalities/breakpoint/cpp/main.cpp
+++ b/packages/Python/lldbsuite/test/functionalities/breakpoint/cpp/main.cpp
@@ -12,8 +12,8 @@
 namespace a {
     class c {
     public:
-        c () {}
-        ~c() {}
+        c();
+        ~c();
         void func1() 
         {
             puts (__PRETTY_FUNCTION__);
@@ -27,13 +27,16 @@ namespace a {
             puts (__PRETTY_FUNCTION__);
         }
     };
+
+    c::c() {}
+    c::~c() {}
 }
 
 namespace b {
     class c {
     public:
-        c () {}
-        ~c() {}
+        c();
+        ~c();
         void func1() 
         {
             puts (__PRETTY_FUNCTION__);
@@ -43,6 +46,9 @@ namespace b {
             puts (__PRETTY_FUNCTION__);
         }
     };
+
+    c::c() {}
+    c::~c() {}
 }
 
 namespace c {
diff --git a/packages/Python/lldbsuite/test/functionalities/breakpoint/cpp_exception/TestCPPExceptionBreakpoint.py b/packages/Python/lldbsuite/test/functionalities/breakpoint/cpp_exception/TestCPPExceptionBreakpoint.py
index f7a19098b492..2aac3a9600d3 100644
--- a/packages/Python/lldbsuite/test/functionalities/breakpoint/cpp_exception/TestCPPExceptionBreakpoint.py
+++ b/packages/Python/lldbsuite/test/functionalities/breakpoint/cpp_exception/TestCPPExceptionBreakpoint.py
@@ -8,10 +8,11 @@ from __future__ import print_function
 
 import os
 import re
-import lldb
-import lldbsuite.test.lldbutil as lldbutil
 import sys
+import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
 
 class TestCPPExceptionBreakpoint (TestBase):
 
@@ -19,7 +20,7 @@ class TestCPPExceptionBreakpoint (TestBase):
     my_var = 10
 
     @add_test_categories(['pyapi'])
-    @expectedFailureWindows("llvm.org/pr24538") # clang-cl does not support throw or catch
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24538")
     def test_cpp_exception_breakpoint(self):
         """Test setting and hitting the C++ exception breakpoint."""
         self.build()
diff --git a/packages/Python/lldbsuite/test/functionalities/breakpoint/debugbreak/TestDebugBreak.py b/packages/Python/lldbsuite/test/functionalities/breakpoint/debugbreak/TestDebugBreak.py
index b32c970301c9..de61f9e88f1b 100644
--- a/packages/Python/lldbsuite/test/functionalities/breakpoint/debugbreak/TestDebugBreak.py
+++ b/packages/Python/lldbsuite/test/functionalities/breakpoint/debugbreak/TestDebugBreak.py
@@ -6,14 +6,15 @@ from __future__ import print_function
 
 import os
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbutil
 
 class DebugBreakTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @skipIf(archs=not_in(["i386", "i686"]))
+    @skipIf(archs=no_match(["i386", "i686", "x86_64"]))
     @no_debug_info_test
     def test_asm_int_3(self):
         """Test that intrinsics like `__debugbreak();` and `asm {"int3"}` are treated like breakpoints."""
@@ -26,13 +27,15 @@ class DebugBreakTestCase(TestBase):
 
         # We've hit the first stop, so grab the frame.
         self.assertEqual(process.GetState(), lldb.eStateStopped)
-        thread = process.GetThreadAtIndex(0)
+        stop_reason = lldb.eStopReasonException if (lldbplatformutil.getPlatform()=="windows" or lldbplatformutil.getPlatform()=="macosx") else lldb.eStopReasonSignal
+        thread = lldbutil.get_stopped_thread(process, stop_reason)
+        self.assertIsNotNone(thread, "Unable to find thread stopped at the __debugbreak()")
         frame = thread.GetFrameAtIndex(0)
 
         # We should be in funciton 'bar'.
         self.assertTrue(frame.IsValid())
         function_name = frame.GetFunctionName()
-        self.assertTrue('bar' in function_name)
+        self.assertTrue('bar' in function_name, "Unexpected function name {}".format(function_name))
 
         # We should be able to evaluate the parameter foo.
         value = frame.EvaluateExpression('*foo')
diff --git a/packages/Python/lldbsuite/test/functionalities/breakpoint/objc/TestObjCBreakpoints.py b/packages/Python/lldbsuite/test/functionalities/breakpoint/objc/TestObjCBreakpoints.py
index 648a0f5ea07c..c48cee1bd2b2 100644
--- a/packages/Python/lldbsuite/test/functionalities/breakpoint/objc/TestObjCBreakpoints.py
+++ b/packages/Python/lldbsuite/test/functionalities/breakpoint/objc/TestObjCBreakpoints.py
@@ -8,11 +8,12 @@ from __future__ import print_function
 
 
 import os, time
-import lldb
-from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
 import shutil
 import subprocess
+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
 
 @skipUnlessDarwin
 class TestObjCBreakpoints(TestBase):
diff --git a/packages/Python/lldbsuite/test/functionalities/breakpoint/source_regexp/Makefile b/packages/Python/lldbsuite/test/functionalities/breakpoint/source_regexp/Makefile
new file mode 100644
index 000000000000..ac984f101c18
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/breakpoint/source_regexp/Makefile
@@ -0,0 +1,5 @@
+LEVEL = ../../../make
+
+C_SOURCES := main.c a.c
+
+include $(LEVEL)/Makefile.rules
diff --git a/packages/Python/lldbsuite/test/functionalities/breakpoint/source_regexp/TestSourceRegexBreakpoints.py b/packages/Python/lldbsuite/test/functionalities/breakpoint/source_regexp/TestSourceRegexBreakpoints.py
new file mode 100644
index 000000000000..81cab927d214
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/breakpoint/source_regexp/TestSourceRegexBreakpoints.py
@@ -0,0 +1,100 @@
+"""
+Test lldb breakpoint setting by source regular expression.
+This test just tests the source file & function restrictions.
+"""
+
+from __future__ import print_function
+
+import os, time
+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+class TestSourceRegexBreakpoints(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    def test_location (self):
+        self.build()
+        self.source_regex_locations()
+
+    def test_restrictions (self):
+        self.build ()
+        self.source_regex_restrictions ()
+
+
+    def source_regex_locations (self):
+        """ Test that restricting source expressions to files & to functions. """
+        # Create a target by the debugger.
+        exe = os.path.join(os.getcwd(), "a.out")
+        target = self.dbg.CreateTarget(exe)
+        self.assertTrue(target, VALID_TARGET)
+
+        # First look just in main:
+        target_files = lldb.SBFileSpecList()
+        target_files.Append(lldb.SBFileSpec("a.c"))
+
+        func_names = lldb.SBStringList()
+        func_names.AppendString("a_func")
+
+        source_regex = "Set . breakpoint here"
+        main_break = target.BreakpointCreateBySourceRegex (source_regex,
+                                                           lldb.SBFileSpecList(),
+                                                           target_files,
+                                                           func_names)
+        num_locations = main_break.GetNumLocations()
+        self.assertTrue(num_locations == 1, "a.c in a_func should give one breakpoint, got %d."%(num_locations))
+
+        loc = main_break.GetLocationAtIndex(0)
+        self.assertTrue(loc.IsValid(), "Got a valid location.")
+        address = loc.GetAddress()
+        self.assertTrue(address.IsValid(), "Got a valid address from the location.")
+        
+        a_func_line = line_number("a.c", "Set A breakpoint here")
+        line_entry = address.GetLineEntry()
+        self.assertTrue(line_entry.IsValid(), "Got a valid line entry.")
+        self.assertTrue(line_entry.line == a_func_line, "Our line number matches the one lldbtest found.")
+
+    def source_regex_restrictions (self):
+        """ Test that restricting source expressions to files & to functions. """
+        # Create a target by the debugger.
+        exe = os.path.join(os.getcwd(), "a.out")
+        target = self.dbg.CreateTarget(exe)
+        self.assertTrue(target, VALID_TARGET)
+
+        # First look just in main:
+        target_files = lldb.SBFileSpecList()
+        target_files.Append(lldb.SBFileSpec("main.c"))
+        source_regex = "Set . breakpoint here"
+        main_break = target.BreakpointCreateBySourceRegex (source_regex,
+                                                           lldb.SBFileSpecList(),
+                                                           target_files,
+                                                           lldb.SBStringList())
+
+        num_locations = main_break.GetNumLocations()
+        self.assertTrue(num_locations == 2, "main.c should have 2 matches, got %d."%(num_locations))
+
+        # Now look in both files:
+        target_files.Append(lldb.SBFileSpec("a.c"))
+
+        main_break = target.BreakpointCreateBySourceRegex (source_regex,
+                                                           lldb.SBFileSpecList(),
+                                                           target_files,
+                                                           lldb.SBStringList())
+
+        num_locations =main_break.GetNumLocations()
+        self.assertTrue(num_locations == 4, "main.c and a.c should have 4 matches, got %d."%(num_locations))
+
+        # Now restrict it to functions:
+        func_names = lldb.SBStringList()
+        func_names.AppendString("main_func")
+        main_break = target.BreakpointCreateBySourceRegex (source_regex,
+                                                           lldb.SBFileSpecList(),
+                                                           target_files,
+                                                           func_names)
+
+        num_locations =main_break.GetNumLocations()
+        self.assertTrue(num_locations == 2, "main_func in main.c and a.c should have 2 matches, got %d."%(num_locations))
+
+
diff --git a/packages/Python/lldbsuite/test/functionalities/breakpoint/source_regexp/a.c b/packages/Python/lldbsuite/test/functionalities/breakpoint/source_regexp/a.c
new file mode 100644
index 000000000000..056583f1c42c
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/breakpoint/source_regexp/a.c
@@ -0,0 +1,16 @@
+#include <stdio.h>
+
+#include "a.h"
+
+static int
+main_func(int input)
+{
+  return printf("Set B breakpoint here: %d", input);
+}
+
+int
+a_func(int input)
+{
+  input += 1; // Set A breakpoint here;
+  return main_func(input);
+}
diff --git a/packages/Python/lldbsuite/test/functionalities/breakpoint/source_regexp/a.h b/packages/Python/lldbsuite/test/functionalities/breakpoint/source_regexp/a.h
new file mode 100644
index 000000000000..f578ac0304cd
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/breakpoint/source_regexp/a.h
@@ -0,0 +1 @@
+int a_func(int);
diff --git a/packages/Python/lldbsuite/test/functionalities/breakpoint/source_regexp/main.c b/packages/Python/lldbsuite/test/functionalities/breakpoint/source_regexp/main.c
new file mode 100644
index 000000000000..9c8625e877f5
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/breakpoint/source_regexp/main.c
@@ -0,0 +1,17 @@
+#include <stdio.h>
+#include "a.h"
+
+int
+main_func(int input)
+{
+  return printf("Set B breakpoint here: %d.\n", input);
+}
+
+int
+main()
+{
+  a_func(10);
+  main_func(10);
+  printf("Set a breakpoint here:\n");
+  return 0;
+}
diff --git a/packages/Python/lldbsuite/test/functionalities/command_history/TestCommandHistory.py b/packages/Python/lldbsuite/test/functionalities/command_history/TestCommandHistory.py
index 312c91517f98..66ba8d07622d 100644
--- a/packages/Python/lldbsuite/test/functionalities/command_history/TestCommandHistory.py
+++ b/packages/Python/lldbsuite/test/functionalities/command_history/TestCommandHistory.py
@@ -8,7 +8,9 @@ from __future__ import print_function
 
 import os
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
 
 class CommandHistoryTestCase(TestBase):
 
diff --git a/packages/Python/lldbsuite/test/functionalities/command_regex/TestCommandRegex.py b/packages/Python/lldbsuite/test/functionalities/command_regex/TestCommandRegex.py
index 2c48efa863b4..5b680ec65de5 100644
--- a/packages/Python/lldbsuite/test/functionalities/command_regex/TestCommandRegex.py
+++ b/packages/Python/lldbsuite/test/functionalities/command_regex/TestCommandRegex.py
@@ -8,13 +8,15 @@ from __future__ import print_function
 
 import os
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
 
 class CommandRegexTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @expectedFailureHostWindows("llvm.org/pr22274: need a pexpect replacement for windows")
+    @expectedFailureAll(hostoslist=["windows"], bugnumber="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."""
diff --git a/packages/Python/lldbsuite/test/functionalities/command_script/TestCommandScript.py b/packages/Python/lldbsuite/test/functionalities/command_script/TestCommandScript.py
index 542ee7a1e5f3..97e52231e818 100644
--- a/packages/Python/lldbsuite/test/functionalities/command_script/TestCommandScript.py
+++ b/packages/Python/lldbsuite/test/functionalities/command_script/TestCommandScript.py
@@ -87,8 +87,8 @@ class CmdPythonTestCase(TestBase):
                        'For more information run'])
 
         self.expect("help targetname",
-                    substrs = ['This', 'command', 'takes', '\'raw\'', 'input',
-                               'quote', 'stuff'])
+                    substrs = ['Expects', '\'raw\'', 'input',
+                               'help', 'raw-input'])
 
         self.expect("longwait",
                     substrs = ['Done; if you saw the delays I am doing OK'])
diff --git a/packages/Python/lldbsuite/test/functionalities/command_script/import/TestImport.py b/packages/Python/lldbsuite/test/functionalities/command_script/import/TestImport.py
index 691045ae82ed..01c3f35bf300 100644
--- a/packages/Python/lldbsuite/test/functionalities/command_script/import/TestImport.py
+++ b/packages/Python/lldbsuite/test/functionalities/command_script/import/TestImport.py
@@ -6,7 +6,9 @@ from __future__ import print_function
 
 import os, sys, time
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
 
 class ImportTestCase(TestBase):
 
diff --git a/packages/Python/lldbsuite/test/functionalities/command_script/import/rdar-12586188/TestRdar12586188.py b/packages/Python/lldbsuite/test/functionalities/command_script/import/rdar-12586188/TestRdar12586188.py
index 9800a08c06de..4f7ebebd4dd2 100644
--- a/packages/Python/lldbsuite/test/functionalities/command_script/import/rdar-12586188/TestRdar12586188.py
+++ b/packages/Python/lldbsuite/test/functionalities/command_script/import/rdar-12586188/TestRdar12586188.py
@@ -6,7 +6,9 @@ from __future__ import print_function
 
 import os, sys, time
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
 
 class Rdar12586188TestCase(TestBase):
 
diff --git a/packages/Python/lldbsuite/test/functionalities/command_script/import/thepackage/__init__.py b/packages/Python/lldbsuite/test/functionalities/command_script/import/thepackage/__init__.py
index faa4e3b0cbff..1181462af868 100644
--- a/packages/Python/lldbsuite/test/functionalities/command_script/import/thepackage/__init__.py
+++ b/packages/Python/lldbsuite/test/functionalities/command_script/import/thepackage/__init__.py
@@ -1,5 +1,7 @@
-import TPunitA
-import TPunitB
+from __future__ import absolute_import
+
+from . import TPunitA
+from . import TPunitB
 
 def __lldb_init_module(debugger,*args):
 	debugger.HandleCommand("command script add -f thepackage.TPunitA.command TPcommandA")
diff --git a/packages/Python/lldbsuite/test/functionalities/command_script_alias/.categories b/packages/Python/lldbsuite/test/functionalities/command_script_alias/.categories
new file mode 100644
index 000000000000..3a3f4df6416b
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/command_script_alias/.categories
@@ -0,0 +1 @@
+cmdline
diff --git a/packages/Python/lldbsuite/test/functionalities/command_script_alias/TestCommandScriptAlias.py b/packages/Python/lldbsuite/test/functionalities/command_script_alias/TestCommandScriptAlias.py
new file mode 100644
index 000000000000..694728a9f9c0
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/command_script_alias/TestCommandScriptAlias.py
@@ -0,0 +1,37 @@
+"""
+Test lldb Python commands.
+"""
+
+from __future__ import print_function
+
+
+import os, time
+import lldb
+from lldbsuite.test.lldbtest import *
+
+class CommandScriptAliasTestCase(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    def test (self):
+        self.pycmd_tests ()
+
+    def pycmd_tests (self):
+        self.runCmd("command script import tcsacmd.py")
+        self.runCmd("command script add -f tcsacmd.some_command_here attach")
+
+        # This is the function to remove the custom commands in order to have a
+        # clean slate for the next test case.
+        def cleanup():
+            self.runCmd('command script delete attach', check=False)
+
+        # Execute the cleanup function during test case tear down.
+        self.addTearDownHook(cleanup)
+
+        # We don't want to display the stdout if not in TraceOn() mode.
+        if not self.TraceOn():
+            self.HideStdout()
+
+        self.expect('attach a', substrs = ['Victory is mine']);
+        self.runCmd("command script delete attach")
+        self.runCmd('attach noprocessexistswiththisname', check=False) # this can't crash but we don't care whether the actual attach works
diff --git a/packages/Python/lldbsuite/test/functionalities/command_script_alias/tcsacmd.py b/packages/Python/lldbsuite/test/functionalities/command_script_alias/tcsacmd.py
new file mode 100644
index 000000000000..6c60e3ca1a55
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/command_script_alias/tcsacmd.py
@@ -0,0 +1,11 @@
+from __future__ import print_function
+import lldb, sys
+
+def some_command_here(debugger, command, result, d):
+  if command == "a":
+    print("Victory is mine", file=result)
+    return True
+  else:
+    print("Sadness for all", file=result)
+    return False
+
diff --git a/packages/Python/lldbsuite/test/functionalities/command_script_immediate_output/TestCommandScriptImmediateOutput.py b/packages/Python/lldbsuite/test/functionalities/command_script_immediate_output/TestCommandScriptImmediateOutput.py
new file mode 100644
index 000000000000..a843d08a97d4
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/command_script_immediate_output/TestCommandScriptImmediateOutput.py
@@ -0,0 +1,86 @@
+"""
+Test that LLDB correctly allows scripted commands to set an immediate output file
+"""
+
+from __future__ import print_function
+
+
+
+import os, time
+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test.lldbpexpect import *
+from lldbsuite.test import lldbutil
+
+class CommandScriptImmediateOutputTestCase (PExpectTest):
+
+    mydir = TestBase.compute_mydir(__file__)
+    NO_DEBUG_INFO_TESTCASE = True
+
+    def setUp(self):
+        # Call super's setUp().
+        PExpectTest.setUp(self)
+
+    @skipIfRemote # test not remote-ready llvm.org/pr24813
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr22274: need a pexpect replacement for windows")
+    @expectedFailureAll(oslist=["freebsd"], bugnumber="llvm.org/pr26139")
+    def test_command_script_immediate_output_console (self):
+        """Test that LLDB correctly allows scripted commands to set immediate output to the console."""
+        self.launch(timeout=10)
+
+        script = os.path.join(os.getcwd(), 'custom_command.py')
+        prompt = "\(lldb\) "
+
+        self.sendline('command script import %s' % script, patterns=[prompt])
+        self.sendline('command script add -f custom_command.command_function mycommand', patterns=[prompt])
+        self.sendline('mycommand', patterns='this is a test string, just a test string')
+        self.sendline('command script delete mycommand', patterns=[prompt])
+        self.quit(gracefully=False)
+
+    @skipIfRemote # test not remote-ready llvm.org/pr24813
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr22274: need a pexpect replacement for windows")
+    @expectedFailureAll(oslist=["freebsd"], bugnumber="llvm.org/pr26139")
+    def test_command_script_immediate_output_file (self):
+        """Test that LLDB correctly allows scripted commands to set immediate output to a file."""
+        self.launch(timeout=10)
+
+        test_files = {os.path.join(os.getcwd(), 'read.txt')        :'r',
+                      os.path.join(os.getcwd(), 'write.txt')       :'w',
+                      os.path.join(os.getcwd(), 'append.txt')      :'a',
+                      os.path.join(os.getcwd(), 'write_plus.txt')  :'w+',
+                      os.path.join(os.getcwd(), 'read_plus.txt')   :'r+',
+                      os.path.join(os.getcwd(), 'append_plus.txt') :'a+'}
+
+        starter_string = 'Starter Garbage\n'
+        write_string   = 'writing to file with mode: '
+
+        for path, mode in test_files.iteritems():
+            with open(path, 'w+') as init:
+                init.write(starter_string)
+
+        script = os.path.join(os.getcwd(), 'custom_command.py')
+        prompt = "\(lldb\) "
+
+        self.sendline('command script import %s' % script, patterns=[prompt])
+
+        self.sendline('command script add -f custom_command.write_file mywrite', patterns=[prompt])
+        for path, mode in test_files.iteritems():
+            command = 'mywrite "' + path + '" ' + mode
+
+            self.sendline(command, patterns=[prompt])
+
+        self.sendline('command script delete mywrite', patterns=[prompt])
+
+        self.quit(gracefully=False)
+
+        for path, mode in test_files.iteritems():
+            with open(path, 'r') as result:
+                if mode in ['r', 'a', 'a+']:
+                    self.assertEquals(result.readline(), starter_string)
+                if mode in ['w', 'w+', 'r+', 'a', 'a+']:
+                    self.assertEquals(result.readline(), write_string + mode + '\n')
+
+            self.assertTrue(os.path.isfile(path))
+            os.remove(path)
+
diff --git a/packages/Python/lldbsuite/test/functionalities/command_script_immediate_output/custom_command.py b/packages/Python/lldbsuite/test/functionalities/command_script_immediate_output/custom_command.py
new file mode 100644
index 000000000000..30a3cfb9093c
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/command_script_immediate_output/custom_command.py
@@ -0,0 +1,17 @@
+from __future__ import print_function
+
+import sys
+import shlex
+
+def command_function(debugger, command, exe_ctx, result, internal_dict):
+        result.SetImmediateOutputFile(sys.__stdout__)
+        print('this is a test string, just a test string', file=result)
+
+def write_file(debugger, command, exe_ctx, result, internal_dict):
+        args = shlex.split(command)
+        path = args[0]
+        mode = args[1]
+        with open(path, mode) as f:
+            result.SetImmediateOutputFile(f)
+            if not mode in ['r']:
+                print('writing to file with mode: ' + mode, file=result)
diff --git a/packages/Python/lldbsuite/test/functionalities/command_source/TestCommandSource.py b/packages/Python/lldbsuite/test/functionalities/command_source/TestCommandSource.py
index 013803e698af..0d4eb0776e79 100644
--- a/packages/Python/lldbsuite/test/functionalities/command_source/TestCommandSource.py
+++ b/packages/Python/lldbsuite/test/functionalities/command_source/TestCommandSource.py
@@ -10,7 +10,9 @@ from __future__ import print_function
 
 import os, sys
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
 
 class CommandSourceTestCase(TestBase):
 
diff --git a/packages/Python/lldbsuite/test/functionalities/completion/TestCompletion.py b/packages/Python/lldbsuite/test/functionalities/completion/TestCompletion.py
index d7aab03c0830..7a9ded03ad20 100644
--- a/packages/Python/lldbsuite/test/functionalities/completion/TestCompletion.py
+++ b/packages/Python/lldbsuite/test/functionalities/completion/TestCompletion.py
@@ -8,7 +8,10 @@ from __future__ import print_function
 
 import os
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbplatform
+from lldbsuite.test import lldbutil
 
 class CommandLineCompletionTestCase(TestBase):
 
@@ -23,21 +26,21 @@ class CommandLineCompletionTestCase(TestBase):
         except:
             pass
 
-    @expectedFailureHostWindows("llvm.org/pr24679")
+    @expectedFailureAll(hostoslist=["windows"], bugnumber="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")
+    @expectedFailureAll(hostoslist=["windows"], bugnumber="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")
+    @expectedFailureAll(hostoslist=["windows"], bugnumber="llvm.org/pr24679")
     @skipIfFreeBSD # timing out on the FreeBSD buildbot
     @no_debug_info_test
     def test_process_attach_dash_dash_con(self):
@@ -45,7 +48,7 @@ class CommandLineCompletionTestCase(TestBase):
         self.complete_from_to('process attach --con', 'process attach --continue ')
 
     # <rdar://problem/11052829>
-    @expectedFailureHostWindows("llvm.org/pr24679")
+    @expectedFailureAll(hostoslist=["windows"], bugnumber="llvm.org/pr24679")
     @skipIfFreeBSD # timing out on the FreeBSD buildbot
     @no_debug_info_test
     def test_infinite_loop_while_completing(self):
@@ -53,147 +56,147 @@ class CommandLineCompletionTestCase(TestBase):
         self.complete_from_to('process print hello\\', 'process print hello\\',
                               turn_off_re_match=True)
 
-    @expectedFailureHostWindows("llvm.org/pr24679")
+    @expectedFailureAll(hostoslist=["windows"], bugnumber="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")
+    @expectedFailureAll(hostoslist=["windows"], bugnumber="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")
+    @expectedFailureAll(hostoslist=["windows"], bugnumber="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")
+    @expectedFailureAll(hostoslist=["windows"], bugnumber="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")
+    @expectedFailureAll(hostoslist=["windows"], bugnumber="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")
+    @expectedFailureAll(hostoslist=["windows"], bugnumber="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")
+    @expectedFailureAll(hostoslist=["windows"], bugnumber="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")
+    @expectedFailureAll(hostoslist=["windows"], bugnumber="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")
+    @expectedFailureAll(hostoslist=["windows"], bugnumber="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")
+    @expectedFailureAll(hostoslist=["windows"], bugnumber="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")
+    @expectedFailureAll(hostoslist=["windows"], bugnumber="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")
+    @expectedFailureAll(hostoslist=["windows"], bugnumber="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")
+    @expectedFailureAll(hostoslist=["windows"], bugnumber="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")
+    @expectedFailureAll(hostoslist=["windows"], bugnumber="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")
+    @expectedFailureAll(hostoslist=["windows"], bugnumber="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")
+    @expectedFailureAll(hostoslist=["windows"], bugnumber="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")
+    @expectedFailureAll(hostoslist=["windows"], bugnumber="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")
+    @expectedFailureAll(hostoslist=["windows"], bugnumber="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")
+    @expectedFailureAll(hostoslist=["windows"], bugnumber="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 target.ma', 'settings set target.max-')
 
-    @expectedFailureHostWindows("llvm.org/pr24679")
+    @expectedFailureAll(hostoslist=["windows"], bugnumber="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")
+    @expectedFailureAll(hostoslist=["windows"], bugnumber="llvm.org/pr24679")
     @skipIfFreeBSD # timing out on the FreeBSD buildbot
     @no_debug_info_test
     def test_settings_set_target_pr(self):
@@ -204,21 +207,21 @@ class CommandLineCompletionTestCase(TestBase):
                                'target.prefer-dynamic-value',
                                'target.process.'])
 
-    @expectedFailureHostWindows("llvm.org/pr24679")
+    @expectedFailureAll(hostoslist=["windows"], bugnumber="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")
+    @expectedFailureAll(hostoslist=["windows"], bugnumber="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")
+    @expectedFailureAll(hostoslist=["windows"], bugnumber="llvm.org/pr24679")
     @skipIfFreeBSD # timing out on the FreeBSD buildbot
     @no_debug_info_test
     def test_settings_set_target_process_thread_dot(self):
@@ -229,7 +232,7 @@ class CommandLineCompletionTestCase(TestBase):
                                'target.process.thread.step-avoid-regexp',
                                'target.process.thread.trace-thread'])
 
-    @expectedFailureHostWindows("llvm.org/pr24679")
+    @expectedFailureAll(hostoslist=["windows"], bugnumber="llvm.org/pr24679")
     @skipIfFreeBSD # timing out on the FreeBSD buildbot
     @no_debug_info_test
     def test_target_space(self):
@@ -239,22 +242,22 @@ class CommandLineCompletionTestCase(TestBase):
                               ['Available completions:', 'create', 'delete', 'list',
                                'modules', 'select', 'stop-hook', 'variable'])
 
-    @expectedFailureHostWindows("llvm.org/pr24679")
+    @expectedFailureAll(hostoslist=["windows"], bugnumber="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")
+    @expectedFailureAll(hostoslist=["windows"], bugnumber="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 ')
 
-    @expectedFailureHostWindows("llvm.org/pr24679")
-    @expectedFailureDarwin("llvm.org/pr25485")
+    @expectedFailureAll(hostoslist=["windows"], bugnumber="llvm.org/pr24679")
+    @expectedFailureAll(oslist=lldbplatform.darwin_all, bugnumber="llvm.org/pr25485")
     def test_symbol_name(self):
         self.build()
         self.complete_from_to('''file a.out
diff --git a/packages/Python/lldbsuite/test/functionalities/conditional_break/TestConditionalBreak.py b/packages/Python/lldbsuite/test/functionalities/conditional_break/TestConditionalBreak.py
index 3ae7a20b4c7d..7fcb44f0b3ec 100644
--- a/packages/Python/lldbsuite/test/functionalities/conditional_break/TestConditionalBreak.py
+++ b/packages/Python/lldbsuite/test/functionalities/conditional_break/TestConditionalBreak.py
@@ -9,8 +9,9 @@ from __future__ import print_function
 import os, time
 import re
 import lldb
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
 
 # rdar://problem/8532131
 # lldb not able to digest the clang-generated debug info correctly with respect to function name
@@ -32,6 +33,7 @@ class ConditionalBreakTestCase(TestBase):
         self.build()
         self.simulate_conditional_break_by_user()
 
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr26265: args in frames other than #0 are not evaluated correctly")
     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")
@@ -64,7 +66,8 @@ class ConditionalBreakTestCase(TestBase):
         for j in range(10):
             if self.TraceOn():
                 print("j is: ", j)
-            thread = process.GetThreadAtIndex(0)
+            thread = lldbutil.get_one_thread_stopped_at_breakpoint(process, breakpoint)
+            self.assertIsNotNone(thread, "Expected one thread to be stopped at the breakpoint")
             
             if thread.GetNumFrames() >= 2:
                 frame0 = thread.GetFrameAtIndex(0)
@@ -82,8 +85,8 @@ class ConditionalBreakTestCase(TestBase):
 
                     # And the local variable 'val' should have a value of (int) 3.
                     val = frame1.FindVariable("val")
-                    self.assertTrue(val.GetTypeName() == "int", "'val' has int type")
-                    self.assertTrue(val.GetValue() == "3", "'val' has a value of 3")
+                    self.assertEqual("int", val.GetTypeName())
+                    self.assertEqual("3", val.GetValue())
                     break
 
             process.Continue()
diff --git a/packages/Python/lldbsuite/test/functionalities/data-formatter/boolreference/TestFormattersBoolRefPtr.py b/packages/Python/lldbsuite/test/functionalities/data-formatter/boolreference/TestFormattersBoolRefPtr.py
index 94cdfdfeb343..fb3511ebd91d 100644
--- a/packages/Python/lldbsuite/test/functionalities/data-formatter/boolreference/TestFormattersBoolRefPtr.py
+++ b/packages/Python/lldbsuite/test/functionalities/data-formatter/boolreference/TestFormattersBoolRefPtr.py
@@ -6,11 +6,12 @@ from __future__ import print_function
 
 
 
+import datetime
 import os, time
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import datetime
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbutil
 
 class DataFormatterBoolRefPtr(TestBase):
 
@@ -56,6 +57,8 @@ class DataFormatterBoolRefPtr(TestBase):
                     substrs = ['YES'])
         self.expect('frame variable no_ref',
                     substrs = ['NO'])
+        self.expect('frame variable unset_ref',
+                    substrs = ['12'])
 
 
         # Now check that we use the right summary for BOOL*
@@ -63,6 +66,8 @@ class DataFormatterBoolRefPtr(TestBase):
                     substrs = ['YES'])
         self.expect('frame variable no_ptr',
                     substrs = ['NO'])
+        self.expect('frame variable unset_ptr',
+                    substrs = ['12'])
 
 
         # Now check that we use the right summary for BOOL
@@ -70,3 +75,5 @@ class DataFormatterBoolRefPtr(TestBase):
                     substrs = ['YES'])
         self.expect('frame variable no',
                     substrs = ['NO'])
+        self.expect('frame variable unset',
+                    substrs = ['12'])
diff --git a/packages/Python/lldbsuite/test/functionalities/data-formatter/boolreference/main.mm b/packages/Python/lldbsuite/test/functionalities/data-formatter/boolreference/main.mm
index a2461fd9da91..22c8790a7541 100644
--- a/packages/Python/lldbsuite/test/functionalities/data-formatter/boolreference/main.mm
+++ b/packages/Python/lldbsuite/test/functionalities/data-formatter/boolreference/main.mm
@@ -11,17 +11,19 @@
 
 int main (int argc, const char * argv[])
 {
-    
     NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
 
 	BOOL yes  = YES;
 	BOOL no = NO;
+    BOOL unset = 12;
 	
 	BOOL &yes_ref = yes;
 	BOOL &no_ref = no;
+	BOOL &unset_ref = unset;
 	
 	BOOL* yes_ptr = &yes;
 	BOOL* no_ptr = &no;
+	BOOL* unset_ptr = &unset;
 
     [pool drain];// Set break point at this line.
     return 0;
diff --git a/packages/Python/lldbsuite/test/functionalities/data-formatter/compactvectors/TestCompactVectors.py b/packages/Python/lldbsuite/test/functionalities/data-formatter/compactvectors/TestCompactVectors.py
index 7cd2a49b4717..914c5260ac24 100644
--- a/packages/Python/lldbsuite/test/functionalities/data-formatter/compactvectors/TestCompactVectors.py
+++ b/packages/Python/lldbsuite/test/functionalities/data-formatter/compactvectors/TestCompactVectors.py
@@ -8,8 +8,9 @@ from __future__ import print_function
 
 import os, time
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbutil
 
 class CompactVectorsFormattingTestCase(TestBase):
 
diff --git a/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-categories/TestDataFormatterCategories.py b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-categories/TestDataFormatterCategories.py
index db426cac6e59..f8209f03d0c2 100644
--- a/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-categories/TestDataFormatterCategories.py
+++ b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-categories/TestDataFormatterCategories.py
@@ -8,8 +8,9 @@ from __future__ import print_function
 
 import os, time
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbutil
 
 class CategoriesDataFormatterTestCase(TestBase):
 
@@ -154,6 +155,7 @@ class CategoriesDataFormatterTestCase(TestBase):
         self.runCmd("type category enable Category1")
         
         self.runCmd("type summary list -w Category1")
+        self.expect("type summary list -w NoSuchCategoryHere", substrs=['no matching results found'])
         
         self.expect("frame variable r1 r2 r3",
                 substrs = ['r1 = Category1',
diff --git a/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-cpp/TestDataFormatterCpp.py b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-cpp/TestDataFormatterCpp.py
index 2ca737156a1a..99443a04f672 100644
--- a/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-cpp/TestDataFormatterCpp.py
+++ b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-cpp/TestDataFormatterCpp.py
@@ -8,8 +8,9 @@ from __future__ import print_function
 
 import os, time
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbutil
 
 class CppDataFormatterTestCase(TestBase):
 
@@ -21,7 +22,7 @@ class CppDataFormatterTestCase(TestBase):
         # Find the line number to break at.
         self.line = line_number('main.cpp', '// Set break point at this line.')
 
-    @expectedFailureWindows("llvm.org/pr24462") # Data formatters have problems on Windows
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24462: Data formatters have problems on Windows")
     def test_with_run_command(self):
         """Test that that file and class static variables display correctly."""
         self.build()
diff --git a/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-disabling/TestDataFormatterDisabling.py b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-disabling/TestDataFormatterDisabling.py
index 0f254a67d5a6..2c2e08431175 100644
--- a/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-disabling/TestDataFormatterDisabling.py
+++ b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-disabling/TestDataFormatterDisabling.py
@@ -8,8 +8,9 @@ from __future__ import print_function
 
 import os, time
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbutil
 
 class DataFormatterDisablingTestCase(TestBase):
 
@@ -21,7 +22,7 @@ class DataFormatterDisablingTestCase(TestBase):
         # Find the line number to break at.
         self.line = line_number('main.cpp', '// Set break point at this line.')
 
-    @expectedFailureWindows("llvm.org/pr24462") # Data formatters have problems on Windows
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24462, Data formatters have problems on Windows")
     def test_with_run_command(self):
         """Check that we can properly disable all data formatter categories."""
         self.build()
@@ -61,6 +62,8 @@ class DataFormatterDisablingTestCase(TestBase):
 
         self.expect('frame variable string1', matching=False, substrs = ['hello world'])
 
+        self.expect('type summary list', substrs=['Category: system (disabled)'])
+
         self.expect('type category list', substrs = ['system','disabled',])
         
         # now enable and check that we are back to normal
diff --git a/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-named-summaries/TestDataFormatterNamedSummaries.py b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-named-summaries/TestDataFormatterNamedSummaries.py
index 94df520d29b3..e9ac79ad08e2 100644
--- a/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-named-summaries/TestDataFormatterNamedSummaries.py
+++ b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-named-summaries/TestDataFormatterNamedSummaries.py
@@ -48,7 +48,9 @@ class NamedSummariesDataFormatterTestCase(TestBase):
         self.runCmd("type summary add --summary-string \"First: x=${var.x} y=${var.y} dummy=${var.dummy}\" First")
         self.runCmd("type summary add --summary-string \"Second: x=${var.x} y=${var.y%hex}\" Second")
         self.runCmd("type summary add --summary-string \"Third: x=${var.x} z=${var.z}\" Third")
-                    
+        
+        self.expect('type summary list', substrs=['AllUseIt'])
+        
         self.expect("frame variable first",
             substrs = ['First: x=12'])
 
diff --git a/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-objc/TestDataFormatterObjC.py b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-objc/TestDataFormatterObjC.py
index e12ddca2eea7..d7d4118d1d6a 100644
--- a/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-objc/TestDataFormatterObjC.py
+++ b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-objc/TestDataFormatterObjC.py
@@ -7,11 +7,12 @@ from __future__ import print_function
 
 
 
+import datetime
 import os, time
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import datetime
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbutil
 
 class ObjCDataFormatterTestCase(TestBase):
 
@@ -66,11 +67,6 @@ class ObjCDataFormatterTestCase(TestBase):
         """Test formatters for NSException."""
         self.appkit_tester_impl(self.nsexception_data_formatter_commands)
 
-    @skipUnlessDarwin
-    def test_nsmisc_with_run_command(self):
-        """Test formatters for misc NS classes."""
-        self.appkit_tester_impl(self.nsmisc_data_formatter_commands)
-
 
     @skipUnlessDarwin
     def test_nsdate_with_run_command(self):
@@ -191,7 +187,7 @@ class ObjCDataFormatterTestCase(TestBase):
     
     def nsnumber_data_formatter_commands(self):
         # Now enable AppKit and check we are displaying Cocoa classes correctly
-        self.expect('frame variable num1 num2 num3 num4 num5 num6 num7 num8_Y num8_N num9',
+        self.expect('frame variable num1 num2 num3 num4 num5 num6 num7 num9',
                     substrs = ['(NSNumber *) num1 = ',' (int)5',
                     '(NSNumber *) num2 = ',' (float)3.1',
                     '(NSNumber *) num3 = ',' (double)3.14',
@@ -199,13 +195,8 @@ class ObjCDataFormatterTestCase(TestBase):
                     '(NSNumber *) num5 = ',' (char)65',
                     '(NSNumber *) num6 = ',' (long)255',
                     '(NSNumber *) num7 = ','2000000',
-                    '(NSNumber *) num8_Y = ',' @"1"',
-                    '(NSNumber *) num8_N = ',' @"0"',
                     '(NSNumber *) num9 = ',' (short)-31616'])
 
-        self.expect('frame variable decimal_one',
-                    substrs = ['(NSDecimalNumber *) decimal_one = 0x','1'])
-
         self.expect('frame variable num_at1 num_at2 num_at3 num_at4',
                     substrs = ['(NSNumber *) num_at1 = ',' (int)12',
                     '(NSNumber *) num_at2 = ',' (int)-12',
@@ -213,26 +204,19 @@ class ObjCDataFormatterTestCase(TestBase):
                     '(NSNumber *) num_at4 = ',' (double)-12.5'])
 
     def nscontainers_data_formatter_commands(self):
-        self.expect('frame variable newArray newDictionary newMutableDictionary cfdict_ref mutable_dict_ref cfarray_ref mutable_array_ref',
+        self.expect('frame variable newArray newDictionary newMutableDictionary cfarray_ref mutable_array_ref',
                     substrs = ['(NSArray *) newArray = ','@"50 elements"',
                     '(NSDictionary *) newDictionary = ',' 12 key/value pairs',
                     '(NSDictionary *) newMutableDictionary = ',' 21 key/value pairs',
-                    '(CFDictionaryRef) cfdict_ref = ','3 key/value pairs',
-                    '(CFMutableDictionaryRef) mutable_dict_ref = ','12 key/value pairs',
                     '(CFArrayRef) cfarray_ref = ','@"3 elements"',
                     '(CFMutableArrayRef) mutable_array_ref = ','@"11 elements"'])
 
-        self.expect('frame variable nscounted_set',
-                    substrs = ['(NSCountedSet *) nscounted_set = ','5 elements'])
-
         self.expect('frame variable iset1 iset2 imset',
                     substrs = ['4 indexes','512 indexes','10 indexes'])
 
-        self.expect('frame variable mutable_bag_ref cfbag_ref binheap_ref',
-                    substrs = ['(CFMutableBagRef) mutable_bag_ref = ','@"17 values"',
-                    '(CFBagRef) cfbag_ref = ','@"15 values"',
-                    '(CFBinaryHeapRef) binheap_ref = ','@"21 items"'])
-                    
+        self.expect('frame variable binheap_ref',
+                    substrs = ['(CFBinaryHeapRef) binheap_ref = ','@"21 items"'])
+
         self.expect('expression -d run -- [NSArray new]', substrs=['@"0 elements"'])
 
     def nsdata_data_formatter_commands(self):
@@ -258,6 +242,9 @@ class ObjCDataFormatterTestCase(TestBase):
         self.expect('frame variable nserror',
                     substrs = ['domain: @"Foobar" - code: 12'])
 
+        self.expect('frame variable nserrorptr',
+                    substrs = ['domain: @"Foobar" - code: 12'])
+
         self.expect('frame variable nserror->_userInfo',
                     substrs = ['2 key/value pairs'])
 
@@ -272,24 +259,10 @@ class ObjCDataFormatterTestCase(TestBase):
 
     def nsexception_data_formatter_commands(self):
         self.expect('frame variable except0 except1 except2 except3',
-                    substrs = ['(NSException *) except0 = ','name:@"TheGuyWhoHasNoName" reason:@"cuz it\'s funny"',
-                    '(NSException *) except1 = ','name:@"TheGuyWhoHasNoName~1" reason:@"cuz it\'s funny"',
-                    '(NSException *) except2 = ','name:@"TheGuyWhoHasNoName`2" reason:@"cuz it\'s funny"',
-                    '(NSException *) except3 = ','name:@"TheGuyWhoHasNoName/3" reason:@"cuz it\'s funny"'])
-
-    def nsmisc_data_formatter_commands(self):
-        self.expect('frame variable localhost',
-                    substrs = ['<NSHost ','> localhost ((','"127.0.0.1"'])
-
-        if self.getArchitecture() in ['i386', 'x86_64']:
-            self.expect('frame variable my_task',
-                        substrs = ['<NS','Task: 0x'])
-
-        self.expect('frame variable range_value',
-                    substrs = ['NSRange: {4, 4}'])
-
-        self.expect('frame variable port',
-                    substrs = ['(NSMachPort *) port = ',' mach port: '])
+                    substrs = ['(NSException *) except0 = ','name: @"TheGuyWhoHasNoName" - reason: @"cuz it\'s funny"',
+                    '(NSException *) except1 = ','name: @"TheGuyWhoHasNoName~1" - reason: @"cuz it\'s funny"',
+                    '(NSException *) except2 = ','name: @"TheGuyWhoHasNoName`2" - reason: @"cuz it\'s funny"',
+                    '(NSException *) except3 = ','name: @"TheGuyWhoHasNoName/3" - reason: @"cuz it\'s funny"'])
 
     def nsdate_data_formatter_commands(self):
         self.expect('frame variable date1 date2',
@@ -298,16 +271,18 @@ class ObjCDataFormatterTestCase(TestBase):
         # this test might fail if we hit the breakpoint late on December 31st of some given year
         # and midnight comes between hitting the breakpoint and running this line of code
         # hopefully the output will be revealing enough in that case :-)
-        now_year = str(datetime.datetime.now().year)
+        now_year = '%s-' % str(datetime.datetime.now().year)
 
-        self.expect('frame variable date3 date4',
-                    substrs = [now_year,'1970'])
+        self.expect('frame variable date3', substrs = [now_year])
+        self.expect('frame variable date4', substrs = ['1970'])
+        self.expect('frame variable date5', substrs = [now_year])
 
         self.expect('frame variable date1_abs date2_abs',
                     substrs = ['1985-04','2011-01'])
 
-        self.expect('frame variable date3_abs date4_abs',
-                    substrs = [now_year,'1970'])
+        self.expect('frame variable date3_abs', substrs = [now_year])
+        self.expect('frame variable date4_abs', substrs = ['1970'])
+        self.expect('frame variable date5_abs', substrs = [now_year])
 
         self.expect('frame variable cupertino home europe',
                     substrs = ['@"America/Los_Angeles"',
@@ -385,7 +360,6 @@ class ObjCDataFormatterTestCase(TestBase):
             self.runCmd('type format clear', check=False)
             self.runCmd('type summary clear', check=False)
             self.runCmd('type synth clear', check=False)
-            self.runCmd('log timers disable', check=False)
 
 
         # Execute the cleanup function during test case tear down.
@@ -406,7 +380,6 @@ class ObjCDataFormatterTestCase(TestBase):
          '(Rect *) rect_ptr = (t=4, l=8, b=4, r=7)',
          '(Point) point = (v=7, h=12)',
          '(Point *) point_ptr = (v=7, h=12)',
-         'name:@"TheGuyWhoHasNoName" reason:@"cuz it\'s funny"',
          '1985',
          'foo_selector_impl'];
          
diff --git a/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-objc/main.m b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-objc/main.m
index 6eb7e021f70b..020e2fc6227a 100644
--- a/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-objc/main.m
+++ b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-objc/main.m
@@ -415,41 +415,6 @@ int main (int argc, const char * argv[])
 
 	    CFStringRef cfstring_ref = CFSTR("HELLO WORLD");
 
-
-	    CFSetRef set_ref = CFSetCreate(NULL, data_set, 3, NULL);
-
-	    CFMutableSetRef mutable_set_ref = CFSetCreateMutable(NULL, 5, NULL);
-
-	    CFSetAddValue(mutable_set_ref, str1);
-	    CFSetAddValue(mutable_set_ref, str2);
-	    CFSetAddValue(mutable_set_ref, str3);
-	    CFSetAddValue(mutable_set_ref, str4);
-	    CFSetAddValue(mutable_set_ref, str5);
-	    CFSetAddValue(mutable_set_ref, str6);
-	    CFSetAddValue(mutable_set_ref, str7);
-	    CFSetAddValue(mutable_set_ref, str8);
-	    CFSetAddValue(mutable_set_ref, str9);
-	    CFSetAddValue(mutable_set_ref, str10);
-	    CFSetAddValue(mutable_set_ref, str11);
-	    CFSetAddValue(mutable_set_ref, str12);
-
-
-	    CFDictionaryRef cfdict_ref = CFDictionaryCreate(NULL, data_set, data_set, 3, NULL, NULL);
-	    CFMutableDictionaryRef mutable_dict_ref = CFDictionaryCreateMutable(NULL, 16, NULL, NULL);
-
-	    CFDictionarySetValue(mutable_dict_ref, str1, str1);
-	    CFDictionarySetValue(mutable_dict_ref, str2, str2);
-	    CFDictionarySetValue(mutable_dict_ref, str3, str3);
-	    CFDictionarySetValue(mutable_dict_ref, str4, str1);
-	    CFDictionarySetValue(mutable_dict_ref, str5, str2);
-	    CFDictionarySetValue(mutable_dict_ref, str6, str3);
-	    CFDictionarySetValue(mutable_dict_ref, str7, str1);
-	    CFDictionarySetValue(mutable_dict_ref, str8, str2);
-	    CFDictionarySetValue(mutable_dict_ref, str9, str3);
-	    CFDictionarySetValue(mutable_dict_ref, str10, str1);
-	    CFDictionarySetValue(mutable_dict_ref, str11, str2);
-	    CFDictionarySetValue(mutable_dict_ref, str12, str3);
-
 	    CFArrayRef cfarray_ref = CFArrayCreate(NULL, data_set, 3, NULL);
 	    CFMutableArrayRef mutable_array_ref = CFArrayCreateMutable(NULL, 16, NULL);
 
@@ -466,31 +431,6 @@ int main (int argc, const char * argv[])
 	    CFArraySetValueAtIndex(mutable_array_ref, 9, str11);
 	    CFArraySetValueAtIndex(mutable_array_ref, 10, str12);
 
-	    CFMutableBagRef mutable_bag_ref = CFBagCreateMutable(NULL, 15, NULL);
-
-	    CFBagSetValue(mutable_bag_ref, strB10);
-	    CFBagSetValue(mutable_bag_ref, str1);
-	    CFBagSetValue(mutable_bag_ref, str2);
-	    CFBagSetValue(mutable_bag_ref, str3);
-	    CFBagSetValue(mutable_bag_ref, str4);
-	    CFBagSetValue(mutable_bag_ref, str5);
-	    CFBagSetValue(mutable_bag_ref, str6);
-	    CFBagSetValue(mutable_bag_ref, str7);
-	    CFBagSetValue(mutable_bag_ref, str8);
-	    CFBagSetValue(mutable_bag_ref, str9);
-	    CFBagSetValue(mutable_bag_ref, str10);
-	    CFBagSetValue(mutable_bag_ref, str11);
-	    CFBagSetValue(mutable_bag_ref, str12);
-	    CFBagSetValue(mutable_bag_ref, strA1);
-	    CFBagSetValue(mutable_bag_ref, strA2);
-	    CFBagSetValue(mutable_bag_ref, strA3);
-
-	    CFBagRef cfbag_ref = CFBagCreateCopy(NULL, mutable_bag_ref);
-
-	    CFBagSetValue(mutable_bag_ref, strB8);
-	    CFBagSetValue(mutable_bag_ref, strC4);
-
-
 	    CFBinaryHeapRef binheap_ref = CFBinaryHeapCreate(NULL, 15, &kCFStringBinaryHeapCallBacks, NULL);
 	    CFBinaryHeapAddValue(binheap_ref, str1);
 	    CFBinaryHeapAddValue(binheap_ref, str2);
@@ -520,6 +460,7 @@ int main (int argc, const char * argv[])
 
 	    NSDictionary *error_userInfo = @{@"a": @1, @"b" : @2};
 	    NSError *nserror = [[NSError alloc] initWithDomain:@"Foobar" code:12 userInfo:error_userInfo];
+	    NSError **nserrorptr = &nserror;
 
 	    NSBundle* bundle_string = [[NSBundle alloc] initWithPath:@"/System/Library/Frameworks/Accelerate.framework"];
 	    NSBundle* bundle_url = [[NSBundle alloc] initWithURL:[[NSURL alloc] initWithString:@"file://localhost/System/Library/Frameworks/Cocoa.framework"]];
@@ -540,8 +481,6 @@ int main (int argc, const char * argv[])
 	    NSException* except2 = [[NSException alloc] initWithName:@"TheGuyWhoHasNoName`2" reason:@"cuz it's funny" userInfo:nil];
 	    NSException* except3 = [[NSException alloc] initWithName:@"TheGuyWhoHasNoName/3" reason:@"cuz it's funny" userInfo:nil];
 
-	    NSMachPort *port = [NSMachPort port];
-
 	    NSURL *nsurl = [[NSURL alloc] initWithString:@"http://www.foo.bar"];
 	    NSURL *nsurl2 = [NSURL URLWithString:@"page.html" relativeToURL:nsurl];
 	    NSURL *nsurl3 = [NSURL URLWithString:@"?whatever" relativeToURL:nsurl2];
@@ -550,22 +489,14 @@ int main (int argc, const char * argv[])
 		NSDate *date2 = [NSDate dateWithNaturalLanguageString:@"12am January 1, 2011"];
 		NSDate *date3 = [NSDate date];
 		NSDate *date4 = [NSDate dateWithTimeIntervalSince1970:24*60*60];
+    NSDate *date5 = [NSDate dateWithTimeIntervalSinceReferenceDate: floor([[NSDate date] timeIntervalSinceReferenceDate])];
 
 		CFAbsoluteTime date1_abs = CFDateGetAbsoluteTime(date1);
 		CFAbsoluteTime date2_abs = CFDateGetAbsoluteTime(date2);
 		CFAbsoluteTime date3_abs = CFDateGetAbsoluteTime(date3);
 		CFAbsoluteTime date4_abs = CFDateGetAbsoluteTime(date4);
+		CFAbsoluteTime date5_abs = CFDateGetAbsoluteTime(date5);
 
-	    NSCountedSet *nscounted_set = [[NSCountedSet alloc] initWithCapacity:5];
-
-	    [nscounted_set addObject:str0];
-	    [nscounted_set addObject:str1];
-	    [nscounted_set addObject:str0];
-	    [nscounted_set addObject:str0];
-	    [nscounted_set addObject:@"foo1"];
-	    [nscounted_set addObject:@"foo2"];
-	    [nscounted_set addObject:@"foo3"];
-	
 	    NSIndexSet *iset1 = [[NSIndexSet alloc] initWithIndexesInRange:NSMakeRange(1, 4)];
 	    NSIndexSet *iset2 = [[NSIndexSet alloc] initWithIndexesInRange:NSMakeRange(1, 512)];
 
@@ -598,21 +529,12 @@ int main (int argc, const char * argv[])
 		NSTimeZone *home_ns = [NSTimeZone timeZoneWithName:@"Europe/Rome"];
 		NSTimeZone *europe_ns = [NSTimeZone timeZoneWithAbbreviation:@"CET"];
 
-		NSHost *localhost = [NSHost hostWithAddress:@"127.0.0.1"];
-
-#ifndef IOS
-		NSTask *my_task = [[NSTask alloc] init];
-#endif
-
-
 	CFGregorianUnits cf_greg_units = {1,3,5,12,5,7};
 	CFGregorianDate cf_greg_date = CFAbsoluteTimeGetGregorianDate(CFDateGetAbsoluteTime(date1), NULL);
 	CFRange cf_range = {4,4};
 	NSPoint ns_point = {4,4};
 	NSRange ns_range = {4,4};
-	
-	NSValue *range_value = [NSValue valueWithRange:ns_range];
-	
+		
 	NSRect ns_rect = {{1,1},{5,5}};
 	NSRect* ns_rect_ptr = &ns_rect;
 	NSRectArray ns_rect_arr = &ns_rect;
diff --git a/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-objc/nsstring/TestDataFormatterNSString.py b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-objc/nsstring/TestDataFormatterNSString.py
index e11c45e9038e..f5c792593772 100644
--- a/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-objc/nsstring/TestDataFormatterNSString.py
+++ b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-objc/nsstring/TestDataFormatterNSString.py
@@ -8,10 +8,11 @@ from __future__ import print_function
 
 
 import os, time
+import datetime
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import datetime
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbutil
 
 class NSStringDataFormatterTestCase(TestBase):
 
diff --git a/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-proper-plurals/TestFormattersOneIsSingular.py b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-proper-plurals/TestFormattersOneIsSingular.py
index 1281f17ab58a..3c9be04a2f6c 100644
--- a/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-proper-plurals/TestFormattersOneIsSingular.py
+++ b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-proper-plurals/TestFormattersOneIsSingular.py
@@ -6,11 +6,12 @@ from __future__ import print_function
 
 
 
+import datetime
 import os, time
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import datetime
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbutil
 
 class DataFormatterOneIsSingularTestCase(TestBase):
 
@@ -64,14 +65,6 @@ class DataFormatterOneIsSingularTestCase(TestBase):
                     substrs = ['1 key/value pair'])
         self.expect('frame variable dict', matching=False,
                     substrs = ['1 key/value pairs'])
-        self.expect('frame variable mutable_bag_ref',
-                    substrs = ['@"1 value"'])
-        self.expect('frame variable mutable_bag_ref', matching=False,
-                    substrs = ['1 values'])
-        self.expect('frame variable nscounted_set',
-                    substrs = ['1 element'])
-        self.expect('frame variable nscounted_set', matching=False,
-                    substrs = ['1 elements'])
         self.expect('frame variable imset',
                     substrs = ['1 index'])
         self.expect('frame variable imset', matching=False,
@@ -80,10 +73,6 @@ class DataFormatterOneIsSingularTestCase(TestBase):
                     substrs = ['@"1 item"'])
         self.expect('frame variable binheap_ref', matching=False,
                     substrs = ['1 items'])
-        self.expect('frame variable nsset',
-                    substrs = ['1 element'])
-        self.expect('frame variable nsset', matching=False,
-                    substrs = ['1 elements'])
         self.expect('frame variable immutableData',
                     substrs = ['1 byte'])
         self.expect('frame variable immutableData', matching=False,
diff --git a/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-proper-plurals/main.m b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-proper-plurals/main.m
index 7204d3c7b202..71ab8a746bb6 100644
--- a/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-proper-plurals/main.m
+++ b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-proper-plurals/main.m
@@ -11,32 +11,21 @@
 
 int main (int argc, const char * argv[])
 {
-    
-    NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
-    
+  NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
 
 	NSArray* key = [NSArray arrayWithObjects:@"foo",nil];
 	NSArray* value = [NSArray arrayWithObjects:@"key",nil];
 	NSDictionary *dict = [NSDictionary dictionaryWithObjects:value forKeys:key];
 
-    CFMutableBagRef mutable_bag_ref = CFBagCreateMutable(NULL, 15, NULL);
-    CFBagSetValue(mutable_bag_ref, CFSTR("Hello world"));
+  NSMutableIndexSet *imset = [[NSMutableIndexSet alloc] init];
+  [imset addIndex:4];
 
-    NSCountedSet *nscounted_set = [[NSCountedSet alloc] initWithCapacity:5];
-    [nscounted_set addObject:@"foo"];
+  CFBinaryHeapRef binheap_ref = CFBinaryHeapCreate(NULL, 15, &kCFStringBinaryHeapCallBacks, NULL);
+  CFBinaryHeapAddValue(binheap_ref, CFSTR("Hello world"));
 
-    NSMutableIndexSet *imset = [[NSMutableIndexSet alloc] init];
-    [imset addIndex:4];
+  NSData *immutableData = [[NSData alloc] initWithBytes:"HELLO" length:1];
 
-    CFBinaryHeapRef binheap_ref = CFBinaryHeapCreate(NULL, 15, &kCFStringBinaryHeapCallBacks, NULL);
-    CFBinaryHeapAddValue(binheap_ref, CFSTR("Hello world"));
-
-    NSSet* nsset = [[NSSet alloc] initWithObjects:@"foo",nil];
-
-    NSData *immutableData = [[NSData alloc] initWithBytes:"HELLO" length:1];
-
-
-    [pool drain];// Set break point at this line.
-    return 0;
+  [pool drain];// Set break point at this line.
+  return 0;
 }
 
diff --git a/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-python-synth/TestDataFormatterPythonSynth.py b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-python-synth/TestDataFormatterPythonSynth.py
index d202ff5d64e1..c7ff28874c5a 100644
--- a/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-python-synth/TestDataFormatterPythonSynth.py
+++ b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-python-synth/TestDataFormatterPythonSynth.py
@@ -8,8 +8,9 @@ from __future__ import print_function
 
 import os, time
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbutil
 
 class PythonSynthDataFormatterTestCase(TestBase):
 
@@ -43,6 +44,8 @@ class PythonSynthDataFormatterTestCase(TestBase):
 
         self.runCmd("run", RUN_SUCCEEDED)
 
+        process = self.dbg.GetSelectedTarget().GetProcess()
+
         # The stop reason of the thread should be breakpoint.
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
             substrs = ['stopped',
@@ -61,39 +64,46 @@ class PythonSynthDataFormatterTestCase(TestBase):
 
         # print the f00_1 variable without a synth
         self.expect("frame variable f00_1",
-            substrs = ['a = 0',
-                       'b = 1',
-                       'r = 33']);
+            substrs = ['a = 1',
+                       'b = 2',
+                       'r = 34']);
 
         # now set up the synth
         self.runCmd("script from fooSynthProvider import *")
         self.runCmd("type synth add -l fooSynthProvider foo")
+        self.expect("type synthetic list foo", substrs=['fooSynthProvider'])
+
+        # note that the value of fake_a depends on target byte order
+        if process.GetByteOrder() == lldb.eByteOrderLittle:
+            fake_a_val = 0x02000000
+        else:
+            fake_a_val = 0x00000100
 
         # check that we get the two real vars and the fake_a variables
         self.expect("frame variable f00_1",
-                    substrs = ['r = 33',
-                               'fake_a = 16777216',
-                               'a = 0']);
+                    substrs = ['r = 34',
+                               'fake_a = %d' % fake_a_val,
+                               'a = 1']);
 
         # check that we do not get the extra vars
         self.expect("frame variable f00_1", matching=False,
-                    substrs = ['b = 1']);
+                    substrs = ['b = 2']);
         
         # check access to members by name
         self.expect('frame variable f00_1.fake_a',
-                substrs = ['16777216'])
+                    substrs = ['%d' % fake_a_val])
         
         # check access to members by index
         self.expect('frame variable f00_1[1]',
-                    substrs = ['16777216'])
+                    substrs = ['%d' % fake_a_val])
         
         # put synthetic children in summary in several combinations
         self.runCmd("type summary add --summary-string \"fake_a=${svar.fake_a}\" foo")
         self.expect('frame variable f00_1',
-                    substrs = ['fake_a=16777216'])
+                    substrs = ['fake_a=%d' % fake_a_val])
         self.runCmd("type summary add --summary-string \"fake_a=${svar[1]}\" foo")
         self.expect('frame variable f00_1',
-            substrs = ['fake_a=16777216'])
+                    substrs = ['fake_a=%d' % fake_a_val])
         
         # clear the summary
         self.runCmd("type summary delete foo")
@@ -101,23 +111,39 @@ class PythonSynthDataFormatterTestCase(TestBase):
         # check that the caching does not span beyond the stopoint
         self.runCmd("n")
 
+        if process.GetByteOrder() == lldb.eByteOrderLittle:
+            fake_a_val = 0x02000000
+        else:
+            fake_a_val = 0x00000200
+
         self.expect("frame variable f00_1",
-                    substrs = ['r = 33',
-                               'fake_a = 16777216',
-                               'a = 1']);
+                    substrs = ['r = 34',
+                               'fake_a = %d' % fake_a_val,
+                               'a = 2']);
 
         # check that altering the object also alters fake_a
         self.runCmd("expr f00_1.a = 280")
+
+        if process.GetByteOrder() == lldb.eByteOrderLittle:
+            fake_a_val = 0x02000001
+        else:
+            fake_a_val = 0x00011800
+
         self.expect("frame variable f00_1",
-                    substrs = ['r = 33',
-                               'fake_a = 16777217',
+                    substrs = ['r = 34',
+                               'fake_a = %d' % fake_a_val,
                                'a = 280']);
 
         # check that expanding a pointer does the right thing
+        if process.GetByteOrder() == lldb.eByteOrderLittle:
+            fake_a_val = 0x0d000000
+        else:
+            fake_a_val = 0x00000c00
+
         self.expect("frame variable --ptr-depth 1 f00_ptr",
-            substrs = ['r = 45',
-                       'fake_a = 218103808',
-                       'a = 12'])
+                    substrs = ['r = 45',
+                               'fake_a = %d' % fake_a_val,
+                               'a = 12'])
         
         # now add a filter.. it should fail
         self.expect("type filter add foo --child b --child j", error=True,
@@ -129,7 +155,7 @@ class PythonSynthDataFormatterTestCase(TestBase):
                        'j = 17'])
         self.expect("frame variable --ptr-depth 1 f00_ptr",
                     substrs = ['r = 45',
-                               'fake_a = 218103808',
+                               'fake_a = %d' % fake_a_val,
                                'a = 12'])
         
         # now delete the synth and add the filter
@@ -137,11 +163,11 @@ class PythonSynthDataFormatterTestCase(TestBase):
         self.runCmd("type filter add foo --child b --child j")
         
         self.expect('frame variable f00_1',
-                        substrs = ['b = 1',
-                                   'j = 17'])
+                        substrs = ['b = 2',
+                                   'j = 18'])
         self.expect("frame variable --ptr-depth 1 f00_ptr", matching=False,
                     substrs = ['r = 45',
-                               'fake_a = 218103808',
+                               'fake_a = %d' % fake_a_val,
                                'a = 12'])
         
         # now add the synth and it should fail
@@ -162,11 +188,11 @@ class PythonSynthDataFormatterTestCase(TestBase):
         self.runCmd("type synth add -l fooSynthProvider foo")
         
         self.expect('frame variable f00_1', matching=False,
-                    substrs = ['b = 1',
-                               'j = 17'])
+                    substrs = ['b = 2',
+                               'j = 18'])
         self.expect("frame variable --ptr-depth 1 f00_ptr", 
                     substrs = ['r = 45',
-                               'fake_a = 218103808',
+                               'fake_a = %d' % fake_a_val,
                                'a = 12'])
 
         # check the listing
@@ -183,8 +209,8 @@ class PythonSynthDataFormatterTestCase(TestBase):
         
         self.expect("frame variable f00_1",
                     substrs = ['a = 280',
-                               'b = 1',
-                               'j = 17']);
+                               'b = 2',
+                               'j = 18']);
 
         self.expect("frame variable f00_1", matching=False,
                 substrs = ['fake_a = '])
diff --git a/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-python-synth/main.cpp b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-python-synth/main.cpp
index 48b29dcfd6e4..f45a2abfb9f1 100644
--- a/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-python-synth/main.cpp
+++ b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-python-synth/main.cpp
@@ -48,7 +48,7 @@ struct wrapint
 
 int main()
 {
-    foo f00_1(0);
+    foo f00_1(1);
     foo *f00_ptr = new foo(12);
     
     f00_1.a++; // Set break point at this line.
diff --git a/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-script/TestDataFormatterScript.py b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-script/TestDataFormatterScript.py
index 324b372cb11e..7ebc1c14ce13 100644
--- a/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-script/TestDataFormatterScript.py
+++ b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-script/TestDataFormatterScript.py
@@ -52,6 +52,7 @@ class ScriptDataFormatterTestCase(TestBase):
         script = 'a = valobj.GetChildMemberWithName(\'integer\'); a_val = a.GetValue(); str = \'Hello from Python, \' + a_val + \' time\'; return str + (\'!\' if a_val == \'1\' else \'s!\');'
 
         self.runCmd("type summary add i_am_cool --python-script \"%s\"" % script)
+        self.expect('type summary list i_am_cool', substrs=[script])
 
         self.expect("frame variable one",
             substrs = ['Hello from Python',
diff --git a/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-skip-summary/Makefile b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-skip-summary/Makefile
index b438bbb970f6..a92cffcc319b 100644
--- a/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-skip-summary/Makefile
+++ b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-skip-summary/Makefile
@@ -1,6 +1,7 @@
 LEVEL = ../../../make
 
 CXX_SOURCES := main.cpp
+USE_LIBSTDCPP := 1
 
 # clang-3.5+ outputs FullDebugInfo by default for Darwin/FreeBSD 
 # targets.  Other targets do not, which causes this test to fail.
@@ -12,8 +13,3 @@ endif
 include $(LEVEL)/Makefile.rules
 
 CXXFLAGS += -O0
-
-ifeq (,$(findstring gcc,$(CC)))
-CXXFLAGS += -stdlib=libstdc++
-LDFLAGS += -stdlib=libstdc++
-endif
diff --git a/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-skip-summary/TestDataFormatterSkipSummary.py b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-skip-summary/TestDataFormatterSkipSummary.py
index 38e700812d05..c186f1465cf5 100644
--- a/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-skip-summary/TestDataFormatterSkipSummary.py
+++ b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-skip-summary/TestDataFormatterSkipSummary.py
@@ -8,15 +8,16 @@ from __future__ import print_function
 
 import os, time
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbutil
 
 class SkipSummaryDataFormatterTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @expectedFailureFreeBSD("llvm.org/pr20548") # fails to build on lab.llvm.org buildbot
-    @expectedFailureWindows("llvm.org/pr24462") # Data formatters have problems on Windows
+    @expectedFailureAll(oslist=['freebsd'], bugnumber="llvm.org/pr20548 fails to build on lab.llvm.org buildbot")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24462, Data formatters have problems on Windows")
     def test_with_run_command(self):
         """Test data formatter commands."""
         self.build()
diff --git a/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-smart-array/TestDataFormatterSmartArray.py b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-smart-array/TestDataFormatterSmartArray.py
index ca8858dbad9b..b3f8ba7d048e 100644
--- a/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-smart-array/TestDataFormatterSmartArray.py
+++ b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-smart-array/TestDataFormatterSmartArray.py
@@ -8,14 +8,15 @@ from __future__ import print_function
 
 import os, time
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbutil
 
 class SmartArrayDataFormatterTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @expectedFailureWindows("llvm.org/pr24462") # Data formatters have problems on Windows
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24462, Data formatters have problems on Windows")
     def test_with_run_command(self):
         """Test data formatter commands."""
         self.build()
@@ -35,6 +36,8 @@ class SmartArrayDataFormatterTestCase(TestBase):
 
         self.runCmd("run", RUN_SUCCEEDED)
 
+        process = self.dbg.GetSelectedTarget().GetProcess()
+
         # The stop reason of the thread should be breakpoint.
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
             substrs = ['stopped',
@@ -310,39 +313,81 @@ class SmartArrayDataFormatterTestCase(TestBase):
         self.runCmd("type summary add --summary-string \"arr = ${var%y}\" \"float [7]\"")
         self.runCmd("type summary add --summary-string \"arr = ${var%y}\" \"int [5]\"")
 
-        self.expect("frame variable flarr",
-                    substrs = ['flarr = arr =',
-                               '00 00 9d 42,00 80 9a 42,00 00 9c 42,00 40 98 42,00 80 99 42,00 c0 99 42,00 00 9a 42'])
-        
-        self.expect("frame variable other.flarr",
-                    substrs = ['flarr = arr =',
-                               '00 00 cc 41,00 00 ca 41,00 00 c9 41,00 00 d6 41,00 00 db 41,00 00 dc 41,00 00 d1 41'])
-
-        self.expect("frame variable intarr",
-                    substrs = ['intarr = arr =',
-                               '01 00 00 00,01 00 00 00,02 00 00 00,03 00 00 00,05 00 00 00'])
-        
-        self.expect("frame variable other.intarr",
-                    substrs = ['intarr = arr = ',
-                               '09 00 00 00,08 00 00 00,07 00 00 00,06 00 00 00,05 00 00 00'])
+        if process.GetByteOrder() == lldb.eByteOrderLittle:
+            self.expect("frame variable flarr",
+                        substrs = ['flarr = arr =',
+                                   '00 00 9d 42,00 80 9a 42,00 00 9c 42,00 40 98 42,00 80 99 42,00 c0 99 42,00 00 9a 42'])
+        else:
+            self.expect("frame variable flarr",
+                        substrs = ['flarr = arr =',
+                                   '42 9d 00 00,42 9a 80 00,42 9c 00 00,42 98 40 00,42 99 80 00,42 99 c0 00,42 9a 00 00'])
+
+        if process.GetByteOrder() == lldb.eByteOrderLittle:
+            self.expect("frame variable other.flarr",
+                        substrs = ['flarr = arr =',
+                                   '00 00 cc 41,00 00 ca 41,00 00 c9 41,00 00 d6 41,00 00 db 41,00 00 dc 41,00 00 d1 41'])
+        else:
+            self.expect("frame variable other.flarr",
+                        substrs = ['flarr = arr =',
+                                   '41 cc 00 00,41 ca 00 00,41 c9 00 00,41 d6 00 00,41 db 00 00,41 dc 00 00,41 d1 00 00'])
+
+        if process.GetByteOrder() == lldb.eByteOrderLittle:
+            self.expect("frame variable intarr",
+                        substrs = ['intarr = arr =',
+                                   '01 00 00 00,01 00 00 00,02 00 00 00,03 00 00 00,05 00 00 00'])
+        else:
+            self.expect("frame variable intarr",
+                        substrs = ['intarr = arr =',
+                                   '00 00 00 01,00 00 00 01,00 00 00 02,00 00 00 03,00 00 00 05'])
+
+        if process.GetByteOrder() == lldb.eByteOrderLittle:
+            self.expect("frame variable other.intarr",
+                        substrs = ['intarr = arr = ',
+                                   '09 00 00 00,08 00 00 00,07 00 00 00,06 00 00 00,05 00 00 00'])
+        else:
+            self.expect("frame variable other.intarr",
+                        substrs = ['intarr = arr = ',
+                                   '00 00 00 09,00 00 00 08,00 00 00 07,00 00 00 06,00 00 00 05'])
                     
         self.runCmd("type summary add --summary-string \"arr = ${var%Y}\" \"float [7]\"")
         self.runCmd("type summary add --summary-string \"arr = ${var%Y}\" \"int [5]\"")
             
-        self.expect("frame variable flarr",
-                    substrs = ['flarr = arr =',
-                               '00 00 9d 42             ...B,00 80 9a 42             ...B,00 00 9c 42             ...B,00 40 98 42             .@.B,00 80 99 42             ...B,00 c0 99 42             ...B,00 00 9a 42             ...B'])
-        
-        self.expect("frame variable other.flarr",
-                    substrs = ['flarr = arr =',
-                               '00 00 cc 41             ...A,00 00 ca 41             ...A,00 00 c9 41             ...A,00 00 d6 41             ...A,00 00 db 41             ...A,00 00 dc 41             ...A,00 00 d1 41             ...A'])
-        
-        self.expect("frame variable intarr",
-                    substrs = ['intarr = arr =',
-                               '....,01 00 00 00',
-                               '....,05 00 00 00'])
-        
-        self.expect("frame variable other.intarr",
-                    substrs = ['intarr = arr = ',
-                               '09 00 00 00',
-                               '....,07 00 00 00'])
+        if process.GetByteOrder() == lldb.eByteOrderLittle:
+            self.expect("frame variable flarr",
+                        substrs = ['flarr = arr =',
+                                   '00 00 9d 42             ...B,00 80 9a 42             ...B,00 00 9c 42             ...B,00 40 98 42             .@.B,00 80 99 42             ...B,00 c0 99 42             ...B,00 00 9a 42             ...B'])
+        else:
+            self.expect("frame variable flarr",
+                        substrs = ['flarr = arr =',
+                                   '42 9d 00 00             B...,42 9a 80 00             B...,42 9c 00 00             B...,42 98 40 00             B.@.,42 99 80 00             B...,42 99 c0 00             B...,42 9a 00 00             B...'])
+
+        if process.GetByteOrder() == lldb.eByteOrderLittle:
+            self.expect("frame variable other.flarr",
+                        substrs = ['flarr = arr =',
+                                   '00 00 cc 41             ...A,00 00 ca 41             ...A,00 00 c9 41             ...A,00 00 d6 41             ...A,00 00 db 41             ...A,00 00 dc 41             ...A,00 00 d1 41             ...A'])
+        else:
+            self.expect("frame variable other.flarr",
+                        substrs = ['flarr = arr =',
+                                   '41 cc 00 00             A...,41 ca 00 00             A...,41 c9 00 00             A...,41 d6 00 00             A...,41 db 00 00             A...,41 dc 00 00             A...,41 d1 00 00             A...'])
+
+        if process.GetByteOrder() == lldb.eByteOrderLittle:
+            self.expect("frame variable intarr",
+                        substrs = ['intarr = arr =',
+                                   '....,01 00 00 00',
+                                   '....,05 00 00 00'])
+        else:
+            self.expect("frame variable intarr",
+                        substrs = ['intarr = arr =',
+                                   '....,00 00 00 01',
+                                   '....,00 00 00 05'])
+
+        if process.GetByteOrder() == lldb.eByteOrderLittle:
+            self.expect("frame variable other.intarr",
+                        substrs = ['intarr = arr = ',
+                                   '09 00 00 00',
+                                   '....,07 00 00 00'])
+        else:
+            self.expect("frame variable other.intarr",
+                        substrs = ['intarr = arr = ',
+                                   '00 00 00 09',
+                                   '....,00 00 00 07'])
diff --git a/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/atomic/Makefile b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/atomic/Makefile
new file mode 100644
index 000000000000..fdd717119d95
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/atomic/Makefile
@@ -0,0 +1,5 @@
+LEVEL = ../../../../../make
+CXX_SOURCES := main.cpp
+CXXFLAGS += -std=c++11
+USE_LIBCPP := 1
+include $(LEVEL)/Makefile.rules
diff --git a/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/atomic/TestLibCxxAtomic.py b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/atomic/TestLibCxxAtomic.py
new file mode 100644
index 000000000000..083f713c259d
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/atomic/TestLibCxxAtomic.py
@@ -0,0 +1,52 @@
+"""
+Test lldb data formatter subsystem.
+"""
+
+from __future__ import print_function
+
+
+
+import os, time
+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+class LibCxxAtomicTestCase(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    def get_variable(self, name):
+        var = self.frame().FindVariable(name)
+        var.SetPreferDynamicValue(lldb.eDynamicCanRunTarget)
+        var.SetPreferSyntheticValue(True)
+        return var
+
+    @skipIf(compiler="gcc")
+    @skipIfWindows # libc++ not ported to Windows yet
+    def test(self):
+        """Test that std::atomic as defined by libc++ is correctly printed by LLDB"""
+        self.build()
+        self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
+
+        bkpt = self.target().FindBreakpointByID(lldbutil.run_break_set_by_source_regexp (self, "Set break point at this line."))
+
+        self.runCmd("run", RUN_SUCCEEDED)
+
+        lldbutil.skip_if_library_missing(self, self.target(), lldbutil.PrintableRegex("libc\+\+"))
+
+        # The stop reason of the thread should be breakpoint.
+        self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
+            substrs = ['stopped',
+                       'stop reason = breakpoint'])
+        
+        s = self.get_variable('s')
+        i = self.get_variable('i')
+        
+        if self.TraceOn(): print(s)
+        if self.TraceOn(): print(i)
+        
+        self.assertTrue(i.GetValueAsUnsigned(0) == 5, "i == 5")
+        self.assertTrue(s.GetNumChildren() == 2, "s has two children")
+        self.assertTrue(s.GetChildAtIndex(0).GetValueAsUnsigned(0) == 1, "s.x == 1")
+        self.assertTrue(s.GetChildAtIndex(1).GetValueAsUnsigned(0) == 2, "s.y == 2")
diff --git a/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/atomic/main.cpp b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/atomic/main.cpp
new file mode 100644
index 000000000000..0eb2418c628a
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/atomic/main.cpp
@@ -0,0 +1,26 @@
+//===-- main.cpp --------------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include <atomic>
+
+struct S {
+    int x = 1;
+    int y = 2;
+};
+
+int main ()
+{
+    std::atomic<S> s;
+    s.store(S());
+    std::atomic<int> i;
+    i.store(5);
+    
+    return 0; // Set break point at this line.
+}
+
diff --git a/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/initializerlist/TestInitializerList.py b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/initializerlist/TestInitializerList.py
index e01f1b6679fc..d452c1be69bf 100644
--- a/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/initializerlist/TestInitializerList.py
+++ b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/initializerlist/TestInitializerList.py
@@ -8,16 +8,17 @@ from __future__ import print_function
 
 import os, time
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbutil
 
 class InitializerListTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @skipIfWindows # libc++ not ported to Windows yet
-    @skipIfGcc
-    @expectedFailureLinux # fails on clang 3.5 and tot
+    @skipIf(compiler="gcc")
+    @expectedFailureAll(oslist=["linux"], bugnumber="fails on clang 3.5 and tot")
     def test(self):
         """Test that that file and class static variables display correctly."""
         self.build()
diff --git a/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/iterator/TestDataFormatterLibccIterator.py b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/iterator/TestDataFormatterLibccIterator.py
index a87a2ed2d434..23f6956cf3f0 100644
--- a/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/iterator/TestDataFormatterLibccIterator.py
+++ b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/iterator/TestDataFormatterLibccIterator.py
@@ -8,8 +8,9 @@ from __future__ import print_function
 
 import os, time
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbutil
 
 class LibcxxIteratorDataFormatterTestCase(TestBase):
 
@@ -21,7 +22,7 @@ class LibcxxIteratorDataFormatterTestCase(TestBase):
         # Find the line number to break at.
         self.line = line_number('main.cpp', '// Set break point at this line.')
 
-    @skipIfGcc
+    @skipIf(compiler="gcc")
     @skipIfWindows # libc++ not ported to Windows yet
     def test_with_run_command(self):
         """Test that libc++ iterators format properly."""
diff --git a/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/list/TestDataFormatterLibcxxList.py b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/list/TestDataFormatterLibcxxList.py
index 18ee31a86106..6fcdc37465db 100644
--- a/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/list/TestDataFormatterLibcxxList.py
+++ b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/list/TestDataFormatterLibcxxList.py
@@ -8,8 +8,9 @@ from __future__ import print_function
 
 import os, time, re
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbutil
 
 class LibcxxListDataFormatterTestCase(TestBase):
 
@@ -24,8 +25,9 @@ class LibcxxListDataFormatterTestCase(TestBase):
         self.line3 = line_number('main.cpp', '// Set third break point at this line.')
         self.line4 = line_number('main.cpp', '// Set fourth break point at this line.')
 
-    @skipIfGcc
+    @skipIf(compiler="gcc")
     @skipIfWindows # libc++ not ported to Windows yet
+    @expectedFailureAll(oslist=["macosx"], bugnumber="rdar://25499635")
     def test_with_run_command(self):
         """Test that that file and class static variables display correctly."""
         self.build()
diff --git a/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/list/loop/TestDataFormatterLibcxxListLoop.py b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/list/loop/TestDataFormatterLibcxxListLoop.py
index 167cb2b887af..9e68e1dbc004 100644
--- a/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/list/loop/TestDataFormatterLibcxxListLoop.py
+++ b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/list/loop/TestDataFormatterLibcxxListLoop.py
@@ -9,16 +9,18 @@ from __future__ import print_function
 
 import os, time, re
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbutil
 
 class LibcxxListDataFormatterTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @skipIfGcc
+    @skipIf(compiler="gcc")
     @skipIfWindows # libc++ not ported to Windows yet
     @add_test_categories(["pyapi"])
+    @skipIfDarwin  # rdar://25499635
     def test_with_run_command(self):
         self.build()
         exe = os.path.join(os.getcwd(), "a.out")
diff --git a/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/map/TestDataFormatterLibccMap.py b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/map/TestDataFormatterLibccMap.py
index 70a98f9c2cae..cecc3178b318 100644
--- a/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/map/TestDataFormatterLibccMap.py
+++ b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/map/TestDataFormatterLibccMap.py
@@ -8,14 +8,15 @@ from __future__ import print_function
 
 import os, time
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbutil
 
 class LibcxxMapDataFormatterTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @skipIfGcc
+    @skipIf(compiler="gcc")
     @skipIfWindows # libc++ not ported to Windows yet
     def test_with_run_command(self):
         """Test that that file and class static variables display correctly."""
diff --git a/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/multimap/TestDataFormatterLibccMultiMap.py b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/multimap/TestDataFormatterLibccMultiMap.py
index d0ca73d3251d..eb74818c91f5 100644
--- a/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/multimap/TestDataFormatterLibccMultiMap.py
+++ b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/multimap/TestDataFormatterLibccMultiMap.py
@@ -9,14 +9,16 @@ from __future__ import print_function
 import os, time
 import lldb
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
 
 class LibcxxMultiMapDataFormatterTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @skipIfWindows # libc++ not ported to Windows yet
-    @skipIfGcc
+    @skipIf(compiler="gcc")
     def test_with_run_command(self):
         """Test that that file and class static variables display correctly."""
         self.build()
diff --git a/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/multiset/TestDataFormatterLibcxxMultiSet.py b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/multiset/TestDataFormatterLibcxxMultiSet.py
index 384f6130d0c0..cfdfd07ddec1 100644
--- a/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/multiset/TestDataFormatterLibcxxMultiSet.py
+++ b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/multiset/TestDataFormatterLibcxxMultiSet.py
@@ -8,14 +8,15 @@ from __future__ import print_function
 
 import os, time
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbutil
 
 class LibcxxMultiSetDataFormatterTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @skipIfGcc
+    @skipIf(compiler="gcc")
     @skipIfWindows # libc++ not ported to Windows yet
     def test_with_run_command(self):
         """Test that that file and class static variables display correctly."""
diff --git a/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/set/TestDataFormatterLibcxxSet.py b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/set/TestDataFormatterLibcxxSet.py
index fcbfb0a8f0ed..00c1e548cf6b 100644
--- a/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/set/TestDataFormatterLibcxxSet.py
+++ b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/set/TestDataFormatterLibcxxSet.py
@@ -8,62 +8,63 @@ from __future__ import print_function
 
 import os, time
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbutil
 
 class LibcxxSetDataFormatterTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @skipIfGcc
+    @skipIf(compiler="gcc")
     @skipIfWindows # libc++ not ported to Windows yet
     def test_with_run_command(self):
         """Test that that file and class static variables display correctly."""
         self.build()
         self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
         
-        bkpt = self.target().FindBreakpointByID(lldbutil.run_break_set_by_source_regexp (self, "Set break point at this line."))
+#        bkpt = self.target().FindBreakpointByID(lldbutil.run_break_set_by_source_regexp (self, "Set break point at this line."))
 
         self.runCmd("run", RUN_SUCCEEDED)
 
-        lldbutil.skip_if_library_missing(self, self.target(), lldbutil.PrintableRegex("libc\+\+"))
-
-        # The stop reason of the thread should be breakpoint.
-        self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
-            substrs = ['stopped',
-                       'stop reason = breakpoint'])
-
-        # 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 format clear', check=False)
-            self.runCmd('type summary clear', check=False)
-            self.runCmd('type filter clear', check=False)
-            self.runCmd('type synth clear', check=False)
-            self.runCmd("settings set target.max-children-count 256", check=False)
-
-        # Execute the cleanup function during test case tear down.
-        self.addTearDownHook(cleanup)
-
-        self.expect('image list', substrs = self.getLibcPlusPlusLibs())
-
-        self.expect("frame variable ii",substrs = ["size=0","{}"])
-        lldbutil.continue_to_breakpoint(self.process(), bkpt)
-        self.expect("frame variable ii",substrs = ["size=6","[0] = 0","[1] = 1", "[2] = 2", "[3] = 3", "[4] = 4", "[5] = 5"])
-        lldbutil.continue_to_breakpoint(self.process(), bkpt)
-        self.expect("frame variable ii",substrs = ["size=7","[2] = 2", "[3] = 3", "[6] = 6"])
-        self.expect("frame variable ii[2]",substrs = [" = 2"])
-        self.expect("p ii",substrs = ["size=7","[2] = 2", "[3] = 3", "[6] = 6"])
-        lldbutil.continue_to_breakpoint(self.process(), bkpt)
-        self.expect("frame variable ii",substrs = ["size=0","{}"])
-        lldbutil.continue_to_breakpoint(self.process(), bkpt)
-        self.expect("frame variable ii",substrs = ["size=0","{}"])
-        self.expect("frame variable ss",substrs = ["size=0","{}"])
-        lldbutil.continue_to_breakpoint(self.process(), bkpt)
-        self.expect("frame variable ss",substrs = ["size=2",'[0] = "a"','[1] = "a very long string is right here"'])
-        lldbutil.continue_to_breakpoint(self.process(), bkpt)
-        self.expect("frame variable ss",substrs = ["size=4",'[2] = "b"','[3] = "c"','[0] = "a"','[1] = "a very long string is right here"'])
-        self.expect("p ss",substrs = ["size=4",'[2] = "b"','[3] = "c"','[0] = "a"','[1] = "a very long string is right here"'])
-        self.expect("frame variable ss[2]",substrs = [' = "b"'])
-        lldbutil.continue_to_breakpoint(self.process(), bkpt)
-        self.expect("frame variable ss",substrs = ["size=3",'[0] = "a"','[1] = "a very long string is right here"','[2] = "c"'])
+#        lldbutil.skip_if_library_missing(self, self.target(), lldbutil.PrintableRegex("libc\+\+"))
+#
+#        # The stop reason of the thread should be breakpoint.
+#        self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
+#            substrs = ['stopped',
+#                       'stop reason = breakpoint'])
+#
+#        # 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 format clear', check=False)
+#            self.runCmd('type summary clear', check=False)
+#            self.runCmd('type filter clear', check=False)
+#            self.runCmd('type synth clear', check=False)
+#            self.runCmd("settings set target.max-children-count 256", check=False)
+#
+#        # Execute the cleanup function during test case tear down.
+#        self.addTearDownHook(cleanup)
+#
+#        self.expect('image list', substrs = self.getLibcPlusPlusLibs())
+#
+#        self.expect("frame variable ii",substrs = ["size=0","{}"])
+#        lldbutil.continue_to_breakpoint(self.process(), bkpt)
+#        self.expect("frame variable ii",substrs = ["size=6","[0] = 0","[1] = 1", "[2] = 2", "[3] = 3", "[4] = 4", "[5] = 5"])
+#        lldbutil.continue_to_breakpoint(self.process(), bkpt)
+#        self.expect("frame variable ii",substrs = ["size=7","[2] = 2", "[3] = 3", "[6] = 6"])
+#        self.expect("frame variable ii[2]",substrs = [" = 2"])
+#        self.expect("p ii",substrs = ["size=7","[2] = 2", "[3] = 3", "[6] = 6"])
+#        lldbutil.continue_to_breakpoint(self.process(), bkpt)
+#        self.expect("frame variable ii",substrs = ["size=0","{}"])
+#        lldbutil.continue_to_breakpoint(self.process(), bkpt)
+#        self.expect("frame variable ii",substrs = ["size=0","{}"])
+#        self.expect("frame variable ss",substrs = ["size=0","{}"])
+#        lldbutil.continue_to_breakpoint(self.process(), bkpt)
+#        self.expect("frame variable ss",substrs = ["size=2",'[0] = "a"','[1] = "a very long string is right here"'])
+#        lldbutil.continue_to_breakpoint(self.process(), bkpt)
+#        self.expect("frame variable ss",substrs = ["size=4",'[2] = "b"','[3] = "c"','[0] = "a"','[1] = "a very long string is right here"'])
+#        self.expect("p ss",substrs = ["size=4",'[2] = "b"','[3] = "c"','[0] = "a"','[1] = "a very long string is right here"'])
+#        self.expect("frame variable ss[2]",substrs = [' = "b"'])
+#        lldbutil.continue_to_breakpoint(self.process(), bkpt)
+#        self.expect("frame variable ss",substrs = ["size=3",'[0] = "a"','[1] = "a very long string is right here"','[2] = "c"'])
diff --git a/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/string/TestDataFormatterLibcxxString.py b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/string/TestDataFormatterLibcxxString.py
index 942124255f55..76eedb8c8919 100644
--- a/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/string/TestDataFormatterLibcxxString.py
+++ b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/string/TestDataFormatterLibcxxString.py
@@ -9,8 +9,9 @@ from __future__ import print_function
 
 import os, time
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbutil
 
 class LibcxxStringDataFormatterTestCase(TestBase):
 
@@ -22,7 +23,7 @@ class LibcxxStringDataFormatterTestCase(TestBase):
         # Find the line number to break at.
         self.line = line_number('main.cpp', '// Set break point at this line.')
 
-    @skipIfGcc
+    @skipIf(compiler="gcc")
     @skipIfWindows # libc++ not ported to Windows yet
     def test_with_run_command(self):
         """Test that that file and class static variables display correctly."""
diff --git a/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/unordered/TestDataFormatterUnordered.py b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/unordered/TestDataFormatterUnordered.py
index 5e6ec2519323..4765cd70f67c 100644
--- a/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/unordered/TestDataFormatterUnordered.py
+++ b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/unordered/TestDataFormatterUnordered.py
@@ -8,15 +8,16 @@ from __future__ import print_function
 
 import os, time
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbutil
 
 class LibcxxUnorderedDataFormatterTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @skipIfWindows # libc++ not ported to Windows yet
-    @skipIfGcc
+    @skipIf(compiler="gcc")
     def test_with_run_command(self):
         """Test that that file and class static variables display correctly."""
         self.build()
@@ -72,4 +73,5 @@ class LibcxxUnorderedDataFormatterTestCase(TestBase):
 
     def look_for_content_and_continue(self, var_name, patterns):
         self.expect( ("frame variable %s" % var_name), patterns=patterns)
+        self.expect( ("frame variable %s" % var_name), patterns=patterns)
         self.runCmd("continue")
diff --git a/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/vbool/TestDataFormatterLibcxxVBool.py b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/vbool/TestDataFormatterLibcxxVBool.py
index 9771a819aa6b..fe3b6c115e31 100644
--- a/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/vbool/TestDataFormatterLibcxxVBool.py
+++ b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/vbool/TestDataFormatterLibcxxVBool.py
@@ -8,8 +8,9 @@ from __future__ import print_function
 
 import os, time
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbutil
 
 class LibcxxVBoolDataFormatterTestCase(TestBase):
 
@@ -21,7 +22,7 @@ class LibcxxVBoolDataFormatterTestCase(TestBase):
         # Find the line number to break at.
         self.line = line_number('main.cpp', '// Set break point at this line.')
 
-    @skipIfGcc
+    @skipIf(compiler="gcc")
     @skipIfWindows # libc++ not ported to Windows.
     def test_with_run_command(self):
         """Test that that file and class static variables display correctly."""
diff --git a/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/vector/TestDataFormatterLibcxxVector.py b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/vector/TestDataFormatterLibcxxVector.py
index f8cd65be0931..9a145fba73e8 100644
--- a/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/vector/TestDataFormatterLibcxxVector.py
+++ b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/vector/TestDataFormatterLibcxxVector.py
@@ -8,14 +8,15 @@ from __future__ import print_function
 
 import os, time
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbutil
 
 class LibcxxVectorDataFormatterTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @skipIfGcc
+    @skipIf(compiler="gcc")
     @skipIfWindows # libc++ not ported to Windows yet
     def test_with_run_command(self):
         """Test that that file and class static variables display correctly."""
diff --git a/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libstdcpp/iterator/TestDataFormatterStdIterator.py b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libstdcpp/iterator/TestDataFormatterStdIterator.py
index 6742c9e71701..dbaa37daa2d1 100644
--- a/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libstdcpp/iterator/TestDataFormatterStdIterator.py
+++ b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libstdcpp/iterator/TestDataFormatterStdIterator.py
@@ -8,8 +8,9 @@ from __future__ import print_function
 
 import os, time
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbutil
 
 class StdIteratorDataFormatterTestCase(TestBase):
 
@@ -22,7 +23,7 @@ class StdIteratorDataFormatterTestCase(TestBase):
         self.line = line_number('main.cpp', '// Set break point at this line.')
 
     @skipIfWindows # libstdcpp not ported to Windows
-    @expectedFailureIcc # llvm.org/pr15301 LLDB prints incorrect sizes of STL containers
+    @expectedFailureAll(compiler="icc", bugnumber="llvm.org/pr15301 LLDB prints incorrect sizes of STL containers")
     def test_with_run_command(self):
         """Test that libstdcpp iterators format properly."""
         self.build()
diff --git a/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libstdcpp/list/TestDataFormatterStdList.py b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libstdcpp/list/TestDataFormatterStdList.py
index 5147d18da0fe..55658af1f2a3 100644
--- a/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libstdcpp/list/TestDataFormatterStdList.py
+++ b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libstdcpp/list/TestDataFormatterStdList.py
@@ -8,8 +8,9 @@ from __future__ import print_function
 
 import os, time
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbutil
 
 class StdListDataFormatterTestCase(TestBase):
 
diff --git a/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libstdcpp/map/TestDataFormatterStdMap.py b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libstdcpp/map/TestDataFormatterStdMap.py
index e21c4e94c2c4..ff99255aec0c 100644
--- a/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libstdcpp/map/TestDataFormatterStdMap.py
+++ b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libstdcpp/map/TestDataFormatterStdMap.py
@@ -8,8 +8,9 @@ from __future__ import print_function
 
 import os, time
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbutil
 
 class StdMapDataFormatterTestCase(TestBase):
 
@@ -21,7 +22,7 @@ class StdMapDataFormatterTestCase(TestBase):
         # Find the line number to break at.
         self.line = line_number('main.cpp', '// Set break point at this line.')
 
-    @expectedFailureIcc   # llvm.org/pr15301: LLDB prints incorrect size of libstdc++ containers
+    @expectedFailureAll(compiler="icc", bugnumber="llvm.org/pr15301 LLDB prints incorrect sizes of STL containers")
     @skipIfWindows # libstdcpp not ported to Windows
     @skipIfFreeBSD
     def test_with_run_command(self):
diff --git a/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libstdcpp/smart_ptr/Makefile b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libstdcpp/smart_ptr/Makefile
new file mode 100644
index 000000000000..88cb026aba1c
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libstdcpp/smart_ptr/Makefile
@@ -0,0 +1,15 @@
+LEVEL = ../../../../../make
+
+CXX_SOURCES := main.cpp
+
+CXXFLAGS := -O0
+USE_LIBSTDCPP := 1
+
+# clang-3.5+ outputs FullDebugInfo by default for Darwin/FreeBSD
+# targets.  Other targets do not, which causes this test to fail.
+# This flag enables FullDebugInfo for all targets.
+ifneq (,$(findstring clang,$(CC)))
+  CFLAGS_EXTRAS += -fno-limit-debug-info
+endif
+
+include $(LEVEL)/Makefile.rules
diff --git a/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libstdcpp/smart_ptr/TestDataFormatterStdSmartPtr.py b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libstdcpp/smart_ptr/TestDataFormatterStdSmartPtr.py
new file mode 100644
index 000000000000..20b1a3d21156
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libstdcpp/smart_ptr/TestDataFormatterStdSmartPtr.py
@@ -0,0 +1,46 @@
+"""
+Test lldb data formatter subsystem.
+"""
+
+from __future__ import print_function
+
+import os, time
+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+class StdSmartPtrDataFormatterTestCase(TestBase):
+    mydir = TestBase.compute_mydir(__file__)
+
+    @skipIfFreeBSD
+    @skipIfWindows # libstdcpp not ported to Windows
+    @skipIfDarwin # doesn't compile on Darwin
+    def test_with_run_command(self):
+        self.build()
+        self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
+
+        lldbutil.run_break_set_by_source_regexp (self, "Set break point at this line.")
+        self.runCmd("run", RUN_SUCCEEDED)
+
+        # The stop reason of the thread should be breakpoint.
+        self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
+            substrs = ['stopped', 'stop reason = breakpoint'])
+
+        self.expect("frame variable nsp", substrs = ['nsp = nullptr'])
+        self.expect("frame variable isp", substrs = ['isp = 123'])
+        self.expect("frame variable ssp", substrs = ['ssp = "foobar"'])
+
+        self.expect("frame variable nwp", substrs = ['nwp = nullptr'])
+        self.expect("frame variable iwp", substrs = ['iwp = 123'])
+        self.expect("frame variable swp", substrs = ['swp = "foobar"'])
+        
+        self.runCmd("continue")
+
+        self.expect("frame variable nsp", substrs = ['nsp = nullptr'])
+        self.expect("frame variable isp", substrs = ['isp = nullptr'])
+        self.expect("frame variable ssp", substrs = ['ssp = nullptr'])
+
+        self.expect("frame variable nwp", substrs = ['nwp = nullptr'])
+        self.expect("frame variable iwp", substrs = ['iwp = nullptr'])
+        self.expect("frame variable swp", substrs = ['swp = nullptr'])
diff --git a/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libstdcpp/smart_ptr/main.cpp b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libstdcpp/smart_ptr/main.cpp
new file mode 100644
index 000000000000..7ba50875a6db
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libstdcpp/smart_ptr/main.cpp
@@ -0,0 +1,20 @@
+#include <memory>
+#include <string>
+
+int
+main()
+{
+    std::shared_ptr<char> nsp;
+    std::shared_ptr<int> isp(new int{123});
+    std::shared_ptr<std::string> ssp = std::make_shared<std::string>("foobar");
+
+    std::weak_ptr<char> nwp;
+    std::weak_ptr<int> iwp = isp;
+    std::weak_ptr<std::string> swp = ssp;
+
+    nsp.reset(); // Set break point at this line.
+    isp.reset();
+    ssp.reset();
+
+    return 0; // Set break point at this line.
+}
diff --git a/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libstdcpp/string/TestDataFormatterStdString.py b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libstdcpp/string/TestDataFormatterStdString.py
index 2d6af24c6afc..fde2f791183a 100644
--- a/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libstdcpp/string/TestDataFormatterStdString.py
+++ b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libstdcpp/string/TestDataFormatterStdString.py
@@ -9,8 +9,9 @@ from __future__ import print_function
 
 import os, time
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbutil
 
 class StdStringDataFormatterTestCase(TestBase):
 
diff --git a/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libstdcpp/vbool/TestDataFormatterStdVBool.py b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libstdcpp/vbool/TestDataFormatterStdVBool.py
index 9e73009aba83..f5cf7c04c3a7 100644
--- a/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libstdcpp/vbool/TestDataFormatterStdVBool.py
+++ b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libstdcpp/vbool/TestDataFormatterStdVBool.py
@@ -8,8 +8,9 @@ from __future__ import print_function
 
 import os, time
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbutil
 
 class StdVBoolDataFormatterTestCase(TestBase):
 
@@ -21,8 +22,8 @@ class StdVBoolDataFormatterTestCase(TestBase):
         # Find the line number to break at.
         self.line = line_number('main.cpp', '// Set break point at this line.')
 
-    @expectedFailureFreeBSD("llvm.org/pr20548") # fails to build on lab.llvm.org buildbot
-    @expectedFailureIcc # llvm.org/pr15301: lldb does not print the correct sizes of STL containers when building with ICC
+    @expectedFailureAll(oslist=['freebsd'], bugnumber='llvm.org/pr20548 fails to build on lab.llvm.org buildbot')
+    @expectedFailureAll(compiler="icc", bugnumber="llvm.org/pr15301 LLDB prints incorrect sizes of STL containers")
     @skipIfWindows # libstdcpp not ported to Windows.
     @skipIfDarwin
     def test_with_run_command(self):
diff --git a/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libstdcpp/vector/TestDataFormatterStdVector.py b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libstdcpp/vector/TestDataFormatterStdVector.py
index ed4313657e93..4a352ef41c17 100644
--- a/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libstdcpp/vector/TestDataFormatterStdVector.py
+++ b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libstdcpp/vector/TestDataFormatterStdVector.py
@@ -8,8 +8,9 @@ from __future__ import print_function
 
 import os, time
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbutil
 
 class StdVectorDataFormatterTestCase(TestBase):
 
@@ -22,7 +23,7 @@ class StdVectorDataFormatterTestCase(TestBase):
         self.line = line_number('main.cpp', '// Set break point at this line.')
 
     @skipIfFreeBSD
-    @expectedFailureIcc # llvm.org/pr15301 LLDB prints incorrect sizes of STL containers
+    @expectedFailureAll(compiler="icc", bugnumber="llvm.org/pr15301 LLDB prints incorrect sizes of STL containers")
     @skipIfWindows # libstdcpp not ported to Windows
     def test_with_run_command(self):
         """Test that that file and class static variables display correctly."""
diff --git a/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-synthtype/Makefile b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-synthtype/Makefile
new file mode 100644
index 000000000000..314f1cb2f077
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-synthtype/Makefile
@@ -0,0 +1,5 @@
+LEVEL = ../../../make
+
+CXX_SOURCES := main.cpp
+
+include $(LEVEL)/Makefile.rules
diff --git a/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-synthtype/TestDataFormatterSynthType.py b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-synthtype/TestDataFormatterSynthType.py
new file mode 100644
index 000000000000..6a03456e5c32
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-synthtype/TestDataFormatterSynthType.py
@@ -0,0 +1,56 @@
+"""
+Test lldb data formatter subsystem.
+"""
+
+from __future__ import print_function
+
+
+
+import os, time
+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+class DataFormatterSynthTypeTestCase(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    def setUp(self):
+        # Call super's setUp().
+        TestBase.setUp(self)
+        # Find the line number to break at.
+        self.line = line_number('main.cpp', 'break here')
+
+    @skipIfFreeBSD # llvm.org/pr20545 bogus output confuses buildbot parser
+    def test_with_run_command(self):
+        """Test using Python synthetic children provider to provide a typename."""
+        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=True)
+
+        self.runCmd("run", RUN_SUCCEEDED)
+
+        # The stop reason of the thread should be breakpoint.
+        self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
+            substrs = ['stopped',
+                       'stop reason = breakpoint'])
+
+        # 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 format clear', check=False)
+            self.runCmd('type summary clear', check=False)
+            self.runCmd('type filter clear', check=False)
+            self.runCmd('type synth clear', check=False)
+
+        # Execute the cleanup function during test case tear down.
+        self.addTearDownHook(cleanup)
+
+        self.runCmd("script from myIntSynthProvider import *")
+        self.runCmd("type synth add -l myIntSynthProvider myInt")
+
+        self.expect('frame variable x', substrs=['ThisTestPasses'])
+        self.expect('frame variable y', substrs=['ThisTestPasses'])
+        self.expect('frame variable z', substrs=['ThisTestPasses'])
diff --git a/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-synthtype/main.cpp b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-synthtype/main.cpp
new file mode 100644
index 000000000000..accbf0a5a578
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-synthtype/main.cpp
@@ -0,0 +1,29 @@
+class myInt {
+    private: int theValue;
+    public: myInt() : theValue(0) {}
+    public: myInt(int _x) : theValue(_x) {}
+    int val() { return theValue; }
+};
+
+class myArray {
+public:
+    int array[16];
+};
+
+class hasAnInt {
+    public:
+        myInt theInt;
+        hasAnInt() : theInt(42) {}  
+};
+
+myInt operator + (myInt x, myInt y) { return myInt(x.val() + y.val()); }
+
+int main() {
+    myInt x{3};
+    myInt y{4};
+    myInt z {x+y};
+    hasAnInt hi;
+    myArray ma;
+
+    return z.val(); // break here
+}
diff --git a/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-synthtype/myIntSynthProvider.py b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-synthtype/myIntSynthProvider.py
new file mode 100644
index 000000000000..42737140b112
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-synthtype/myIntSynthProvider.py
@@ -0,0 +1,36 @@
+class myIntSynthProvider(object):
+	def __init__(self, valobj, dict):
+		self.valobj = valobj;
+		self.val = self.valobj.GetChildMemberWithName("theValue")
+	def num_children(self):
+		return 0;
+	def get_child_at_index(self, index):
+	    return None
+	def get_child_index(self, name):
+	    return None
+	def update(self):
+		return False
+	def has_children(self):
+	    return False
+	def get_type_name(self):
+	    return "ThisTestPasses"
+
+
+class myArraySynthProvider(object):
+    def __init__(self, valobj, dict):
+        self.valobj = valobj
+        self.array = self.valobj.GetChildMemberWithName("array")
+
+    def num_children(self, max_count):
+        if 16 < max_count:
+            return 16
+        return max_count
+
+    def get_child_at_index(self, index):
+        return None # Keep it simple when this is not tested here.
+
+    def get_child_index(self, name):
+        return None # Keep it simple when this is not tested here.
+
+    def has_children(self):
+        return True
diff --git a/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-synthval/TestDataFormatterSynthVal.py b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-synthval/TestDataFormatterSynthVal.py
index 8d6e5df37a5c..e7a34647a6de 100644
--- a/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-synthval/TestDataFormatterSynthVal.py
+++ b/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-synthval/TestDataFormatterSynthVal.py
@@ -8,8 +8,9 @@ from __future__ import print_function
 
 import os, time
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbutil
 
 class DataFormatterSynthValueTestCase(TestBase):
 
@@ -22,7 +23,7 @@ class DataFormatterSynthValueTestCase(TestBase):
         self.line = line_number('main.cpp', 'break here')
 
     @skipIfFreeBSD # llvm.org/pr20545 bogus output confuses buildbot parser
-    @expectedFailureWindows("llvm.org/pr24462") # Data formatters have problems on Windows
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24462, Data formatters have problems on Windows")
     def test_with_run_command(self):
         """Test using Python synthetic children provider to provide a value."""
         self.build()
diff --git a/packages/Python/lldbsuite/test/functionalities/data-formatter/dump_dynamic/TestDumpDynamic.py b/packages/Python/lldbsuite/test/functionalities/data-formatter/dump_dynamic/TestDumpDynamic.py
index 8ae09d691940..886d09fda456 100644
--- a/packages/Python/lldbsuite/test/functionalities/data-formatter/dump_dynamic/TestDumpDynamic.py
+++ b/packages/Python/lldbsuite/test/functionalities/data-formatter/dump_dynamic/TestDumpDynamic.py
@@ -2,4 +2,4 @@ from __future__ import absolute_import
 
 from lldbsuite.test import lldbinline
 
-lldbinline.MakeInlineTest(__file__, globals(), [lldbinline.expectedFailureWindows("llvm.org/pr24663")])
+lldbinline.MakeInlineTest(__file__, globals(), [lldbinline.expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24663")])
diff --git a/packages/Python/lldbsuite/test/functionalities/data-formatter/nsarraysynth/TestNSArraySynthetic.py b/packages/Python/lldbsuite/test/functionalities/data-formatter/nsarraysynth/TestNSArraySynthetic.py
index a12f9c841a7f..871cc19373a4 100644
--- a/packages/Python/lldbsuite/test/functionalities/data-formatter/nsarraysynth/TestNSArraySynthetic.py
+++ b/packages/Python/lldbsuite/test/functionalities/data-formatter/nsarraysynth/TestNSArraySynthetic.py
@@ -6,11 +6,12 @@ from __future__ import print_function
 
 
 
+import datetime
 import os, time
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import datetime
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbutil
 
 class NSArraySyntheticTestCase(TestBase):
 
diff --git a/packages/Python/lldbsuite/test/functionalities/data-formatter/nsdictionarysynth/TestNSDictionarySynthetic.py b/packages/Python/lldbsuite/test/functionalities/data-formatter/nsdictionarysynth/TestNSDictionarySynthetic.py
index 13d493ecbdcc..5ee54c3a2952 100644
--- a/packages/Python/lldbsuite/test/functionalities/data-formatter/nsdictionarysynth/TestNSDictionarySynthetic.py
+++ b/packages/Python/lldbsuite/test/functionalities/data-formatter/nsdictionarysynth/TestNSDictionarySynthetic.py
@@ -6,11 +6,12 @@ from __future__ import print_function
 
 
 
+import datetime
 import os, time
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import datetime
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbutil
 
 class NSDictionarySyntheticTestCase(TestBase):
 
diff --git a/packages/Python/lldbsuite/test/functionalities/data-formatter/nssetsynth/TestNSSetSynthetic.py b/packages/Python/lldbsuite/test/functionalities/data-formatter/nssetsynth/TestNSSetSynthetic.py
index 6c558001bb04..d1680434d3b9 100644
--- a/packages/Python/lldbsuite/test/functionalities/data-formatter/nssetsynth/TestNSSetSynthetic.py
+++ b/packages/Python/lldbsuite/test/functionalities/data-formatter/nssetsynth/TestNSSetSynthetic.py
@@ -6,11 +6,12 @@ from __future__ import print_function
 
 
 
+import datetime
 import os, time
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import datetime
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbutil
 
 class NSSetSyntheticTestCase(TestBase):
 
diff --git a/packages/Python/lldbsuite/test/functionalities/data-formatter/ostypeformatting/TestFormattersOsType.py b/packages/Python/lldbsuite/test/functionalities/data-formatter/ostypeformatting/TestFormattersOsType.py
index 4fb6176e9e4f..4158ec8a661c 100644
--- a/packages/Python/lldbsuite/test/functionalities/data-formatter/ostypeformatting/TestFormattersOsType.py
+++ b/packages/Python/lldbsuite/test/functionalities/data-formatter/ostypeformatting/TestFormattersOsType.py
@@ -6,11 +6,12 @@ from __future__ import print_function
 
 
 
+import datetime
 import os, time
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import datetime
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbutil
 
 class DataFormatterOSTypeTestCase(TestBase):
 
diff --git a/packages/Python/lldbsuite/test/functionalities/data-formatter/parray/Makefile b/packages/Python/lldbsuite/test/functionalities/data-formatter/parray/Makefile
new file mode 100644
index 000000000000..314f1cb2f077
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/data-formatter/parray/Makefile
@@ -0,0 +1,5 @@
+LEVEL = ../../../make
+
+CXX_SOURCES := main.cpp
+
+include $(LEVEL)/Makefile.rules
diff --git a/packages/Python/lldbsuite/test/functionalities/data-formatter/parray/TestPrintArray.py b/packages/Python/lldbsuite/test/functionalities/data-formatter/parray/TestPrintArray.py
new file mode 100644
index 000000000000..700b7418118a
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/data-formatter/parray/TestPrintArray.py
@@ -0,0 +1,70 @@
+"""
+Test lldb data formatter subsystem.
+"""
+
+from __future__ import print_function
+
+
+
+import datetime
+import os, time
+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+class PrintArrayTestCase(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    def test_print_array(self):
+        """Test that expr -Z works"""
+        self.build()
+        self.printarray_data_formatter_commands()
+
+    def setUp(self):
+        # Call super's setUp().
+        TestBase.setUp(self)
+        # Find the line number to break at.
+        self.line = line_number('main.cpp', 'break here')
+
+    def printarray_data_formatter_commands(self):
+        """Test that expr -Z works"""
+        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)
+
+        # The stop reason of the thread should be breakpoint.
+        self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
+            substrs = ['stopped',
+                       'stop reason = breakpoint'])
+
+        # 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 format clear', check=False)
+            self.runCmd('type summary clear', check=False)
+            self.runCmd('type synth clear', check=False)
+
+        # Execute the cleanup function during test case tear down.
+        self.addTearDownHook(cleanup)
+        
+        self.expect('expr --element-count 3 -- data', substrs=['[0] = 1', '[1] = 3', '[2] = 5'])
+        self.expect('expr data', substrs=['int *', '$', '0x'])
+        self.expect('expr -f binary --element-count 0 -- data', substrs=['int *', '$', '0b'])
+        self.expect('expr -f hex --element-count 3 -- data', substrs=['[0] = 0x', '1', '[1] = 0x', '3', '[2] = 0x', '5'])
+        self.expect('expr -f binary --element-count 2 -- data', substrs=['int *', '$', '0x', '[0] = 0b', '1', '[1] = 0b', '11'])
+        self.expect('parray 3 data', substrs=['[0] = 1', '[1] = 3', '[2] = 5'])
+        self.expect('parray `1 + 1 + 1` data', substrs=['[0] = 1', '[1] = 3', '[2] = 5'])
+        self.expect('parray `data[1]` data', substrs=['[0] = 1', '[1] = 3', '[2] = 5'])
+        self.expect('parray/x 3 data', substrs=['[0] = 0x', '1', '[1] = 0x', '3', '[2] = 0x', '5'])
+        self.expect('parray/x `data[1]` data', substrs=['[0] = 0x', '1', '[1] = 0x', '3', '[2] = 0x', '5'])
+
+        # check error conditions
+        self.expect('expr --element-count 10 -- 123', error=True, substrs=['expression cannot be used with --element-count as it does not refer to a pointer'])
+        self.expect('expr --element-count 10 -- (void*)123', error=True, substrs=['expression cannot be used with --element-count as it refers to a pointer to void'])
+        self.expect('parray data', error=True, substrs=["invalid element count 'data'"])
+        self.expect('parray data data', error=True, substrs=["invalid element count 'data'"])
+        self.expect('parray', error=True, substrs=['Not enough arguments provided'])
diff --git a/packages/Python/lldbsuite/test/functionalities/data-formatter/parray/main.cpp b/packages/Python/lldbsuite/test/functionalities/data-formatter/parray/main.cpp
new file mode 100644
index 000000000000..b2d6309947ad
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/data-formatter/parray/main.cpp
@@ -0,0 +1,29 @@
+//===-- main.cpp -------------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include <functional>
+#include <stdlib.h>
+
+template<typename ElemType>
+ElemType* alloc(size_t count, std::function<ElemType(size_t)> get)
+{
+  ElemType *elems = new ElemType[count];
+  for(size_t i = 0; i < count; i++)
+    elems[i] = get(i);
+  return elems;
+}
+
+int main (int argc, const char * argv[])
+{
+  int* data = alloc<int>(5, [] (size_t idx) -> int {
+    return 2 * idx + 1;
+  });
+  return 0; // break here
+}
+
diff --git a/packages/Python/lldbsuite/test/functionalities/data-formatter/poarray/Makefile b/packages/Python/lldbsuite/test/functionalities/data-formatter/poarray/Makefile
new file mode 100644
index 000000000000..261658b10ae8
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/data-formatter/poarray/Makefile
@@ -0,0 +1,9 @@
+LEVEL = ../../../make
+
+OBJCXX_SOURCES := main.mm
+
+CFLAGS_EXTRAS += -w
+
+include $(LEVEL)/Makefile.rules
+
+LDFLAGS += -framework Foundation
diff --git a/packages/Python/lldbsuite/test/functionalities/data-formatter/poarray/TestPrintObjectArray.py b/packages/Python/lldbsuite/test/functionalities/data-formatter/poarray/TestPrintObjectArray.py
new file mode 100644
index 000000000000..7eb26a569867
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/data-formatter/poarray/TestPrintObjectArray.py
@@ -0,0 +1,60 @@
+"""
+Test lldb data formatter subsystem.
+"""
+
+from __future__ import print_function
+
+
+
+import datetime
+import os, time
+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+class PrintObjectArrayTestCase(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    @skipUnlessDarwin
+    def test_print_array(self):
+        """Test that expr -O -Z works"""
+        self.build()
+        self.printarray_data_formatter_commands()
+
+    def setUp(self):
+        # Call super's setUp().
+        TestBase.setUp(self)
+        # Find the line number to break at.
+        self.line = line_number('main.mm', 'break here')
+
+    def printarray_data_formatter_commands(self):
+        """Test that expr -O -Z works"""
+        self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
+
+        lldbutil.run_break_set_by_file_and_line (self, "main.mm", self.line, num_expected_locations=1, loc_exact=True)
+
+        self.runCmd("run", RUN_SUCCEEDED)
+
+        # The stop reason of the thread should be breakpoint.
+        self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
+            substrs = ['stopped',
+                       'stop reason = breakpoint'])
+
+        # 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 format clear', check=False)
+            self.runCmd('type summary clear', check=False)
+            self.runCmd('type synth clear', check=False)
+
+        # Execute the cleanup function during test case tear down.
+        self.addTearDownHook(cleanup)
+
+        self.expect('expr --element-count 3 --object-description -- objects', substrs=['3735928559', '4276993775', '3203398366', 'Hello', 'World', 'Two =', '1 ='])
+        self.expect('poarray 3 objects', substrs=['3735928559', '4276993775', '3203398366', 'Hello', 'World', 'Two =', '1 ='])
+        self.expect('expr --element-count 3 --object-description --description-verbosity=full -- objects', substrs=['[0] =', '3735928559', '4276993775', '3203398366', '[1] =', 'Hello', 'World', '[2] =', 'Two =', '1 ='])
+        self.expect('parray 3 objects', substrs=['[0] = 0x', '[1] = 0x', '[2] = 0x'])
+        self.expect('expr --element-count 3 -d run -- objects', substrs=['3 elements', '2 elements', '2 key/value pairs'])
+        self.expect('expr --element-count 3 -d run --ptr-depth=1 -- objects', substrs=['3 elements', '2 elements', '2 key/value pairs', '3735928559', '4276993775', '3203398366', '"Hello"', '"World"'])
diff --git a/packages/Python/lldbsuite/test/functionalities/data-formatter/poarray/main.mm b/packages/Python/lldbsuite/test/functionalities/data-formatter/poarray/main.mm
new file mode 100644
index 000000000000..9ef61e6a73f2
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/data-formatter/poarray/main.mm
@@ -0,0 +1,30 @@
+//===-- main.cpp -------------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#import <Foundation/Foundation.h>
+
+struct ThreeObjects
+{
+  id one;
+  id two;
+  id three;
+};
+
+int main()
+{
+  NSArray *array1 = @[@0xDEADBEEF, @0xFEEDBEEF, @0xBEEFFADE];
+  NSArray *array2 = @[@"Hello", @"World"];
+  NSDictionary *dictionary = @{@1: array2, @"Two": array2};
+  ThreeObjects *tobjects = new ThreeObjects();
+  tobjects->one = array1;
+  tobjects->two = array2;
+  tobjects->three = dictionary;
+  id* objects = (id*)tobjects;
+  return 0; // break here
+}
diff --git a/packages/Python/lldbsuite/test/functionalities/data-formatter/setvaluefromcstring/TestSetValueFromCString.py b/packages/Python/lldbsuite/test/functionalities/data-formatter/setvaluefromcstring/TestSetValueFromCString.py
index 80305e303d03..791ce27dad00 100644
--- a/packages/Python/lldbsuite/test/functionalities/data-formatter/setvaluefromcstring/TestSetValueFromCString.py
+++ b/packages/Python/lldbsuite/test/functionalities/data-formatter/setvaluefromcstring/TestSetValueFromCString.py
@@ -1,4 +1,4 @@
-import lldbsuite.test.lldbinline as lldbinline
-import lldbsuite.test.lldbtest as lldbtest
+from lldbsuite.test import lldbinline
+from lldbsuite.test import decorators
 
-lldbinline.MakeInlineTest(__file__, globals(), [lldbtest.skipIfFreeBSD,lldbtest.skipIfLinux,lldbtest.skipIfWindows])
+lldbinline.MakeInlineTest(__file__, globals(), [decorators.skipIfFreeBSD,decorators.skipIfLinux,decorators.skipIfWindows])
diff --git a/packages/Python/lldbsuite/test/functionalities/data-formatter/stringprinter/TestStringPrinter.py b/packages/Python/lldbsuite/test/functionalities/data-formatter/stringprinter/TestStringPrinter.py
index 69f7d48c8b6c..e26344f2711a 100644
--- a/packages/Python/lldbsuite/test/functionalities/data-formatter/stringprinter/TestStringPrinter.py
+++ b/packages/Python/lldbsuite/test/functionalities/data-formatter/stringprinter/TestStringPrinter.py
@@ -1,4 +1,4 @@
-import lldbsuite.test.lldbinline as lldbinline
-import lldbsuite.test.lldbtest as lldbtest
+from lldbsuite.test import lldbinline
+from lldbsuite.test import decorators
 
-lldbinline.MakeInlineTest(__file__, globals(), [lldbtest.expectedFailureWindows("llvm.org/pr24772")])
+lldbinline.MakeInlineTest(__file__, globals(), [decorators.expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24772")])
diff --git a/packages/Python/lldbsuite/test/functionalities/data-formatter/synthcapping/TestSyntheticCapping.py b/packages/Python/lldbsuite/test/functionalities/data-formatter/synthcapping/TestSyntheticCapping.py
index 0550f57ae62a..e8b6c1ad95f5 100644
--- a/packages/Python/lldbsuite/test/functionalities/data-formatter/synthcapping/TestSyntheticCapping.py
+++ b/packages/Python/lldbsuite/test/functionalities/data-formatter/synthcapping/TestSyntheticCapping.py
@@ -8,8 +8,9 @@ from __future__ import print_function
 
 import os, time
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbutil
 
 class SyntheticCappingTestCase(TestBase):
 
@@ -30,6 +31,8 @@ class SyntheticCappingTestCase(TestBase):
 
         self.runCmd("run", RUN_SUCCEEDED)
 
+        process = self.dbg.GetSelectedTarget().GetProcess()
+
         # The stop reason of the thread should be breakpoint.
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
             substrs = ['stopped',
@@ -51,25 +54,31 @@ class SyntheticCappingTestCase(TestBase):
         self.runCmd("script from fooSynthProvider import *")
         self.runCmd("type synth add -l fooSynthProvider foo")
 
+        # note that the value of fake_a depends on target byte order
+        if process.GetByteOrder() == lldb.eByteOrderLittle:
+            fake_a_val = 0x02000000
+        else:
+            fake_a_val = 0x00000100
+
         # check that the synthetic children work, so we know we are doing the right thing
         self.expect("frame variable f00_1",
-                    substrs = ['r = 33',
-                               'fake_a = 16777216',
-                               'a = 0']);
+                    substrs = ['r = 34',
+                               'fake_a = %d' % fake_a_val,
+                               'a = 1']);
 
         # check that capping works
         self.runCmd("settings set target.max-children-count 2", check=False)
         
         self.expect("frame variable f00_1",
                     substrs = ['...',
-                               'fake_a = 16777216',
-                               'a = 0']);
+                               'fake_a = %d' % fake_a_val,
+                               'a = 1']);
         
         self.expect("frame variable f00_1", matching=False,
-                    substrs = ['r = 33']);
+                    substrs = ['r = 34']);
 
         
         self.runCmd("settings set target.max-children-count 256", check=False)
 
         self.expect("frame variable f00_1", matching=True,
-                    substrs = ['r = 33']);
+                    substrs = ['r = 34']);
diff --git a/packages/Python/lldbsuite/test/functionalities/data-formatter/synthcapping/fooSynthProvider.py b/packages/Python/lldbsuite/test/functionalities/data-formatter/synthcapping/fooSynthProvider.py
index fb95ac2b54d0..1a7e5679c0b8 100644
--- a/packages/Python/lldbsuite/test/functionalities/data-formatter/synthcapping/fooSynthProvider.py
+++ b/packages/Python/lldbsuite/test/functionalities/data-formatter/synthcapping/fooSynthProvider.py
@@ -1,21 +1,21 @@
 import lldb
 class fooSynthProvider:
-     def __init__(self, valobj, dict):
-         self.valobj = valobj;
-         self.int_type = valobj.GetType().GetBasicType(lldb.eBasicTypeInt)
-     def num_children(self):
-         return 3;
-     def get_child_at_index(self, index):
-         if index == 0:
-             child = self.valobj.GetChildMemberWithName('a');
-         if index == 1:
-             child = self.valobj.CreateChildAtOffset ('fake_a', 1, self.int_type);
-         if index == 2:
-             child = self.valobj.GetChildMemberWithName('r');
-         return child;
-     def get_child_index(self, name):
-         if name == 'a':
-             return 0;
-         if name == 'fake_a':
-             return 1;
-    	 return 2;
+    def __init__(self, valobj, dict):
+        self.valobj = valobj;
+        self.int_type = valobj.GetType().GetBasicType(lldb.eBasicTypeInt)
+    def num_children(self):
+        return 3;
+    def get_child_at_index(self, index):
+        if index == 0:
+            child = self.valobj.GetChildMemberWithName('a');
+        if index == 1:
+            child = self.valobj.CreateChildAtOffset ('fake_a', 1, self.int_type);
+        if index == 2:
+            child = self.valobj.GetChildMemberWithName('r');
+        return child;
+    def get_child_index(self, name):
+        if name == 'a':
+            return 0;
+        if name == 'fake_a':
+            return 1;
+        return 2;
diff --git a/packages/Python/lldbsuite/test/functionalities/data-formatter/synthcapping/main.cpp b/packages/Python/lldbsuite/test/functionalities/data-formatter/synthcapping/main.cpp
index b921915b91c5..fec7907e0031 100644
--- a/packages/Python/lldbsuite/test/functionalities/data-formatter/synthcapping/main.cpp
+++ b/packages/Python/lldbsuite/test/functionalities/data-formatter/synthcapping/main.cpp
@@ -48,7 +48,7 @@ struct wrapint
 
 int main()
 {
-    foo f00_1(0);
+    foo f00_1(1);
     foo *f00_ptr = new foo(12);
     
     f00_1.a++; // Set break point at this line.
diff --git a/packages/Python/lldbsuite/test/functionalities/data-formatter/synthupdate/TestSyntheticFilterRecompute.py b/packages/Python/lldbsuite/test/functionalities/data-formatter/synthupdate/TestSyntheticFilterRecompute.py
index 6b70a88b9f2c..23a31da685de 100644
--- a/packages/Python/lldbsuite/test/functionalities/data-formatter/synthupdate/TestSyntheticFilterRecompute.py
+++ b/packages/Python/lldbsuite/test/functionalities/data-formatter/synthupdate/TestSyntheticFilterRecompute.py
@@ -6,11 +6,12 @@ from __future__ import print_function
 
 
 
+import datetime
 import os, time
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import datetime
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbutil
 
 class SyntheticFilterRecomputingTestCase(TestBase):
 
diff --git a/packages/Python/lldbsuite/test/functionalities/data-formatter/type_summary_list_arg/TestTypeSummaryListArg.py b/packages/Python/lldbsuite/test/functionalities/data-formatter/type_summary_list_arg/TestTypeSummaryListArg.py
new file mode 100644
index 000000000000..6568056f761b
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/data-formatter/type_summary_list_arg/TestTypeSummaryListArg.py
@@ -0,0 +1,31 @@
+"""
+Test lldb data formatter subsystem.
+"""
+
+from __future__ import print_function
+
+
+
+import os, time
+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+class TypeSummaryListArgumentTestCase(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    def setUp(self):
+        # Call super's setUp().
+        TestBase.setUp(self)
+
+    @no_debug_info_test
+    def test_type_summary_list_with_arg(self):
+        """Test that the 'type summary list' command handles command line arguments properly"""
+        self.expect('type summary list Foo', substrs=['Category: default', 'Category: system'])
+        self.expect('type summary list char', substrs=['char *', 'unsigned char'])
+
+        self.expect('type summary list -w default', substrs=['system'], matching=False)
+        self.expect('type summary list -w system unsigned', substrs=['default', '0-9'], matching=False)
+        self.expect('type summary list -w system char', substrs=['unsigned char *'], matching=True)
diff --git a/packages/Python/lldbsuite/test/functionalities/data-formatter/type_summary_list_script/Makefile b/packages/Python/lldbsuite/test/functionalities/data-formatter/type_summary_list_script/Makefile
new file mode 100644
index 000000000000..314f1cb2f077
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/data-formatter/type_summary_list_script/Makefile
@@ -0,0 +1,5 @@
+LEVEL = ../../../make
+
+CXX_SOURCES := main.cpp
+
+include $(LEVEL)/Makefile.rules
diff --git a/packages/Python/lldbsuite/test/functionalities/data-formatter/type_summary_list_script/TestTypeSummaryListScript.py b/packages/Python/lldbsuite/test/functionalities/data-formatter/type_summary_list_script/TestTypeSummaryListScript.py
new file mode 100644
index 000000000000..63a4a3a4ba8c
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/data-formatter/type_summary_list_script/TestTypeSummaryListScript.py
@@ -0,0 +1,61 @@
+"""
+Test lldb data formatter subsystem.
+"""
+
+from __future__ import print_function
+
+
+
+import os, time
+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+class TypeSummaryListScriptTestCase(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    def test_typesummarylist_script(self):
+        """Test data formatter commands."""
+        self.build()
+        self.data_formatter_commands()
+
+    def setUp(self):
+        # Call super's setUp().
+        TestBase.setUp(self)
+        # Find the line number to break at.
+        self.line = line_number('main.cpp', 'Break here')
+
+    def data_formatter_commands(self):
+        """Test printing out Python summary formatters."""
+        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)
+
+        # The stop reason of the thread should be breakpoint.
+        self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
+            substrs = ['stopped',
+                       'stop reason = breakpoint'])
+
+        # 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 category delete TSLSFormatters', check=False)
+            self.runCmd('type format clear', check=False)
+            self.runCmd('type summary clear', check=False)
+            self.runCmd('type filter clear', check=False)
+            self.runCmd('type synth clear', check=False)
+
+        self.addTearDownHook(cleanup)
+
+        self.runCmd("command script import tslsformatters.py")
+
+        self.expect("frame variable myStruct", substrs=['A data formatter at work'])
+        
+        self.expect('type summary list', substrs=['Struct_SummaryFormatter'])
+        self.expect('type summary list Struct', substrs=['Struct_SummaryFormatter'])
+
+
diff --git a/packages/Python/lldbsuite/test/functionalities/data-formatter/type_summary_list_script/main.cpp b/packages/Python/lldbsuite/test/functionalities/data-formatter/type_summary_list_script/main.cpp
new file mode 100644
index 000000000000..2de37041f263
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/data-formatter/type_summary_list_script/main.cpp
@@ -0,0 +1,15 @@
+#include <stdio.h>
+
+typedef struct Struct
+{
+  int one;
+  int two;
+} Struct;
+
+int
+main()
+{
+  Struct myStruct = {10, 20};
+  printf ("Break here: %d\n.", myStruct.one);
+  return 0;
+}
diff --git a/packages/Python/lldbsuite/test/functionalities/data-formatter/type_summary_list_script/tslsformatters.py b/packages/Python/lldbsuite/test/functionalities/data-formatter/type_summary_list_script/tslsformatters.py
new file mode 100644
index 000000000000..d1ce8b7db17a
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/data-formatter/type_summary_list_script/tslsformatters.py
@@ -0,0 +1,10 @@
+import lldb
+
+def Struct_SummaryFormatter(valobj, internal_dict):
+    return 'A data formatter at work'
+
+category = lldb.debugger.CreateCategory("TSLSFormatters")
+category.SetEnabled(True)
+summary = lldb.SBTypeSummary.CreateWithFunctionName("tslsformatters.Struct_SummaryFormatter", lldb.eTypeOptionCascade)
+spec = lldb.SBTypeNameSpecifier("Struct", False)
+category.AddTypeSummary(spec, summary)
diff --git a/packages/Python/lldbsuite/test/functionalities/data-formatter/typedef_array/TestTypedefArray.py b/packages/Python/lldbsuite/test/functionalities/data-formatter/typedef_array/TestTypedefArray.py
index 30b66e062827..41b8c3499ccd 100644
--- a/packages/Python/lldbsuite/test/functionalities/data-formatter/typedef_array/TestTypedefArray.py
+++ b/packages/Python/lldbsuite/test/functionalities/data-formatter/typedef_array/TestTypedefArray.py
@@ -1,4 +1,4 @@
-import lldbsuite.test.lldbinline as lldbinline
-import lldbsuite.test.lldbtest as lldbtest
+from lldbsuite.test import lldbinline
+from lldbsuite.test import decorators
 
-lldbinline.MakeInlineTest(__file__, globals(), [lldbtest.expectedFailureGcc])
+lldbinline.MakeInlineTest(__file__, globals(), [decorators.expectedFailureAll(compiler="gcc")])
diff --git a/packages/Python/lldbsuite/test/functionalities/data-formatter/varscript_formatting/TestDataFormatterVarScriptFormatting.py b/packages/Python/lldbsuite/test/functionalities/data-formatter/varscript_formatting/TestDataFormatterVarScriptFormatting.py
index 4d060c332f93..f3eced625898 100644
--- a/packages/Python/lldbsuite/test/functionalities/data-formatter/varscript_formatting/TestDataFormatterVarScriptFormatting.py
+++ b/packages/Python/lldbsuite/test/functionalities/data-formatter/varscript_formatting/TestDataFormatterVarScriptFormatting.py
@@ -7,10 +7,11 @@ from __future__ import print_function
 
 
 import os, time
+import os.path
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
-import os.path
+from lldbsuite.test import lldbutil
 
 class PythonSynthDataFormatterTestCase(TestBase):
 
diff --git a/packages/Python/lldbsuite/test/functionalities/data-formatter/vector-types/TestVectorTypesFormatting.py b/packages/Python/lldbsuite/test/functionalities/data-formatter/vector-types/TestVectorTypesFormatting.py
index 05899a24ad22..365ddff3c7e8 100644
--- a/packages/Python/lldbsuite/test/functionalities/data-formatter/vector-types/TestVectorTypesFormatting.py
+++ b/packages/Python/lldbsuite/test/functionalities/data-formatter/vector-types/TestVectorTypesFormatting.py
@@ -8,8 +8,9 @@ from __future__ import print_function
 
 import os, time
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbutil
 
 class VectorTypesFormattingTestCase(TestBase):
 
diff --git a/packages/Python/lldbsuite/test/functionalities/dead-strip/TestDeadStrip.py b/packages/Python/lldbsuite/test/functionalities/dead-strip/TestDeadStrip.py
index f10736bd75c0..efbaa69eef57 100644
--- a/packages/Python/lldbsuite/test/functionalities/dead-strip/TestDeadStrip.py
+++ b/packages/Python/lldbsuite/test/functionalities/dead-strip/TestDeadStrip.py
@@ -8,15 +8,17 @@ from __future__ import print_function
 
 import os, time
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbutil
 
 class DeadStripTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @expectedFailureWindows("llvm.org/pr24778")
-    @expectedFailureDwo("llvm.org/pr25087")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778")
+    @expectedFailureAll(debug_info="dwo", bugnumber="llvm.org/pr25087")
+    @expectedFailureAll(oslist=["linux"], debug_info="gmodules", bugnumber="llvm.org/pr27865")
     @skipIfFreeBSD # The -dead_strip linker option isn't supported on FreeBSD versions of ld.
     def test(self):
         """Test breakpoint works correctly with dead-code stripping."""
diff --git a/packages/Python/lldbsuite/test/functionalities/disassembly/TestDisassembleBreakpoint.py b/packages/Python/lldbsuite/test/functionalities/disassembly/TestDisassembleBreakpoint.py
index df2308de7605..be0ea1441333 100644
--- a/packages/Python/lldbsuite/test/functionalities/disassembly/TestDisassembleBreakpoint.py
+++ b/packages/Python/lldbsuite/test/functionalities/disassembly/TestDisassembleBreakpoint.py
@@ -8,14 +8,15 @@ from __future__ import print_function
 
 import os, time
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbutil
 
 class DisassemblyTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @expectedFailureWindows # Function name prints fully demangled instead of name-only
+    @expectedFailureAll(oslist=["windows"], bugnumber="function names print fully demangled instead of name-only")
     def test(self):
         self.build()
         exe = os.path.join (os.getcwd(), "a.out")
@@ -41,7 +42,10 @@ class DisassemblyTestCase(TestBase):
             instructions = [' add ', ' ldr ', ' str ']
         elif re.match("mips" , arch):
             breakpoint_opcodes = ["break"]
-            instructions = ['lw', 'sw', 'jr']
+            instructions = ['lw', 'sw']
+        elif arch in ["s390x"]:
+            breakpoint_opcodes = [".long"]
+            instructions = [' l ', ' a ', ' st ']
         else:
             # TODO please add your arch here
             self.fail('unimplemented for arch = "{arch}"'.format(arch=self.getArchitecture()))
diff --git a/packages/Python/lldbsuite/test/functionalities/dynamic_value_child_count/TestDynamicValueChildCount.py b/packages/Python/lldbsuite/test/functionalities/dynamic_value_child_count/TestDynamicValueChildCount.py
index ac039990b5bf..37593768f4a8 100644
--- a/packages/Python/lldbsuite/test/functionalities/dynamic_value_child_count/TestDynamicValueChildCount.py
+++ b/packages/Python/lldbsuite/test/functionalities/dynamic_value_child_count/TestDynamicValueChildCount.py
@@ -9,8 +9,9 @@ from __future__ import print_function
 import os, time
 import re
 import lldb
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
 
 class DynamicValueChildCountTestCase(TestBase):
 
@@ -31,11 +32,8 @@ class DynamicValueChildCountTestCase(TestBase):
         self.main_sixth_call_line = line_number('pass-to-base.cpp',
                                                        '// Break here and check b has 0 children again')
 
-    @expectedFailureLinux("llvm.org/pr23039")
-    @expectedFailureFreeBSD("llvm.org/pr19311") # continue at a breakpoint does not work
-    @expectedFailureWindows("llvm.org/pr24663")
-    @expectedFailurei386("to be figured out")
     @add_test_categories(['pyapi'])
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24663")
     def test_get_dynamic_vals(self):
         """Test fetching C++ dynamic values from pointers & references."""
         """Get argument vals for the call stack when stopped on a breakpoint."""
diff --git a/packages/Python/lldbsuite/test/functionalities/embedded_interpreter/TestConvenienceVariables.py b/packages/Python/lldbsuite/test/functionalities/embedded_interpreter/TestConvenienceVariables.py
index eddaa3cc9840..4b1880dee96f 100644
--- a/packages/Python/lldbsuite/test/functionalities/embedded_interpreter/TestConvenienceVariables.py
+++ b/packages/Python/lldbsuite/test/functionalities/embedded_interpreter/TestConvenienceVariables.py
@@ -6,7 +6,9 @@ from __future__ import print_function
 
 import os
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
 
 class ConvenienceVariablesCase(TestBase):
 
@@ -20,7 +22,7 @@ class ConvenienceVariablesCase(TestBase):
 
     @skipIfFreeBSD # llvm.org/pr17228
     @skipIfRemote
-    @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr22274: need a pexpect replacement for windows")
     def test_with_run_commands(self):
         """Test convenience variables lldb.debugger, lldb.target, lldb.process, lldb.thread, and lldb.frame."""
         self.build()
diff --git a/packages/Python/lldbsuite/test/functionalities/exec/TestExec.py b/packages/Python/lldbsuite/test/functionalities/exec/TestExec.py
index 9321a308a83c..912d51fb6b02 100644
--- a/packages/Python/lldbsuite/test/functionalities/exec/TestExec.py
+++ b/packages/Python/lldbsuite/test/functionalities/exec/TestExec.py
@@ -8,9 +8,10 @@ from __future__ import print_function
 import lldb
 import os
 import time
+from lldbsuite.support import seven
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
-import lldbsuite.support.seven as seven
+from lldbsuite.test import lldbutil
 
 def execute_command (command):
     #print('%% %s' % (command))
@@ -55,15 +56,18 @@ class ExecTestCase(TestBase):
             self.assertTrue(process.GetState() == lldb.eStateStopped,
                             STOPPED_DUE_TO_BREAKPOINT)
 
-            thread = process.GetThreadAtIndex (0)
+            threads = lldbutil.get_threads_stopped_at_breakpoint(process, breakpoint)
+            self.assertTrue(len(threads) == 1)
 
-            self.assertTrue (thread.IsValid(),
-                             "Process stopped at 'main' should have a valid thread");
+            # We had a deadlock tearing down the TypeSystemMap on exec, but only if some
+            # expression had been evaluated.  So make sure we do that here so the teardown
+            # is not trivial.
 
-            stop_reason = thread.GetStopReason()
-            
-            self.assertTrue (stop_reason == lldb.eStopReasonBreakpoint,
-                             "Thread in process stopped in 'main' should have a stop reason of eStopReasonBreakpoint");
+            thread = threads[0]
+            value = thread.frames[0].EvaluateExpression("1 + 2")
+            self.assertTrue(value.IsValid(), "Expression evaluated successfully")
+            int_value = value.GetValueAsSigned()
+            self.assertTrue(int_value == 3, "Expression got the right result.")
 
             # Run and we should stop due to exec
             process.Continue()
@@ -71,15 +75,11 @@ class ExecTestCase(TestBase):
             self.assertTrue(process.GetState() == lldb.eStateStopped,
                             "Process should be stopped at __dyld_start")
                         
-            thread = process.GetThreadAtIndex (0)
-        
-            self.assertTrue (thread.IsValid(),
-                             "Process stopped at exec should have a valid thread");
-        
-            stop_reason = thread.GetStopReason()
-        
-            self.assertTrue (stop_reason == lldb.eStopReasonExec,
-                             "Thread in process stopped on exec should have a stop reason of eStopReasonExec");
-        
+            threads = lldbutil.get_stopped_threads(process, lldb.eStopReasonExec)
+            self.assertTrue(len(threads) == 1, "We got a thread stopped for exec.")
+
              # Run and we should stop at breakpoint in main after exec
             process.Continue()        
+
+            threads = lldbutil.get_threads_stopped_at_breakpoint(process, breakpoint)
+            self.assertTrue(len(threads) == 1, "Stopped at breakpoint in exec'ed process.")
diff --git a/packages/Python/lldbsuite/test/functionalities/expr-doesnt-deadlock/TestExprDoesntBlock.py b/packages/Python/lldbsuite/test/functionalities/expr-doesnt-deadlock/TestExprDoesntBlock.py
index a54b45822a6a..1492fe069220 100644
--- a/packages/Python/lldbsuite/test/functionalities/expr-doesnt-deadlock/TestExprDoesntBlock.py
+++ b/packages/Python/lldbsuite/test/functionalities/expr-doesnt-deadlock/TestExprDoesntBlock.py
@@ -9,8 +9,9 @@ from __future__ import print_function
 import os, time
 import re
 import lldb
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
 
 class ExprDoesntDeadlockTestCase(TestBase):
 
@@ -19,9 +20,8 @@ class ExprDoesntDeadlockTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @expectedFailureFreeBSD('llvm.org/pr17946')
-    @expectedFlakeyLinux # failed 1/365 test runs, line 61, thread.IsValid()
-    @expectedFailureWindows # Windows doesn't have pthreads, need to port this test.
+    @expectedFailureAll(oslist=['freebsd'], bugnumber='llvm.org/pr17946')
+    @expectedFailureAll(oslist=["windows"], bugnumber="Windows doesn't have pthreads, test needs to be ported")
     def test_with_run_command(self):
         """Test that expr will time out and allow other threads to run if it blocks."""
         self.build()
diff --git a/packages/Python/lldbsuite/test/functionalities/fat_archives/TestFatArchives.py b/packages/Python/lldbsuite/test/functionalities/fat_archives/TestFatArchives.py
index 19a2dba2109a..6d2763c1ead1 100644
--- a/packages/Python/lldbsuite/test/functionalities/fat_archives/TestFatArchives.py
+++ b/packages/Python/lldbsuite/test/functionalities/fat_archives/TestFatArchives.py
@@ -8,9 +8,10 @@ from __future__ import print_function
 import lldb
 import os
 import time
-from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
 import lldbsuite.support.seven as seven
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
 
 def execute_command (command):
     # print('%% %s' % (command))
diff --git a/packages/Python/lldbsuite/test/functionalities/format/TestFormats.py b/packages/Python/lldbsuite/test/functionalities/format/TestFormats.py
index cc962150bc8c..0ba036124b03 100644
--- a/packages/Python/lldbsuite/test/functionalities/format/TestFormats.py
+++ b/packages/Python/lldbsuite/test/functionalities/format/TestFormats.py
@@ -8,13 +8,15 @@ from __future__ import print_function
 
 import os
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
 
 class TestFormats(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @expectedFailureHostWindows("llvm.org/pr22274: need a pexpect replacement for windows")
+    @expectedFailureAll(hostoslist=["windows"], bugnumber="llvm.org/pr22274: need a pexpect replacement for windows")
     def test_formats(self):
         """Test format string functionality."""
         self.build()
diff --git a/packages/Python/lldbsuite/test/functionalities/inferior-assert/TestInferiorAssert.py b/packages/Python/lldbsuite/test/functionalities/inferior-assert/TestInferiorAssert.py
index 950b021b69ce..ceeb2eadaf4f 100644
--- a/packages/Python/lldbsuite/test/functionalities/inferior-assert/TestInferiorAssert.py
+++ b/packages/Python/lldbsuite/test/functionalities/inferior-assert/TestInferiorAssert.py
@@ -6,55 +6,56 @@ from __future__ import print_function
 
 import os, time
 import lldb
-import lldbsuite.test.lldbutil as lldbutil
-import lldbsuite.test.lldbplatformutil as lldbplatformutil
+from lldbsuite.test import lldbutil
+from lldbsuite.test import lldbplatformutil
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 
 class AssertingInferiorTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @expectedFailureWindows("llvm.org/pr21793: need to implement support for detecting assertion / abort on Windows")
-    @expectedFailurei386("llvm.org/pr25338")
-    @expectedFailureLinux("llvm.org/pr25338", archs=['arm', 'i386'])
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr21793: need to implement support for detecting assertion / abort on Windows")
+    @expectedFailureAll(oslist=["linux"], archs=["arm"], bugnumber="llvm.org/pr25338")
+    @expectedFailureAll(bugnumber="llvm.org/pr26592", triple = '^mips')
     def test_inferior_asserting(self):
         """Test that lldb reliably catches the inferior asserting (command)."""
         self.build()
         self.inferior_asserting()
 
-    @expectedFailureWindows("llvm.org/pr21793: need to implement support for detecting assertion / abort on Windows")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr21793: need to implement support for detecting assertion / abort on Windows")
     @expectedFailureAndroid(api_levels=list(range(16 + 1))) # b.android.com/179836
     def test_inferior_asserting_register(self):
         """Test that lldb reliably reads registers from the inferior after asserting (command)."""
         self.build()
         self.inferior_asserting_registers()
 
-    @expectedFailureWindows("llvm.org/pr21793: need to implement support for detecting assertion / abort on Windows")
-    @expectedFailurei386("llvm.org/pr25338")
-    @expectedFailureLinux("llvm.org/pr25338", archs=['arm', 'i386'])
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr21793: need to implement support for detecting assertion / abort on Windows")
+    @expectedFailureAll(oslist=["linux"], archs=["aarch64", "arm"], bugnumber="llvm.org/pr25338")
+    @expectedFailureAll(bugnumber="llvm.org/pr26592", triple = '^mips')
     def test_inferior_asserting_disassemble(self):
         """Test that lldb reliably disassembles frames after asserting (command)."""
         self.build()
         self.inferior_asserting_disassemble()
 
     @add_test_categories(['pyapi'])
-    @expectedFailureWindows("llvm.org/pr21793: need to implement support for detecting assertion / abort on Windows")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr21793: need to implement support for detecting assertion / abort on Windows")
     def test_inferior_asserting_python(self):
         """Test that lldb reliably catches the inferior asserting (Python API)."""
         self.build()
         self.inferior_asserting_python()
 
-    @expectedFailureWindows("llvm.org/pr21793: need to implement support for detecting assertion / abort on Windows")
-    @expectedFailurei386("llvm.org/pr25338")
-    @expectedFailureLinux("llvm.org/pr25338", archs=['arm', 'i386'])
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr21793: need to implement support for detecting assertion / abort on Windows")
+    @expectedFailureAll(oslist=["linux"], archs=["aarch64", "arm"], bugnumber="llvm.org/pr25338")
+    @expectedFailureAll(bugnumber="llvm.org/pr26592", triple = '^mips')
     def test_inferior_asserting_expr(self):
         """Test that the lldb expression interpreter can read from the inferior after asserting (command)."""
         self.build()
         self.inferior_asserting_expr()
 
-    @expectedFailureWindows("llvm.org/pr21793: need to implement support for detecting assertion / abort on Windows")
-    @expectedFailurei386("llvm.org/pr25338")
-    @expectedFailureLinux("llvm.org/pr25338", archs=['arm', 'i386'])
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr21793: need to implement support for detecting assertion / abort on Windows")
+    @expectedFailureAll(oslist=["linux"], archs=["aarch64", "arm"], bugnumber="llvm.org/pr25338")
+    @expectedFailureAll(bugnumber="llvm.org/pr26592", triple = '^mips')
     def test_inferior_asserting_step(self):
         """Test that lldb functions correctly after stepping through a call to assert()."""
         self.build()
@@ -64,7 +65,8 @@ class AssertingInferiorTestCase(TestBase):
         lldbutil.run_break_set_by_file_and_line (self, "main.c", line, num_expected_locations=1, loc_exact=True)
 
     def check_stop_reason(self):
-        if matchAndroid(api_levels=list(range(1, 16+1)))(self):
+        matched = lldbplatformutil.match_android_device(self.getArchitecture(), valid_api_levels=list(range(1, 16+1)))
+        if matched:
             # On android until API-16 the abort() call ended in a sigsegv instead of in a sigabrt
             stop_reason = 'stop reason = signal SIGSEGV'
         else:
diff --git a/packages/Python/lldbsuite/test/functionalities/inferior-changed/TestInferiorChanged.py b/packages/Python/lldbsuite/test/functionalities/inferior-changed/TestInferiorChanged.py
index 830c7f69355f..359846c314f6 100644
--- a/packages/Python/lldbsuite/test/functionalities/inferior-changed/TestInferiorChanged.py
+++ b/packages/Python/lldbsuite/test/functionalities/inferior-changed/TestInferiorChanged.py
@@ -6,15 +6,17 @@ from __future__ import print_function
 
 import os, time
 import lldb
-from lldbsuite.test import configuration
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import configuration
+from lldbsuite.test import lldbutil
 
 class ChangedInferiorTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @skipIfHostWindows
+    @skipIf(hostoslist=["windows"])
+    @no_debug_info_test
     def test_inferior_crashing(self):
         """Test lldb reloads the inferior after it was changed during the session."""
         self.build()
diff --git a/packages/Python/lldbsuite/test/functionalities/inferior-crashing/TestInferiorCrashing.py b/packages/Python/lldbsuite/test/functionalities/inferior-crashing/TestInferiorCrashing.py
index c547df116c16..fd6a9abce36e 100644
--- a/packages/Python/lldbsuite/test/functionalities/inferior-crashing/TestInferiorCrashing.py
+++ b/packages/Python/lldbsuite/test/functionalities/inferior-crashing/TestInferiorCrashing.py
@@ -6,55 +6,56 @@ from __future__ import print_function
 
 import os, time
 import lldb
-import lldbsuite.test.lldbutil as lldbutil
-import lldbsuite.test.lldbplatformutil as lldbplatformutil
+from lldbsuite.test import lldbutil
+from lldbsuite.test import lldbplatformutil
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 
 class CrashingInferiorTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @expectedFailureFreeBSD("llvm.org/pr23699 SIGSEGV is reported as exception, not signal")
-    @expectedFailureWindows("llvm.org/pr24778") # This actually works, but the test relies on the output format instead of the API
+    @expectedFailureAll(oslist=['freebsd'], bugnumber="llvm.org/pr23699 SIGSEGV is reported as exception, not signal")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778, This actually works, but the test relies on the output format instead of the API")
     def test_inferior_crashing(self):
         """Test that lldb reliably catches the inferior crashing (command)."""
         self.build()
         self.inferior_crashing()
 
-    @expectedFailureWindows("llvm.org/pr24778")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778, This actually works, but the test relies on the output format instead of the API")
     def test_inferior_crashing_register(self):
         """Test that lldb reliably reads registers from the inferior after crashing (command)."""
         self.build()
         self.inferior_crashing_registers()
 
     @add_test_categories(['pyapi'])
-    @expectedFailureWindows("llvm.org/pr24778")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778, This actually works, but the test relies on the output format instead of the API")
     def test_inferior_crashing_python(self):
         """Test that lldb reliably catches the inferior crashing (Python API)."""
         self.build()
         self.inferior_crashing_python()
 
-    @expectedFailureWindows("llvm.org/pr24778")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778, This actually works, but the test relies on the output format instead of the API")
     def test_inferior_crashing_expr(self):
         """Test that the lldb expression interpreter can read from the inferior after crashing (command)."""
         self.build()
         self.inferior_crashing_expr()
 
-    @expectedFailureWindows("llvm.org/pr24778")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778, This actually works, but the test relies on the output format instead of the API")
     def test_inferior_crashing_step(self):
         """Test that stepping after a crash behaves correctly."""
         self.build()
         self.inferior_crashing_step()
 
-    @expectedFailureFreeBSD('llvm.org/pr24939')
-    @expectedFailureWindows("llvm.org/pr24778")
+    @expectedFailureAll(oslist=['freebsd'], bugnumber='llvm.org/pr24939')
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778, This actually works, but the test relies on the output format instead of the API")
     @expectedFailureAndroid(archs=['aarch64'], api_levels=list(range(21 + 1))) # No eh_frame for sa_restorer
     def test_inferior_crashing_step_after_break(self):
         """Test that lldb functions correctly after stepping through a crash."""
         self.build()
         self.inferior_crashing_step_after_break()
 
-    @expectedFailureWindows("llvm.org/pr24778")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778, This actually works, but the test relies on the output format instead of the API")
     @skipIfLinux # Inferior exits after stepping after a segfault. This is working as intended IMHO.
     def test_inferior_crashing_expr_step_and_expr(self):
         """Test that lldb expressions work before and after stepping after a crash."""
diff --git a/packages/Python/lldbsuite/test/functionalities/inferior-crashing/recursive-inferior/TestRecursiveInferior.py b/packages/Python/lldbsuite/test/functionalities/inferior-crashing/recursive-inferior/TestRecursiveInferior.py
index 8afc81f6892a..0d1992d7b4b1 100644
--- a/packages/Python/lldbsuite/test/functionalities/inferior-crashing/recursive-inferior/TestRecursiveInferior.py
+++ b/packages/Python/lldbsuite/test/functionalities/inferior-crashing/recursive-inferior/TestRecursiveInferior.py
@@ -6,57 +6,57 @@ from __future__ import print_function
 
 import os, time
 import lldb
-import lldbsuite.test.lldbutil as lldbutil
-import lldbsuite.test.lldbplatformutil as lldbplatformutil
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbplatformutil
+from lldbsuite.test import lldbutil
 
 class CrashingRecursiveInferiorTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @expectedFailureFreeBSD("llvm.org/pr23699 SIGSEGV is reported as exception, not signal")
-    @expectedFailureWindows("llvm.org/pr24778")
+    @expectedFailureAll(oslist=['freebsd'], bugnumber="llvm.org/pr23699 SIGSEGV is reported as exception, not signal")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778")
     def test_recursive_inferior_crashing(self):
         """Test that lldb reliably catches the inferior crashing (command)."""
         self.build()
         self.recursive_inferior_crashing()
 
-    @expectedFailureWindows("llvm.org/pr24778")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778")
     def test_recursive_inferior_crashing_register(self):
         """Test that lldb reliably reads registers from the inferior after crashing (command)."""
         self.build()
         self.recursive_inferior_crashing_registers()
 
     @add_test_categories(['pyapi'])
-    @expectedFailureWindows("llvm.org/pr24778")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778")
     def test_recursive_inferior_crashing_python(self):
         """Test that lldb reliably catches the inferior crashing (Python API)."""
         self.build()
         self.recursive_inferior_crashing_python()
 
-    @expectedFailureWindows("llvm.org/pr24778")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778")
     def test_recursive_inferior_crashing_expr(self):
         """Test that the lldb expression interpreter can read from the inferior after crashing (command)."""
         self.build()
         self.recursive_inferior_crashing_expr()
 
-    @expectedFailureWindows("llvm.org/pr24778")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778")
     def test_recursive_inferior_crashing_step(self):
         """Test that stepping after a crash behaves correctly."""
         self.build()
         self.recursive_inferior_crashing_step()
 
-    @expectedFailureFreeBSD('llvm.org/pr24939')
-    @expectedFailureWindows("llvm.org/pr24778")
+    @expectedFailureAll(oslist=['freebsd'], bugnumber='llvm.org/pr24939')
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778")
     @expectedFailureAndroid(archs=['aarch64'], api_levels=list(range(21 + 1))) # No eh_frame for sa_restorer
     def test_recursive_inferior_crashing_step_after_break(self):
         """Test that lldb functions correctly after stepping through a crash."""
         self.build()
         self.recursive_inferior_crashing_step_after_break()
 
-    @expectedFailureFreeBSD('llvm.org/pr15989') # Couldn't allocate space for the stack frame
     @skipIfLinux # Inferior exits after stepping after a segfault. This is working as intended IMHO.
-    @expectedFailureWindows("llvm.org/pr24778")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778")
     def test_recursive_inferior_crashing_expr_step_and_expr(self):
         """Test that lldb expressions work before and after stepping after a crash."""
         self.build()
diff --git a/packages/Python/lldbsuite/test/functionalities/inline-stepping/TestInlineStepping.py b/packages/Python/lldbsuite/test/functionalities/inline-stepping/TestInlineStepping.py
index 023f6f31e395..8257106888d6 100644
--- a/packages/Python/lldbsuite/test/functionalities/inline-stepping/TestInlineStepping.py
+++ b/packages/Python/lldbsuite/test/functionalities/inline-stepping/TestInlineStepping.py
@@ -6,18 +6,16 @@ from __future__ import print_function
 
 import os, time, sys
 import lldb
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
 
 class TestInlineStepping(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @add_test_categories(['pyapi'])
-    @expectedFailureFreeBSD('llvm.org/pr17214')
-    @expectedFailureIcc # Not really a bug.  ICC combines two inlined functions.
-    # failed 1/365 dosep runs, (i386-clang), TestInlineStepping.py:237 failed to stop at first breakpoint in main
-    @expectedFailureAll(oslist=["linux"], archs=["i386"])
+    @expectedFailureAll(compiler="icc", bugnumber="# Not really a bug.  ICC combines two inlined functions.")
     def test_with_python_api(self):
         """Test stepping over and into inlined functions."""
         self.build()
diff --git a/packages/Python/lldbsuite/test/functionalities/jitloader_gdb/TestJITLoaderGDB.py b/packages/Python/lldbsuite/test/functionalities/jitloader_gdb/TestJITLoaderGDB.py
index c7abf3464412..336260a8e4a3 100644
--- a/packages/Python/lldbsuite/test/functionalities/jitloader_gdb/TestJITLoaderGDB.py
+++ b/packages/Python/lldbsuite/test/functionalities/jitloader_gdb/TestJITLoaderGDB.py
@@ -2,13 +2,12 @@
 
 from __future__ import print_function
 
-
-
 import unittest2
 import os
 import lldb
+from lldbsuite.test import lldbutil
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
 import re
 
 
@@ -16,7 +15,7 @@ class JITLoaderGDBTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @skipTestIfFn(lambda x: True, "llvm.org/pr24702", "Skipped because the test crashes the test runner")
+    @skipTestIfFn(lambda : "Skipped because the test crashes the test runner", bugnumber="llvm.org/pr24702")
     @unittest2.expectedFailure("llvm.org/pr24702")
     def test_bogus_values(self):
         """Test that we handle inferior misusing the GDB JIT interface"""
diff --git a/packages/Python/lldbsuite/test/functionalities/launch_with_shellexpand/TestLaunchWithShellExpand.py b/packages/Python/lldbsuite/test/functionalities/launch_with_shellexpand/TestLaunchWithShellExpand.py
index 8f712dc21110..28d8cccacfcf 100644
--- a/packages/Python/lldbsuite/test/functionalities/launch_with_shellexpand/TestLaunchWithShellExpand.py
+++ b/packages/Python/lldbsuite/test/functionalities/launch_with_shellexpand/TestLaunchWithShellExpand.py
@@ -8,16 +8,15 @@ from __future__ import print_function
 import lldb
 import os
 import time
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbutil
 
 class LaunchWithShellExpandTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @expectedFailureFreeBSD("llvm.org/pr22627 process launch w/ shell expansion not working")
-    @expectedFailureLinux("llvm.org/pr22627 process launch w/ shell expansion not working")
-    @expectedFailureWindows("llvm.org/pr24778")
+    @expectedFailureAll(oslist=["windows", "linux", "freebsd"], bugnumber="llvm.org/pr24778 llvm.org/pr22627")
     def test(self):
         self.build()
         exe = os.path.join (os.getcwd(), "a.out")
@@ -31,7 +30,7 @@ class LaunchWithShellExpandTestCase(TestBase):
         breakpoint = target.BreakpointCreateBySourceRegex ('break here', lldb.SBFileSpec ("main.cpp", False))
         self.assertTrue(breakpoint, VALID_BREAKPOINT)
 
-        self.runCmd("process launch -X true -w %s -- fi*.tx?" % (os.getcwd()))
+        self.runCmd("process launch -X true -w %s -- fi*.tx? () > <" % (os.getcwd()))
 
         process = self.process()
 
@@ -52,7 +51,11 @@ class LaunchWithShellExpandTestCase(TestBase):
         self.expect("frame variable argv[2]", substrs=['file2.txt'])
         self.expect("frame variable argv[3]", substrs=['file3.txt'])
         self.expect("frame variable argv[4]", substrs=['file4.txy'])
+        self.expect("frame variable argv[5]", substrs=['()'])
+        self.expect("frame variable argv[6]", substrs=['>'])
+        self.expect("frame variable argv[7]", substrs=['<'])
         self.expect("frame variable argv[5]", substrs=['file5.tyx'], matching=False)
+        self.expect("frame variable argv[8]", substrs=['file5.tyx'], matching=False)
 
         self.runCmd("process kill")
 
diff --git a/packages/Python/lldbsuite/test/functionalities/llvm/TestLLVM.py b/packages/Python/lldbsuite/test/functionalities/llvm/TestLLVM.py
new file mode 100644
index 000000000000..a2a43bf2fabd
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/llvm/TestLLVM.py
@@ -0,0 +1,60 @@
+"""
+Test lldb 'commands regex' command which allows the user to create a regular expression command.
+"""
+
+from __future__ import print_function
+
+
+
+import os
+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+class TestHomeDirectory(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    @expectedFailureAll(hostoslist=["windows"], bugnumber="llvm.org/pr22274: need a pexpect replacement for windows")
+    @no_debug_info_test
+    def test_tilde_home_directory(self):
+        """Test that we can resolve "~/" in paths correctly. 
+        When a path starts with "~/", we use llvm::sys::path::home_directory() to
+        resolve the home directory. This currently relies on "HOME" being set in the
+        environment. While this is usually set, we can't rely upon that. We might 
+        eventually get a fix into llvm::sys::path::home_directory() so it doesn't rely
+        on having to have an environment variable set, but until then we have work around
+        code in FileSpec::ResolveUsername (llvm::SmallVectorImpl<char> &path) to ensure
+        this always works. This test tests that we get the correct answer for with and
+        without "HOME" being set in the environment."""
+        import pexpect
+        prompt = "(lldb) "
+
+        child = pexpect.spawn('%s --no-use-colors %s' % (lldbtest_config.lldbExec, self.lldbOption))
+        # Turn on logging for what the child sends back.
+        if self.TraceOn():
+            child.logfile_read = sys.stdout
+        # So that the spawned lldb session gets shutdown durng teardown.
+        self.child = child
+
+        # Resolve "~/." to the full path of our home directory + "/."
+        if 'HOME' in os.environ: 
+            home_dir = os.environ['HOME']
+            if self.TraceOn():
+                print("home directory is: '%s'" % (home_dir))
+            if os.path.exists(home_dir):
+                home_dir_slash_dot = home_dir + '/.'
+                child.expect_exact(prompt)
+                child.sendline('''script str(lldb.SBFileSpec("~/.", True))''')
+                child.expect_exact(home_dir)
+                child.expect_exact(prompt)
+                child.sendline('''script import os; os.unsetenv('HOME'); str(lldb.SBFileSpec("~/", True))''');
+                child.expect_exact(home_dir)
+                child.expect_exact(prompt)
+            elif self.TraceOn():
+                print('''home directory "%s" doesn't exist, skipping home directory test''' % (home_dir))
+        elif self.TraceOn():
+            print('"HOME" not in environment, skipping home directory test')
+
+        child.sendline('quit')
diff --git a/packages/Python/lldbsuite/test/functionalities/load_unload/TestLoadUnload.py b/packages/Python/lldbsuite/test/functionalities/load_unload/TestLoadUnload.py
index 481e7c887bd0..3a703b2ee04e 100644
--- a/packages/Python/lldbsuite/test/functionalities/load_unload/TestLoadUnload.py
+++ b/packages/Python/lldbsuite/test/functionalities/load_unload/TestLoadUnload.py
@@ -9,8 +9,9 @@ from __future__ import print_function
 import os, time
 import re
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbutil
 
 @skipIfWindows # Windows doesn't have dlopen and friends, dynamic libraries work differently
 class LoadUnloadTestCase(TestBase):
@@ -125,7 +126,6 @@ class LoadUnloadTestCase(TestBase):
             substrs = [new_dylib])
 
     @skipIfFreeBSD # llvm.org/pr14424 - missing FreeBSD Makefiles/testcase support
-    @skipUnlessListedRemote(['android'])
     @expectedFailureAndroid # wrong source file shows up for hidden library
     @skipIfWindows # Windows doesn't have dlopen and friends, dynamic libraries work differently
     def test_dyld_library_path(self):
@@ -182,7 +182,6 @@ class LoadUnloadTestCase(TestBase):
 
     @expectedFailureAll(bugnumber="llvm.org/pr25805", hostoslist=["windows"], compiler="gcc", archs=["i386"], triple='.*-android')
     @skipIfFreeBSD # llvm.org/pr14424 - missing FreeBSD Makefiles/testcase support
-    @skipUnlessListedRemote(['android'])
     @skipIfWindows # Windows doesn't have dlopen and friends, dynamic libraries work differently
     def test_lldb_process_load_and_unload_commands(self):
         """Test that lldb process load/unload command work correctly."""
@@ -241,7 +240,6 @@ class LoadUnloadTestCase(TestBase):
         self.runCmd("process continue")
 
     @skipIfFreeBSD # llvm.org/pr14424 - missing FreeBSD Makefiles/testcase support
-    @skipUnlessListedRemote(['android'])
     def test_load_unload(self):
         """Test breakpoint by name works correctly with dlopen'ing."""
 
@@ -283,7 +281,6 @@ class LoadUnloadTestCase(TestBase):
             substrs = [' resolved, hit count = 2'])
 
     @skipIfFreeBSD # llvm.org/pr14424 - missing FreeBSD Makefiles/testcase support
-    @skipUnlessListedRemote(['android'])
     @skipIfWindows # Windows doesn't have dlopen and friends, dynamic libraries work differently
     def test_step_over_load (self):
         """Test stepping over code that loads a shared library works correctly."""
@@ -313,7 +310,6 @@ class LoadUnloadTestCase(TestBase):
                       'stop reason = step over'])
 
     @skipIfFreeBSD # llvm.org/pr14424 - missing FreeBSD Makefiles/testcase support
-    @skipUnlessListedRemote(['android'])
     @skipIfWindows # Windows doesn't have dlopen and friends, dynamic libraries work differently
     @unittest2.expectedFailure("llvm.org/pr25806")
     def test_static_init_during_load (self):
diff --git a/packages/Python/lldbsuite/test/functionalities/longjmp/TestLongjmp.py b/packages/Python/lldbsuite/test/functionalities/longjmp/TestLongjmp.py
index 1316a01c924c..d9f2b2231895 100644
--- a/packages/Python/lldbsuite/test/functionalities/longjmp/TestLongjmp.py
+++ b/packages/Python/lldbsuite/test/functionalities/longjmp/TestLongjmp.py
@@ -8,8 +8,9 @@ from __future__ import print_function
 
 import os
 import lldb
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
 
 class LongjmpTestCase(TestBase):
 
@@ -20,8 +21,8 @@ class LongjmpTestCase(TestBase):
 
     @skipIfDarwin # llvm.org/pr16769: LLDB on Mac OS X dies in function ReadRegisterBytes in GDBRemoteRegisterContext.cpp
     @skipIfFreeBSD # llvm.org/pr17214
-    @expectedFailureLinux("llvm.org/pr20231")
-    @expectedFailureWindows("llvm.org/pr24778")
+    @expectedFailureAll(oslist=["linux"], bugnumber="llvm.org/pr20231")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778")
     def test_step_out(self):
         """Test stepping when the inferior calls setjmp/longjmp, in particular, thread step-out."""
         self.build()
@@ -29,8 +30,8 @@ class LongjmpTestCase(TestBase):
 
     @skipIfDarwin # llvm.org/pr16769: LLDB on Mac OS X dies in function ReadRegisterBytes in GDBRemoteRegisterContext.cpp
     @skipIfFreeBSD # llvm.org/pr17214
-    @expectedFailureLinux("llvm.org/pr20231")
-    @expectedFailureWindows("llvm.org/pr24778")
+    @expectedFailureAll(oslist=["linux"], bugnumber="llvm.org/pr20231")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778")
     def test_step_over(self):
         """Test stepping when the inferior calls setjmp/longjmp, in particular, thread step-over a longjmp."""
         self.build()
@@ -38,8 +39,8 @@ class LongjmpTestCase(TestBase):
 
     @skipIfDarwin # llvm.org/pr16769: LLDB on Mac OS X dies in function ReadRegisterBytes in GDBRemoteRegisterContext.cpp
     @skipIfFreeBSD # llvm.org/pr17214
-    @expectedFailureLinux("llvm.org/pr20231")
-    @expectedFailureWindows("llvm.org/pr24778")
+    @expectedFailureAll(oslist=["linux"], bugnumber="llvm.org/pr20231")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778")
     def test_step_back_out(self):
         """Test stepping when the inferior calls setjmp/longjmp, in particular, thread step-out after thread step-in."""
         self.build()
diff --git a/packages/Python/lldbsuite/test/functionalities/memory/cache/Makefile b/packages/Python/lldbsuite/test/functionalities/memory/cache/Makefile
new file mode 100644
index 000000000000..314f1cb2f077
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/memory/cache/Makefile
@@ -0,0 +1,5 @@
+LEVEL = ../../../make
+
+CXX_SOURCES := main.cpp
+
+include $(LEVEL)/Makefile.rules
diff --git a/packages/Python/lldbsuite/test/functionalities/memory/cache/TestMemoryCache.py b/packages/Python/lldbsuite/test/functionalities/memory/cache/TestMemoryCache.py
new file mode 100644
index 000000000000..a65882d3fa43
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/memory/cache/TestMemoryCache.py
@@ -0,0 +1,64 @@
+"""
+Test the MemoryCache L1 flush.
+"""
+
+from __future__ import print_function
+
+
+
+import os, time
+import re
+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+import lldbsuite.test.lldbutil as lldbutil
+
+class MemoryCacheTestCase(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    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.')
+
+    @expectedFlakeyOS(oslist=["windows"])
+    def test_memory_cache(self):
+        """Test the MemoryCache class with a sequence of 'memory read' and 'memory write' operations."""
+        self.build()
+        exe = os.path.join(os.getcwd(), "a.out")
+        self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
+
+        # Break in main() after the variables are assigned values.
+        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)
+
+        # The stop reason of the thread should be breakpoint.
+        self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
+            substrs = ['stopped', 'stop reason = breakpoint'])
+
+        # The breakpoint should have a hit count of 1.
+        self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
+            substrs = [' resolved, hit count = 1'])
+
+        # Read a chunk of memory containing &my_ints[0]. The number of bytes read
+        # must be greater than m_L2_cache_line_byte_size to make sure the L1
+        # cache is used.
+        self.runCmd('memory read -f d -c 201 `&my_ints - 100`')
+
+        # Check the value of my_ints[0] is the same as set in main.cpp.
+        line = self.res.GetOutput().splitlines()[100]
+        self.assertTrue(0x00000042 == int(line.split(':')[1], 0))
+
+        # Change the value of my_ints[0] in memory.
+        self.runCmd("memory write -s 4 `&my_ints` AA")
+
+        # Re-read the chunk of memory. The cache line should have been
+        # flushed because of the 'memory write'.
+        self.runCmd('memory read -f d -c 201 `&my_ints - 100`')
+
+        # Check the value of my_ints[0] have been updated correctly.
+        line = self.res.GetOutput().splitlines()[100]
+        self.assertTrue(0x000000AA == int(line.split(':')[1], 0))
diff --git a/packages/Python/lldbsuite/test/functionalities/memory/cache/main.cpp b/packages/Python/lldbsuite/test/functionalities/memory/cache/main.cpp
new file mode 100644
index 000000000000..7f25e2f4bf68
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/memory/cache/main.cpp
@@ -0,0 +1,14 @@
+//===-- main.cpp ------------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+int main ()
+{
+    int my_ints[] = {0x42};
+    return 0; // Set break point at this line.
+}
diff --git a/packages/Python/lldbsuite/test/functionalities/multidebugger_commands/TestMultipleDebuggersCommands.py b/packages/Python/lldbsuite/test/functionalities/multidebugger_commands/TestMultipleDebuggersCommands.py
new file mode 100644
index 000000000000..7d959ec504c8
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/multidebugger_commands/TestMultipleDebuggersCommands.py
@@ -0,0 +1,48 @@
+"""
+Test that commands do not try and hold on to stale CommandInterpreters in a multiple debuggers scenario
+"""
+
+from __future__ import print_function
+
+
+
+import os, time
+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+class MultipleDebuggersCommandsTestCase(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    @no_debug_info_test
+    def test_multipledebuggers_commands(self):
+        """Test that commands do not try and hold on to stale CommandInterpreters in a multiple debuggers scenario"""
+        source_init_files = False
+        magic_text = "The following commands may relate to 'env'"
+        
+        debugger_1 = lldb.SBDebugger.Create(source_init_files)
+        interpreter_1 = debugger_1.GetCommandInterpreter()
+        
+        retobj = lldb.SBCommandReturnObject()
+        interpreter_1.HandleCommand("apropos env", retobj)
+        self.assertTrue(magic_text in str(retobj), "[interpreter_1]: the output does not contain the correct words")
+        
+        if self.TraceOn(): print(str(retobj))
+        
+        lldb.SBDebugger.Destroy(debugger_1)
+        
+        # now do this again with a different debugger - we shouldn't crash
+        
+        debugger_2 = lldb.SBDebugger.Create(source_init_files)
+        interpreter_2 = debugger_2.GetCommandInterpreter()
+        
+        retobj = lldb.SBCommandReturnObject()
+        interpreter_2.HandleCommand("apropos env", retobj)
+        self.assertTrue(magic_text in str(retobj), "[interpreter_2]: the output does not contain the correct words")
+        
+        if self.TraceOn(): print(str(retobj))
+        
+        lldb.SBDebugger.Destroy(debugger_2)
+        
diff --git a/packages/Python/lldbsuite/test/functionalities/nested_alias/Makefile b/packages/Python/lldbsuite/test/functionalities/nested_alias/Makefile
new file mode 100644
index 000000000000..8a7102e347af
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/nested_alias/Makefile
@@ -0,0 +1,5 @@
+LEVEL = ../../make
+
+CXX_SOURCES := main.cpp
+
+include $(LEVEL)/Makefile.rules
diff --git a/packages/Python/lldbsuite/test/functionalities/nested_alias/TestNestedAlias.py b/packages/Python/lldbsuite/test/functionalities/nested_alias/TestNestedAlias.py
new file mode 100644
index 000000000000..6a74ddb727df
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/nested_alias/TestNestedAlias.py
@@ -0,0 +1,68 @@
+"""
+Test that an alias can reference other aliases without crashing.
+"""
+
+from __future__ import print_function
+
+
+
+import os, time
+import re
+import lldb
+from lldbsuite.test.lldbtest import *
+import lldbsuite.test.lldbutil as lldbutil
+
+class NestedAliasTestCase(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    def setUp(self):
+        # Call super's setUp().
+        TestBase.setUp(self)
+        # Find the line number to break inside main().
+        self.line = line_number('main.cpp', '// break here')
+
+    def test_nested_alias(self):
+        """Test that an alias can reference other aliases without crashing."""
+        self.build()
+        exe = os.path.join(os.getcwd(), "a.out")
+        self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
+
+        # Break in main() aftre the variables are assigned values.
+        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)
+
+        # The stop reason of the thread should be breakpoint.
+        self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
+            substrs = ['stopped', 'stop reason = breakpoint'])
+
+        # The breakpoint should have a hit count of 1.
+        self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
+            substrs = [' resolved, hit count = 1'])
+
+        # This is the function to remove the custom aliases in order to have a
+        # clean slate for the next test case.
+        def cleanup():
+            self.runCmd('command unalias read', check=False)
+            self.runCmd('command unalias rd', check=False)
+            self.runCmd('command unalias fo', check=False)
+            self.runCmd('command unalias foself', check=False)
+
+        # Execute the cleanup function during test case tear down.
+        self.addTearDownHook(cleanup)
+
+        self.runCmd('command alias read memory read -f A')
+        self.runCmd('command alias rd read -c 3')
+        
+        self.expect('memory read -f A -c 3 `&my_ptr[0]`', substrs=['deadbeef', 'main.cpp:', 'feedbeef'])
+        self.expect('rd `&my_ptr[0]`', substrs=['deadbeef', 'main.cpp:', 'feedbeef'])
+
+        self.expect('memory read -f A -c 3 `&my_ptr[0]`', substrs=['deadfeed'], matching=False)
+        self.expect('rd `&my_ptr[0]`', substrs=['deadfeed'], matching=False)
+
+        self.runCmd('command alias fo frame variable -O --')
+        self.runCmd('command alias foself fo self')
+        
+        self.expect('help foself', substrs=['--show-all-children', '--raw-output'], matching=False)
+        self.expect('help foself', substrs=['Show variables for the current', 'stack frame.'], matching=True)
diff --git a/packages/Python/lldbsuite/test/functionalities/nested_alias/main.cpp b/packages/Python/lldbsuite/test/functionalities/nested_alias/main.cpp
new file mode 100644
index 000000000000..4424cf30c3a4
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/nested_alias/main.cpp
@@ -0,0 +1,22 @@
+//===-- main.cpp ------------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#include <stdio.h>
+
+int main (int argc, char const *argv[])
+{
+  void* my_ptr[] = {
+    reinterpret_cast<void*>(0xDEADBEEF),
+    reinterpret_cast<void*>(main),
+    reinterpret_cast<void*>(0xFEEDBEEF),
+    reinterpret_cast<void*>(0xFEEDDEAD),
+    reinterpret_cast<void*>(0xDEADFEED)
+  };
+  return 0; // break here
+}
+
diff --git a/packages/Python/lldbsuite/test/functionalities/object-file/TestImageListMultiArchitecture.py b/packages/Python/lldbsuite/test/functionalities/object-file/TestImageListMultiArchitecture.py
index 4f4a22ed6067..0fdc43bb9feb 100644
--- a/packages/Python/lldbsuite/test/functionalities/object-file/TestImageListMultiArchitecture.py
+++ b/packages/Python/lldbsuite/test/functionalities/object-file/TestImageListMultiArchitecture.py
@@ -9,16 +9,19 @@ from __future__ import print_function
 
 
 import os.path
+import re
+
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
-import re
+from lldbsuite.test import lldbutil
 
 class TestImageListMultiArchitecture(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @no_debug_info_test
+    @skipIfRemote
     def test_image_list_shows_multiple_architectures(self):
         """Test that image list properly shows the correct architecture for a set of different architecture object files."""
         images = {
diff --git a/packages/Python/lldbsuite/test/functionalities/paths/TestPaths.py b/packages/Python/lldbsuite/test/functionalities/paths/TestPaths.py
index f718b62f95ea..db577dc5bacd 100644
--- a/packages/Python/lldbsuite/test/functionalities/paths/TestPaths.py
+++ b/packages/Python/lldbsuite/test/functionalities/paths/TestPaths.py
@@ -8,8 +8,9 @@ from __future__ import print_function
 import lldb
 import os
 import time
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbutil
 
 class TestPaths(TestBase):
 
diff --git a/packages/Python/lldbsuite/test/functionalities/platform/TestPlatformCommand.py b/packages/Python/lldbsuite/test/functionalities/platform/TestPlatformCommand.py
index 6b3eedaf603a..9599f83d6a53 100644
--- a/packages/Python/lldbsuite/test/functionalities/platform/TestPlatformCommand.py
+++ b/packages/Python/lldbsuite/test/functionalities/platform/TestPlatformCommand.py
@@ -8,7 +8,9 @@ from __future__ import print_function
 
 import os, time
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
 
 class PlatformCommandTestCase(TestBase):
 
diff --git a/packages/Python/lldbsuite/test/functionalities/plugins/commands/TestPluginCommands.py b/packages/Python/lldbsuite/test/functionalities/plugins/commands/TestPluginCommands.py
index b62c30bcf4e7..619ed7afe328 100644
--- a/packages/Python/lldbsuite/test/functionalities/plugins/commands/TestPluginCommands.py
+++ b/packages/Python/lldbsuite/test/functionalities/plugins/commands/TestPluginCommands.py
@@ -9,8 +9,9 @@ from __future__ import print_function
 import os, time
 import re
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbutil
 
 class PluginCommandTestCase(TestBase):
 
@@ -18,7 +19,7 @@ class PluginCommandTestCase(TestBase):
 
     @skipIfNoSBHeaders
     @skipIfHostIncompatibleWithRemote # Requires a compatible arch and platform to link against the host's built lldb lib.
-    @expectedFailureWindows("llvm.org/pr24778")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778")
     @no_debug_info_test
     def test_load_plugin(self):
         """Test that plugins that load commands work correctly."""
diff --git a/packages/Python/lldbsuite/test/functionalities/postmortem/linux-core/TestLinuxCore.py b/packages/Python/lldbsuite/test/functionalities/postmortem/linux-core/TestLinuxCore.py
new file mode 100644
index 000000000000..fd5bb00d0565
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/postmortem/linux-core/TestLinuxCore.py
@@ -0,0 +1,164 @@
+"""
+Test basics of linux core file debugging.
+"""
+
+from __future__ import print_function
+
+import shutil
+import struct
+
+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+class LinuxCoreTestCase(TestBase):
+    NO_DEBUG_INFO_TESTCASE = True
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    _i386_pid   = 32306
+    _x86_64_pid = 32259
+    _s390x_pid  = 1045
+
+    _i386_regions   = 4
+    _x86_64_regions = 5
+    _s390x_regions  = 2
+
+    @skipIf(bugnumber="llvm.org/pr26947")
+    def test_i386(self):
+        """Test that lldb can read the process information from an i386 linux core file."""
+        self.do_test("i386", self._i386_pid, self._i386_regions)
+
+    def test_x86_64(self):
+        """Test that lldb can read the process information from an x86_64 linux core file."""
+        self.do_test("x86_64", self._x86_64_pid, self._x86_64_regions)
+
+    # This seems to hang on non-s390x platforms for some reason.  Disabling for now.
+    @skipIf(archs=no_match(['s390x'])) 
+    def test_s390x(self):
+        """Test that lldb can read the process information from an s390x linux core file."""
+        self.do_test("s390x", self._s390x_pid, self._s390x_regions)
+
+    def test_same_pid_running(self):
+        """Test that we read the information from the core correctly even if we have a running
+        process with the same PID around"""
+        try:
+            shutil.copyfile("x86_64.out",  "x86_64-pid.out")
+            shutil.copyfile("x86_64.core", "x86_64-pid.core")
+            with open("x86_64-pid.core", "r+b") as f:
+                # These are offsets into the NT_PRSTATUS and NT_PRPSINFO structures in the note
+                # segment of the core file. If you update the file, these offsets may need updating
+                # as well. (Notes can be viewed with readelf --notes.)
+                for pid_offset in [0x1c4, 0x320]:
+                    f.seek(pid_offset)
+                    self.assertEqual(struct.unpack("<I", f.read(4))[0], self._x86_64_pid)
+
+                    # We insert our own pid, and make sure the test still works.
+                    f.seek(pid_offset)
+                    f.write(struct.pack("<I", os.getpid()))
+            self.do_test("x86_64-pid", os.getpid(), self._x86_64_regions)
+        finally:
+            self.RemoveTempFile("x86_64-pid.out")
+            self.RemoveTempFile("x86_64-pid.core")
+
+    def test_two_cores_same_pid(self):
+        """Test that we handle the situation if we have two core files with the same PID
+        around"""
+        alttarget = self.dbg.CreateTarget("altmain.out")
+        altprocess = alttarget.LoadCore("altmain.core")
+        self.assertTrue(altprocess, PROCESS_IS_VALID)
+        self.assertEqual(altprocess.GetNumThreads(), 1)
+        self.assertEqual(altprocess.GetProcessID(), self._x86_64_pid)
+
+        altframe = altprocess.GetSelectedThread().GetFrameAtIndex(0)
+        self.assertEqual(altframe.GetFunctionName(), "_start")
+        self.assertEqual(altframe.GetLineEntry().GetLine(), line_number("altmain.c", "Frame _start"))
+
+        error = lldb.SBError()
+        F = altprocess.ReadCStringFromMemory(altframe.FindVariable("F").GetValueAsUnsigned(), 256, error)
+        self.assertTrue(error.Success())
+        self.assertEqual(F, "_start")
+
+        # without destroying this process, run the test which opens another core file with the
+        # same pid
+        self.do_test("x86_64", self._x86_64_pid, self._x86_64_regions)
+
+    def check_memory_regions(self, process, region_count):
+        region_list = process.GetMemoryRegions()
+        self.assertEqual(region_list.GetSize(), region_count)
+
+        region = lldb.SBMemoryRegionInfo()
+
+        # Check we have the right number of regions.
+        self.assertEqual(region_list.GetSize(), region_count);
+
+        # Check that getting a region beyond the last in the list fails.
+        self.assertFalse(region_list.GetMemoryRegionAtIndex(region_count, region));
+
+        # Check each region is valid.
+        for i in range(region_list.GetSize()):
+            # Check we can actually get this region.
+            self.assertTrue(region_list.GetMemoryRegionAtIndex(i, region))
+
+            #Every region in the list should be mapped.
+            self.assertTrue(region.IsMapped())
+
+            # Test the address at the start of a region returns it's enclosing region.
+            begin_address = region.GetRegionBase()
+            region_at_begin = lldb.SBMemoryRegionInfo()
+            error = process.GetMemoryRegionInfo(begin_address, region_at_begin)
+            self.assertEqual(region, region_at_begin)
+
+            # Test an address in the middle of a region returns it's enclosing region.
+            middle_address = (region.GetRegionBase() + region.GetRegionEnd()) / 2l
+            region_at_middle = lldb.SBMemoryRegionInfo()
+            error = process.GetMemoryRegionInfo(middle_address, region_at_middle)
+            self.assertEqual(region, region_at_middle)
+
+            # Test the address at the end of a region returns it's enclosing region.
+            end_address = region.GetRegionEnd() - 1l
+            region_at_end = lldb.SBMemoryRegionInfo()
+            error = process.GetMemoryRegionInfo(end_address, region_at_end)
+            self.assertEqual(region, region_at_end)
+
+            # Check that quering the end address does not return this region but
+            # the next one.
+            next_region = lldb.SBMemoryRegionInfo()
+            error = process.GetMemoryRegionInfo(region.GetRegionEnd(), next_region)
+            self.assertNotEqual(region, next_region)
+            self.assertEqual(region.GetRegionEnd(), next_region.GetRegionBase())
+
+        # Check that query beyond the last region returns an unmapped region
+        # that ends at LLDB_INVALID_ADDRESS
+        last_region = lldb.SBMemoryRegionInfo()
+        region_list.GetMemoryRegionAtIndex(region_count - 1, last_region)
+        end_region = lldb.SBMemoryRegionInfo()
+        error = process.GetMemoryRegionInfo(last_region.GetRegionEnd(), end_region)
+        self.assertFalse(end_region.IsMapped())
+        self.assertEqual(last_region.GetRegionEnd(), end_region.GetRegionBase())
+        self.assertEqual(end_region.GetRegionEnd(), lldb.LLDB_INVALID_ADDRESS)
+
+    def do_test(self, filename, pid, region_count):
+        target = self.dbg.CreateTarget(filename + ".out")
+        process = target.LoadCore(filename + ".core")
+        self.assertTrue(process, PROCESS_IS_VALID)
+        self.assertEqual(process.GetNumThreads(), 1)
+        self.assertEqual(process.GetProcessID(), pid)
+
+        thread = process.GetSelectedThread()
+        self.assertTrue(thread)
+        self.assertEqual(thread.GetThreadID(), pid)
+        backtrace = ["bar", "foo", "_start"]
+        self.assertEqual(thread.GetNumFrames(), len(backtrace))
+        for i in range(len(backtrace)):
+            frame = thread.GetFrameAtIndex(i)
+            self.assertTrue(frame)
+            self.assertEqual(frame.GetFunctionName(), backtrace[i])
+            self.assertEqual(frame.GetLineEntry().GetLine(),
+                    line_number("main.c", "Frame " + backtrace[i]))
+            self.assertEqual(frame.FindVariable("F").GetValueAsUnsigned(), ord(backtrace[i][0]))
+
+        self.check_memory_regions(process, region_count)
+
+        self.dbg.DeleteTarget(target)
diff --git a/packages/Python/lldbsuite/test/functionalities/postmortem/linux-core/altmain.c b/packages/Python/lldbsuite/test/functionalities/postmortem/linux-core/altmain.c
new file mode 100644
index 000000000000..da49a00996e1
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/postmortem/linux-core/altmain.c
@@ -0,0 +1,6 @@
+void _start(void)
+{
+    const char *F = "_start";
+    char *boom = (char *)0;
+    *boom = 47; // Frame _start
+}
diff --git a/packages/Python/lldbsuite/test/functionalities/postmortem/linux-core/altmain.core b/packages/Python/lldbsuite/test/functionalities/postmortem/linux-core/altmain.core
new file mode 100644
index 000000000000..423413070c7a
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/postmortem/linux-core/altmain.core
diff --git a/packages/Python/lldbsuite/test/functionalities/postmortem/linux-core/altmain.out b/packages/Python/lldbsuite/test/functionalities/postmortem/linux-core/altmain.out
new file mode 100755
index 000000000000..2fddf3e8f803
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/postmortem/linux-core/altmain.out
diff --git a/packages/Python/lldbsuite/test/functionalities/postmortem/linux-core/i386.core b/packages/Python/lldbsuite/test/functionalities/postmortem/linux-core/i386.core
new file mode 100644
index 000000000000..f8deff474d1f
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/postmortem/linux-core/i386.core
diff --git a/packages/Python/lldbsuite/test/functionalities/postmortem/linux-core/i386.out b/packages/Python/lldbsuite/test/functionalities/postmortem/linux-core/i386.out
new file mode 100755
index 000000000000..3cdd4eeca103
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/postmortem/linux-core/i386.out
diff --git a/packages/Python/lldbsuite/test/functionalities/postmortem/linux-core/main.c b/packages/Python/lldbsuite/test/functionalities/postmortem/linux-core/main.c
new file mode 100644
index 000000000000..f5bde4171ca5
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/postmortem/linux-core/main.c
@@ -0,0 +1,17 @@
+static void bar(char *boom)
+{
+    char F = 'b';
+    *boom = 47; // Frame bar
+}
+
+static void foo(char *boom, void (*boomer)(char *))
+{
+    char F = 'f';
+    boomer(boom); // Frame foo
+}
+
+void _start(void)
+{
+    char F = '_';
+    foo(0, bar); // Frame _start
+}
diff --git a/packages/Python/lldbsuite/test/functionalities/postmortem/linux-core/make-core.sh b/packages/Python/lldbsuite/test/functionalities/postmortem/linux-core/make-core.sh
new file mode 100755
index 000000000000..efe1b801df34
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/postmortem/linux-core/make-core.sh
@@ -0,0 +1,40 @@
+#! /bin/bash
+
+set -e -x
+
+file=$1
+if [ -z "$file" ]; then
+    cat <<EOF
+Please supply the main source file as the first argument.
+EOF
+    exit 1
+fi
+
+if grep -q '^|' </proc/sys/kernel/core_pattern; then
+    cat <<EOF
+Your system uses a crash report tool ($(cat /proc/sys/kernel/core_pattern)). Core files
+will not be generated.  Please reset /proc/sys/kernel/core_pattern (requires root
+privileges) to enable core generation.
+EOF
+    exit 1
+fi
+
+ulimit -c 1000
+real_limit=$(ulimit -c)
+if [ $real_limit -lt 100 ]; then
+    cat <<EOF
+Unable to increase the core file limit. Core file may be truncated!
+To fix this, increase HARD core file limit (ulimit -H -c 1000). This may require root
+privileges.
+EOF
+fi
+
+${CC:-cc} -nostdlib -static -g $CFLAGS "$file" -o a.out
+
+cat <<EOF
+Executable file is in a.out.
+Core file will be saved according to pattern $(cat /proc/sys/kernel/core_pattern).
+EOF
+
+ulimit -s 8 # Decrease stack size to 8k => smaller core files.
+exec ./a.out
diff --git a/packages/Python/lldbsuite/test/functionalities/postmortem/linux-core/s390x.core b/packages/Python/lldbsuite/test/functionalities/postmortem/linux-core/s390x.core
new file mode 100644
index 000000000000..b97fc43e967d
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/postmortem/linux-core/s390x.core
diff --git a/packages/Python/lldbsuite/test/functionalities/postmortem/linux-core/s390x.out b/packages/Python/lldbsuite/test/functionalities/postmortem/linux-core/s390x.out
new file mode 100755
index 000000000000..640fbdc257d9
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/postmortem/linux-core/s390x.out
diff --git a/packages/Python/lldbsuite/test/functionalities/postmortem/linux-core/x86_64.core b/packages/Python/lldbsuite/test/functionalities/postmortem/linux-core/x86_64.core
new file mode 100644
index 000000000000..e2fa69e4558e
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/postmortem/linux-core/x86_64.core
diff --git a/packages/Python/lldbsuite/test/functionalities/postmortem/linux-core/x86_64.out b/packages/Python/lldbsuite/test/functionalities/postmortem/linux-core/x86_64.out
new file mode 100755
index 000000000000..842402fd519d
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/postmortem/linux-core/x86_64.out
diff --git a/packages/Python/lldbsuite/test/functionalities/postmortem/minidump/TestMiniDump.py b/packages/Python/lldbsuite/test/functionalities/postmortem/minidump/TestMiniDump.py
index 1dda59ac374b..89d1974b6703 100644
--- a/packages/Python/lldbsuite/test/functionalities/postmortem/minidump/TestMiniDump.py
+++ b/packages/Python/lldbsuite/test/functionalities/postmortem/minidump/TestMiniDump.py
@@ -7,8 +7,9 @@ from six import iteritems
 
 
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbutil
 
 class MiniDumpTestCase(TestBase):
 
diff --git a/packages/Python/lldbsuite/test/functionalities/postmortem/wow64_minidump/TestWow64MiniDump.py b/packages/Python/lldbsuite/test/functionalities/postmortem/wow64_minidump/TestWow64MiniDump.py
new file mode 100644
index 000000000000..08debab538f5
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/postmortem/wow64_minidump/TestWow64MiniDump.py
@@ -0,0 +1,76 @@
+"""
+Test basics of a mini dump taken of a 32-bit process running in WoW64
+
+WoW64 is the subsystem that lets 32-bit processes run in 64-bit Windows.  If you
+capture a mini dump of a process running under WoW64 with a 64-bit debugger, you
+end up with a dump of the WoW64 layer.  In that case, LLDB must do extra work to
+get the 32-bit register contexts.
+"""
+
+from __future__ import print_function
+from six import iteritems
+
+
+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+class Wow64MiniDumpTestCase(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    @skipUnlessWindows  # for now mini-dump debugging is limited to Windows hosts
+    @no_debug_info_test
+    def test_wow64_mini_dump(self):
+        """Test that lldb can read the process information from the minidump."""
+        # target create -c fizzbuzz_wow64.dmp
+        target = self.dbg.CreateTarget("")
+        process = target.LoadCore("fizzbuzz_wow64.dmp")
+        self.assertTrue(process, PROCESS_IS_VALID)
+        self.assertEqual(process.GetNumThreads(), 1)
+        self.assertEqual(process.GetProcessID(), 0x1E9C)
+
+    @skipUnlessWindows  # for now mini-dump debugging is limited to Windows hosts
+    @no_debug_info_test
+    def test_thread_info_in_wow64_mini_dump(self):
+        """Test that lldb can read the thread information from the minidump."""
+        # target create -c fizzbuzz_wow64.dmp
+        target = self.dbg.CreateTarget("")
+        process = target.LoadCore("fizzbuzz_wow64.dmp")
+        # This process crashed due to an access violation (0xc0000005), but the
+        # minidump doesn't have an exception record--perhaps the crash handler
+        # ate it.
+        # TODO:  See if we can recover the exception information from the TEB,
+        # which, according to Windbg, has a pointer to an exception list.
+
+        # In the dump, none of the threads are stopped, so we cannot use
+        # lldbutil.get_stopped_thread.
+        thread = process.GetThreadAtIndex(0)
+        self.assertEqual(thread.GetStopReason(), lldb.eStopReasonNone)
+
+    @skipUnlessWindows  # for now mini-dump debugging is limited to Windows hosts
+    @no_debug_info_test
+    def test_stack_info_in_wow64_mini_dump(self):
+        """Test that we can see a trivial stack in a VS-generate mini dump."""
+        # target create -c fizzbuzz_no_heap.dmp
+        target = self.dbg.CreateTarget("")
+        process = target.LoadCore("fizzbuzz_wow64.dmp")
+        self.assertGreaterEqual(process.GetNumThreads(), 1)
+        # This process crashed due to an access violation (0xc0000005), but the
+        # minidump doesn't have an exception record--perhaps the crash handler
+        # ate it.
+        # TODO:  See if we can recover the exception information from the TEB,
+        # which, according to Windbg, has a pointer to an exception list.
+
+        # In the dump, none of the threads are stopped, so we cannot use
+        # lldbutil.get_stopped_thread.
+        thread = process.GetThreadAtIndex(0)
+        # The crash is in main, so there should be at least one frame on the stack.
+        self.assertGreaterEqual(thread.GetNumFrames(), 1)
+        frame = thread.GetFrameAtIndex(0)
+        self.assertTrue(frame.IsValid())
+        pc = frame.GetPC()
+        eip = frame.FindRegister("pc")
+        self.assertTrue(eip.IsValid())
+        self.assertEqual(pc, eip.GetValueAsUnsigned())
diff --git a/packages/Python/lldbsuite/test/functionalities/postmortem/wow64_minidump/fizzbuzz.cpp b/packages/Python/lldbsuite/test/functionalities/postmortem/wow64_minidump/fizzbuzz.cpp
new file mode 100644
index 000000000000..295d4a1f24db
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/postmortem/wow64_minidump/fizzbuzz.cpp
@@ -0,0 +1,31 @@
+// A sample program for getting minidumps on Windows.
+
+#include <iostream>
+
+bool
+fizz(int x)
+{
+    return x % 3 == 0;
+}
+
+bool
+buzz(int x)
+{
+    return x % 5 == 0;
+}
+
+int
+main()
+{
+    int *buggy = 0;
+
+    for (int i = 1; i <= 100; ++i)
+    {
+        if (fizz(i)) std::cout << "fizz";
+        if (buzz(i)) std::cout << "buzz";
+        if (!fizz(i) && !buzz(i)) std::cout << i;
+        std::cout << '\n';
+    }
+
+    return *buggy;
+}
diff --git a/packages/Python/lldbsuite/test/functionalities/postmortem/wow64_minidump/fizzbuzz_wow64.dmp b/packages/Python/lldbsuite/test/functionalities/postmortem/wow64_minidump/fizzbuzz_wow64.dmp
new file mode 100644
index 000000000000..3d97186f2cd2
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/postmortem/wow64_minidump/fizzbuzz_wow64.dmp
diff --git a/packages/Python/lldbsuite/test/functionalities/process_attach/TestProcessAttach.py b/packages/Python/lldbsuite/test/functionalities/process_attach/TestProcessAttach.py
index 83906b546300..e4eb302d83d1 100644
--- a/packages/Python/lldbsuite/test/functionalities/process_attach/TestProcessAttach.py
+++ b/packages/Python/lldbsuite/test/functionalities/process_attach/TestProcessAttach.py
@@ -8,8 +8,9 @@ from __future__ import print_function
 
 import os, time
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbutil
 
 exe_name = "ProcessAttach"  # Must match Makefile
 
diff --git a/packages/Python/lldbsuite/test/functionalities/process_attach/attach_denied/TestAttachDenied.py b/packages/Python/lldbsuite/test/functionalities/process_attach/attach_denied/TestAttachDenied.py
index ed9d58f90888..3d1d7fdc7907 100644
--- a/packages/Python/lldbsuite/test/functionalities/process_attach/attach_denied/TestAttachDenied.py
+++ b/packages/Python/lldbsuite/test/functionalities/process_attach/attach_denied/TestAttachDenied.py
@@ -9,7 +9,9 @@ from __future__ import print_function
 import os
 import time
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
 
 exe_name = 'AttachDenied'  # Must match Makefile
 
@@ -17,12 +19,6 @@ class AttachDeniedTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    def run_platform_command(self, cmd):
-        platform = self.dbg.GetSelectedPlatform()
-        shell_command = lldb.SBPlatformShellCommand(cmd)
-        err = platform.Run(shell_command)
-        return (err, shell_command.GetStatus(), shell_command.GetOutput())
-
     @skipIfWindows
     @skipIfiOSSimulator
     def test_attach_to_process_by_id_denied(self):
@@ -39,21 +35,7 @@ class AttachDeniedTestCase(TestBase):
         popen = self.spawnSubprocess(exe, [pid_file_path])
         self.addTearDownHook(self.cleanupSubprocesses)
 
-        max_attempts = 5
-        for i in range(max_attempts):
-            err, retcode, msg = self.run_platform_command("ls %s" % pid_file_path)
-            if err.Success() and retcode == 0:
-                break
-            else:
-                print(msg)
-            if i < max_attempts:
-                # Exponential backoff!
-                time.sleep(pow(2, i) * 0.25)
-        else:
-            self.fail("Child PID file %s not found even after %d attempts." % (pid_file_path, max_attempts))
-        err, retcode, pid = self.run_platform_command("cat %s" % (pid_file_path))
-        self.assertTrue(err.Success() and retcode == 0,
-                        "Failed to read file %s: %s, retcode: %d" % (pid_file_path, err.GetCString(), retcode))
+        pid = lldbutil.wait_for_file_on_target(self, pid_file_path)
 
         self.expect('process attach -p ' + pid,
                     startstr = 'error: attach failed:',
diff --git a/packages/Python/lldbsuite/test/functionalities/process_group/TestChangeProcessGroup.py b/packages/Python/lldbsuite/test/functionalities/process_group/TestChangeProcessGroup.py
index 25be37b2b12d..c20d66aa3ab0 100644
--- a/packages/Python/lldbsuite/test/functionalities/process_group/TestChangeProcessGroup.py
+++ b/packages/Python/lldbsuite/test/functionalities/process_group/TestChangeProcessGroup.py
@@ -6,8 +6,9 @@ from __future__ import print_function
 
 import os
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbutil
 
 
 class ChangeProcessGroupTestCase(TestBase):
@@ -35,23 +36,7 @@ class ChangeProcessGroupTestCase(TestBase):
         popen = self.spawnSubprocess(exe, [pid_file_path])
         self.addTearDownHook(self.cleanupSubprocesses)
 
-        max_attempts = 5
-        for i in range(max_attempts):
-            err, retcode, msg = self.run_platform_command("ls %s" % pid_file_path)
-            if err.Success() and retcode == 0:
-                break
-            else:
-                print(msg)
-            if i < max_attempts:
-                # Exponential backoff!
-                time.sleep(pow(2, i) * 0.25)
-        else:
-            self.fail("Child PID file %s not found even after %d attempts." % (pid_file_path, max_attempts))
-
-        err, retcode, pid = self.run_platform_command("cat %s" % (pid_file_path))
-
-        self.assertTrue(err.Success() and retcode == 0,
-                "Failed to read file %s: %s, retcode: %d" % (pid_file_path, err.GetCString(), retcode))
+        pid = lldbutil.wait_for_file_on_target(self, pid_file_path)
 
         # make sure we cleanup the forked child also
         def cleanupChild():
@@ -99,9 +84,3 @@ class ChangeProcessGroupTestCase(TestBase):
         # run to completion
         process.Continue()
         self.assertEqual(process.GetState(), lldb.eStateExited)
-
-    def run_platform_command(self, cmd):
-        platform = self.dbg.GetSelectedPlatform()
-        shell_command = lldb.SBPlatformShellCommand(cmd)
-        err = platform.Run(shell_command)
-        return (err, shell_command.GetStatus(), shell_command.GetOutput())
diff --git a/packages/Python/lldbsuite/test/functionalities/process_launch/TestProcessLaunch.py b/packages/Python/lldbsuite/test/functionalities/process_launch/TestProcessLaunch.py
index 3131000be428..5998edb3c7e0 100644
--- a/packages/Python/lldbsuite/test/functionalities/process_launch/TestProcessLaunch.py
+++ b/packages/Python/lldbsuite/test/functionalities/process_launch/TestProcessLaunch.py
@@ -4,11 +4,16 @@ Test lldb process launch flags.
 
 from __future__ import print_function
 
+import copy
+import os
+import time
 
-
-import os, time
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+import six
 
 class ProcessLaunchTestCase(TestBase):
 
@@ -17,9 +22,11 @@ class ProcessLaunchTestCase(TestBase):
     def setUp(self):
         # Call super's setUp().
         TestBase.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"))
+
+    def tearDown(self):
+        self.runCmd("settings clear auto-confirm")
+        TestBase.tearDown(self)
 
     @not_remote_testsuite_ready
     def test_io (self):
@@ -109,7 +116,7 @@ class ProcessLaunchTestCase(TestBase):
     # rdar://problem/9056462
     # The process launch flag '-w' for setting the current working directory not working?
     @not_remote_testsuite_ready
-    @expectedFailureLinux("llvm.org/pr20265")
+    @expectedFailureAll(oslist=["linux"], bugnumber="llvm.org/pr20265")
     def test_set_working_dir (self):
         """Test that '-w dir' sets the working dir when running the inferior."""
         d = {'CXX_SOURCES' : 'print_cwd.cpp'}
@@ -180,8 +187,9 @@ class ProcessLaunchTestCase(TestBase):
             self.fail(err_msg)
 
     def test_environment_with_special_char (self):
-        """Test that environment variables containing '*' and '}' are communicated correctly to the lldb-server."""
-        d = {'CXX_SOURCES' : 'print_env.cpp'}
+        """Test that environment variables containing '*' and '}' are handled correctly by the inferior."""
+        source = 'print_env.cpp'
+        d = {'CXX_SOURCES' : source}
         self.build(dictionary=d)
         self.setTearDownCleanup(d)
         exe = os.path.join (os.getcwd(), "a.out")
@@ -189,19 +197,19 @@ class ProcessLaunchTestCase(TestBase):
         evil_var = 'INIT*MIDDLE}TAIL'
 
         target = self.dbg.CreateTarget(exe)
-        process = target.LaunchSimple(None, ['EVIL=' + evil_var], self.get_process_working_directory())
-        self.assertEqual(process.GetState(), lldb.eStateExited, PROCESS_EXITED)
-
-        out = process.GetSTDOUT(len(evil_var))
-        self.assertIsNotNone(out, "Encountered an error reading the process's output")
+        main_source_spec = lldb.SBFileSpec(source)
+        breakpoint = target.BreakpointCreateBySourceRegex('// Set breakpoint here.', main_source_spec)
 
-        out = out[:len(evil_var)]
-        if out != evil_var:
-            self.fail('The environment variable was mis-coded: %s\n' % repr(out))
+        process = target.LaunchSimple(None, ['EVIL=' + evil_var], self.get_process_working_directory())
+        self.assertEqual(process.GetState(), lldb.eStateStopped, PROCESS_STOPPED)
 
-        newline = process.GetSTDOUT(1)
-        self.assertIsNotNone(newline, "Encountered an error reading the process's output")
+        threads = lldbutil.get_threads_stopped_at_breakpoint(process, breakpoint)
+        self.assertEqual(len(threads), 1)
+        frame = threads[0].GetFrameAtIndex(0)
+        sbvalue = frame.EvaluateExpression("evil")
+        value = sbvalue.GetSummary().strip('"')
 
-        newline = newline[0]
-        if newline != '\r' and newline != '\n':
-            self.fail('Garbage at end of environment variable')
+        self.assertEqual(value, evil_var)
+        process.Continue()
+        self.assertEqual(process.GetState(), lldb.eStateExited, PROCESS_EXITED)
+        pass
diff --git a/packages/Python/lldbsuite/test/functionalities/process_launch/print_env.cpp b/packages/Python/lldbsuite/test/functionalities/process_launch/print_env.cpp
index cbb9b2175916..8c6df8ea01a4 100644
--- a/packages/Python/lldbsuite/test/functionalities/process_launch/print_env.cpp
+++ b/packages/Python/lldbsuite/test/functionalities/process_launch/print_env.cpp
@@ -5,7 +5,6 @@
 int main (int argc, char **argv)
 {
   char *evil = getenv("EVIL");
-  puts(evil);
 
-  return 0;
+  return 0;  // Set breakpoint here.
 }
diff --git a/packages/Python/lldbsuite/test/functionalities/process_save_core/TestProcessSaveCore.py b/packages/Python/lldbsuite/test/functionalities/process_save_core/TestProcessSaveCore.py
index 0578bcf44b4c..1c01e2138c2e 100644
--- a/packages/Python/lldbsuite/test/functionalities/process_save_core/TestProcessSaveCore.py
+++ b/packages/Python/lldbsuite/test/functionalities/process_save_core/TestProcessSaveCore.py
@@ -6,7 +6,9 @@ from __future__ import print_function
 
 import os, time
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
 
 class ProcessSaveCoreTestCase(TestBase):
 
diff --git a/packages/Python/lldbsuite/test/functionalities/ptr_refs/Makefile b/packages/Python/lldbsuite/test/functionalities/ptr_refs/Makefile
new file mode 100644
index 000000000000..0d70f2595019
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/ptr_refs/Makefile
@@ -0,0 +1,5 @@
+LEVEL = ../../make
+
+C_SOURCES := main.c
+
+include $(LEVEL)/Makefile.rules
diff --git a/packages/Python/lldbsuite/test/functionalities/ptr_refs/TestPtrRefs.py b/packages/Python/lldbsuite/test/functionalities/ptr_refs/TestPtrRefs.py
new file mode 100644
index 000000000000..81db42d8e3c6
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/ptr_refs/TestPtrRefs.py
@@ -0,0 +1,43 @@
+"""
+Test the ptr_refs tool on Darwin
+"""
+
+from __future__ import print_function
+
+import os
+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+class TestPtrRefs(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    @skipUnlessDarwin
+    def test_ptr_refs(self):
+        """Test format string functionality."""
+        self.build()
+        exe_name = 'a.out'
+        exe = os.path.join(os.getcwd(), exe_name)
+    
+        target = self.dbg.CreateTarget(exe)
+        self.assertTrue(target, VALID_TARGET)
+
+        main_file_spec = lldb.SBFileSpec ('main.c')
+        breakpoint = target.BreakpointCreateBySourceRegex('break', main_file_spec)
+        self.assertTrue(breakpoint and
+                        breakpoint.GetNumLocations() == 1,
+                        VALID_BREAKPOINT)
+
+        process = target.LaunchSimple (None, None, self.get_process_working_directory())
+        self.assertTrue(process, PROCESS_IS_VALID)
+
+        # Frame #0 should be on self.line1 and the break condition should hold.
+        thread = lldbutil.get_stopped_thread(process, lldb.eStopReasonBreakpoint)
+        self.assertTrue(thread.IsValid(), "There should be a thread stopped due to breakpoint condition")
+
+        frame = thread.GetFrameAtIndex(0)       
+
+        self.dbg.HandleCommand("script import lldb.macosx.heap")
+        self.expect("ptr_refs my_ptr", substrs=["malloc", "stack"]);
diff --git a/packages/Python/lldbsuite/test/functionalities/ptr_refs/main.c b/packages/Python/lldbsuite/test/functionalities/ptr_refs/main.c
new file mode 100644
index 000000000000..4053f9997276
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/ptr_refs/main.c
@@ -0,0 +1,27 @@
+//===-- main.c --------------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+struct referent {
+    const char *p;
+};
+
+int main (int argc, char const *argv[])
+{
+    const char *my_ptr = strdup("hello");
+    struct referent *r = malloc(sizeof(struct referent));
+    r->p = my_ptr;
+
+    printf("%p\n", r); // break here
+
+    return 0;
+}
diff --git a/packages/Python/lldbsuite/test/functionalities/register/TestRegisters.py b/packages/Python/lldbsuite/test/functionalities/register/TestRegisters.py
index c5d4650aa371..21de3ab7cc37 100644
--- a/packages/Python/lldbsuite/test/functionalities/register/TestRegisters.py
+++ b/packages/Python/lldbsuite/test/functionalities/register/TestRegisters.py
@@ -9,8 +9,9 @@ from __future__ import print_function
 import os, sys, time
 import re
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbutil
 
 class RegisterCommandsTestCase(TestBase):
 
@@ -25,7 +26,7 @@ class RegisterCommandsTestCase(TestBase):
         TestBase.tearDown(self)
 
     @skipIfiOSSimulator
-    @skipUnlessArch(['amd64', 'arm', 'i386', 'x86_64'])
+    @skipIf(archs=no_match(['amd64', 'arm', 'i386', 'x86_64']))
     def test_register_commands(self):
         """Test commands related to registers, in particular vector registers."""
         self.build()
@@ -48,7 +49,7 @@ class RegisterCommandsTestCase(TestBase):
 
     @skipIfiOSSimulator
     @skipIfTargetAndroid(archs=["i386"]) # Writing of mxcsr register fails, presumably due to a kernel/hardware problem
-    @skipUnlessArch(['amd64', 'arm', 'i386', 'x86_64'])
+    @skipIf(archs=no_match(['amd64', 'arm', 'i386', 'x86_64']))
     def test_fp_register_write(self):
         """Test commands that write to registers, in particular floating-point registers."""
         self.build()
@@ -57,14 +58,14 @@ class RegisterCommandsTestCase(TestBase):
     @skipIfiOSSimulator
     @expectedFailureAndroid(archs=["i386"]) # "register read fstat" always return 0xffff
     @skipIfFreeBSD    #llvm.org/pr25057
-    @skipUnlessArch(['amd64', 'i386', 'x86_64'])
+    @skipIf(archs=no_match(['amd64', 'i386', 'x86_64']))
     def test_fp_special_purpose_register_read(self):
         """Test commands that read fpu special purpose registers."""
         self.build()
         self.fp_special_purpose_register_read()
 
     @skipIfiOSSimulator
-    @skipUnlessArch(['amd64', 'arm', 'i386', 'x86_64'])
+    @skipIf(archs=no_match(['amd64', 'arm', 'i386', 'x86_64']))
     def test_register_expressions(self):
         """Test expression evaluation with commands related to registers."""
         self.build()
@@ -85,21 +86,21 @@ class RegisterCommandsTestCase(TestBase):
             self.expect("expr -- ($rax & 0xffffffff) == $eax", substrs = ['true'])
 
     @skipIfiOSSimulator
-    @skipUnlessArch(['amd64', 'x86_64'])
+    @skipIf(archs=no_match(['amd64', 'x86_64']))
     def test_convenience_registers(self):
         """Test convenience registers."""
         self.build()
         self.convenience_registers()
 
     @skipIfiOSSimulator
-    @skipUnlessArch(['amd64', 'x86_64'])
+    @skipIf(archs=no_match(['amd64', 'x86_64']))
     def test_convenience_registers_with_process_attach(self):
         """Test convenience registers after a 'process attach'."""
         self.build()
         self.convenience_registers_with_process_attach(test_16bit_regs=False)
 
     @skipIfiOSSimulator
-    @skipUnlessArch(['amd64', 'x86_64'])
+    @skipIf(archs=no_match(['amd64', 'x86_64']))
     def test_convenience_registers_16bit_with_process_attach(self):
         """Test convenience registers after a 'process attach'."""
         self.build()
diff --git a/packages/Python/lldbsuite/test/functionalities/rerun/TestRerun.py b/packages/Python/lldbsuite/test/functionalities/rerun/TestRerun.py
index 0ed56de35699..8636abadd104 100644
--- a/packages/Python/lldbsuite/test/functionalities/rerun/TestRerun.py
+++ b/packages/Python/lldbsuite/test/functionalities/rerun/TestRerun.py
@@ -8,8 +8,9 @@ from __future__ import print_function
 import lldb
 import os
 import time
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbutil
 
 class TestRerun(TestBase):
 
@@ -31,19 +32,9 @@ class TestRerun(TestBase):
         self.runCmd("process launch 1 2 3")
 
         process = self.process()
-
-        self.assertTrue(process.GetState() == lldb.eStateStopped,
-                        STOPPED_DUE_TO_BREAKPOINT)
-
-        thread = process.GetThreadAtIndex (0)
-
-        self.assertTrue (thread.IsValid(),
-                         "Process stopped at 'main' should have a valid thread");
-
-        stop_reason = thread.GetStopReason()
-        
-        self.assertTrue (stop_reason == lldb.eStopReasonBreakpoint,
-                         "Thread in process stopped in 'main' should have a stop reason of eStopReasonBreakpoint");
+        thread = lldbutil.get_one_thread_stopped_at_breakpoint(process, breakpoint)
+        self.assertIsNotNone(thread, "Process should be stopped at a breakpoint in main")
+        self.assertTrue(thread.IsValid(), "Stopped thread is not valid")
 
         self.expect("frame variable argv[1]", substrs=['1'])
         self.expect("frame variable argv[2]", substrs=['2'])
@@ -57,19 +48,10 @@ class TestRerun(TestBase):
         self.runCmd("process launch")
 
         process = self.process()
-        
-        self.assertTrue(process.GetState() == lldb.eStateStopped,
-                        STOPPED_DUE_TO_BREAKPOINT)
-
-        thread = process.GetThreadAtIndex (0)
+        thread = lldbutil.get_one_thread_stopped_at_breakpoint(process, breakpoint)
 
-        self.assertTrue (thread.IsValid(),
-                         "Process stopped at 'main' should have a valid thread");
-
-        stop_reason = thread.GetStopReason()
-        
-        self.assertTrue (stop_reason == lldb.eStopReasonBreakpoint,
-                         "Thread in process stopped in 'main' should have a stop reason of eStopReasonBreakpoint");
+        self.assertIsNotNone(thread, "Process should be stopped at a breakpoint in main");
+        self.assertTrue(thread.IsValid(), "Stopped thread is not valid")
 
         self.expect("frame variable argv[1]", substrs=['1'])
         self.expect("frame variable argv[2]", substrs=['2'])
diff --git a/packages/Python/lldbsuite/test/functionalities/return-value/TestReturnValue.py b/packages/Python/lldbsuite/test/functionalities/return-value/TestReturnValue.py
index 246eb5c3fdbd..81d93294b5a5 100644
--- a/packages/Python/lldbsuite/test/functionalities/return-value/TestReturnValue.py
+++ b/packages/Python/lldbsuite/test/functionalities/return-value/TestReturnValue.py
@@ -9,8 +9,9 @@ from __future__ import print_function
 import os, time
 import re
 import lldb
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
 
 class ReturnValueTestCase(TestBase):
 
@@ -19,7 +20,7 @@ class ReturnValueTestCase(TestBase):
     @expectedFailureAll(oslist=["macosx","freebsd"], archs=["i386"])
     @expectedFailureAll(oslist=["linux"], compiler="clang", compiler_version=["<=", "3.6"], archs=["i386"])
     @expectedFailureAll(bugnumber="llvm.org/pr25785", hostoslist=["windows"], compiler="gcc", archs=["i386"], triple='.*-android')
-    @expectedFailureWindows("llvm.org/pr24778")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778")
     @add_test_categories(['pyapi'])
     def test_with_python(self):
         """Test getting return values from stepping out."""
diff --git a/packages/Python/lldbsuite/test/functionalities/set-data/TestSetData.py b/packages/Python/lldbsuite/test/functionalities/set-data/TestSetData.py
index 3acad5f87be0..294aa6725155 100644
--- a/packages/Python/lldbsuite/test/functionalities/set-data/TestSetData.py
+++ b/packages/Python/lldbsuite/test/functionalities/set-data/TestSetData.py
@@ -8,8 +8,9 @@ from __future__ import print_function
 
 import os, time
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbutil
 
 class SetDataTestCase(TestBase):
 
diff --git a/packages/Python/lldbsuite/test/functionalities/signal/TestSendSignal.py b/packages/Python/lldbsuite/test/functionalities/signal/TestSendSignal.py
index 971b82a7c75d..1da4d701a590 100644
--- a/packages/Python/lldbsuite/test/functionalities/signal/TestSendSignal.py
+++ b/packages/Python/lldbsuite/test/functionalities/signal/TestSendSignal.py
@@ -6,8 +6,9 @@ from __future__ import print_function
 
 import os, time, signal
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbutil
 
 
 class SendSignalTestCase(TestBase):
@@ -20,7 +21,7 @@ class SendSignalTestCase(TestBase):
         # Find the line number to break inside main().
         self.line = line_number('main.c', 'Put breakpoint here')
 
-    @expectedFailureFreeBSD("llvm.org/pr23318: does not report running state")
+    @expectedFailureAll(oslist=['freebsd'], bugnumber="llvm.org/pr23318: does not report running state")
     @skipIfWindows # Windows does not support signals
     def test_with_run_command(self):
         """Test that lldb command 'process signal SIGUSR1' sends a signal to the inferior process."""
diff --git a/packages/Python/lldbsuite/test/functionalities/signal/handle-segv/TestHandleSegv.py b/packages/Python/lldbsuite/test/functionalities/signal/handle-segv/TestHandleSegv.py
index feed5bfb3c76..d8dbb7f68936 100644
--- a/packages/Python/lldbsuite/test/functionalities/signal/handle-segv/TestHandleSegv.py
+++ b/packages/Python/lldbsuite/test/functionalities/signal/handle-segv/TestHandleSegv.py
@@ -5,10 +5,12 @@ from __future__ import print_function
 
 
 import os
+import re
+
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
-import re
+from lldbsuite.test import lldbutil
 
 
 class HandleSegvTestCase(TestBase):
@@ -17,7 +19,7 @@ class HandleSegvTestCase(TestBase):
 
     @skipIfWindows # signals do not exist on Windows
     @skipIfDarwin
-    @expectedFailureFreeBSD("llvm.org/pr23699 SIGSEGV is reported as exception, not signal")
+    @expectedFailureAll(oslist=['freebsd'], bugnumber="llvm.org/pr23699 SIGSEGV is reported as exception, not signal")
     def test_inferior_handle_sigsegv(self):
         self.build()
         exe = os.path.join(os.getcwd(), "a.out")
diff --git a/packages/Python/lldbsuite/test/functionalities/signal/raise/TestRaise.py b/packages/Python/lldbsuite/test/functionalities/signal/raise/TestRaise.py
index 39e7753397d1..2c30f69d7b20 100644
--- a/packages/Python/lldbsuite/test/functionalities/signal/raise/TestRaise.py
+++ b/packages/Python/lldbsuite/test/functionalities/signal/raise/TestRaise.py
@@ -6,9 +6,11 @@ from __future__ import print_function
 
 import os
 import lldb
-from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
 import re
+from lldbsuite.test.lldbplatformutil import getDarwinOSTriples
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
 
 
 @skipIfWindows # signals do not exist on Windows
@@ -148,8 +150,7 @@ class RaiseTestCase(TestBase):
         # reset signal handling to default
         self.set_handle(signal, default_pass, default_stop, default_notify)
 
-    @expectedFailureLinux("llvm.org/pr24530") # the signal the inferior generates gets lost
-    @expectedFailureDarwin("llvm.org/pr24530") # the signal the inferior generates gets lost
+    @expectedFailureAll(oslist=["linux"]+getDarwinOSTriples(), bugnumber="llvm.org/pr20231")
     def test_restart_bug(self):
         """Test that we catch a signal in the edge case where the process receives it while we are
         about to interrupt it"""
diff --git a/packages/Python/lldbsuite/test/functionalities/single-quote-in-filename-to-lldb/TestSingleQuoteInFilename.py b/packages/Python/lldbsuite/test/functionalities/single-quote-in-filename-to-lldb/TestSingleQuoteInFilename.py
index 6a2dd74d3956..6f5882636cb6 100644
--- a/packages/Python/lldbsuite/test/functionalities/single-quote-in-filename-to-lldb/TestSingleQuoteInFilename.py
+++ b/packages/Python/lldbsuite/test/functionalities/single-quote-in-filename-to-lldb/TestSingleQuoteInFilename.py
@@ -8,7 +8,9 @@ from __future__ import print_function
 
 import os
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
 
 class SingleQuoteInCommandLineTestCase(TestBase):
 
@@ -25,7 +27,7 @@ class SingleQuoteInCommandLineTestCase(TestBase):
         except:
             pass
 
-    @expectedFailureHostWindows("llvm.org/pr22274: need a pexpect replacement for windows")
+    @expectedFailureAll(hostoslist=["windows"], bugnumber="llvm.org/pr22274: need a pexpect replacement for windows")
     @no_debug_info_test
     def test_lldb_invocation_with_single_quote_in_filename(self):
         """Test that 'lldb my_file_name' works where my_file_name is a string with a single quote char in it."""
diff --git a/packages/Python/lldbsuite/test/functionalities/step-avoids-no-debug/TestStepNoDebug.py b/packages/Python/lldbsuite/test/functionalities/step-avoids-no-debug/TestStepNoDebug.py
index 6c1f2c3da41b..8b9c91217de4 100644
--- a/packages/Python/lldbsuite/test/functionalities/step-avoids-no-debug/TestStepNoDebug.py
+++ b/packages/Python/lldbsuite/test/functionalities/step-avoids-no-debug/TestStepNoDebug.py
@@ -8,10 +8,12 @@ from __future__ import print_function
 
 import os
 import re
-import lldb
-import lldbsuite.test.lldbutil as lldbutil
 import sys
+
+import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
 
 class ReturnValueTestCase(TestBase):
 
@@ -25,7 +27,8 @@ class ReturnValueTestCase(TestBase):
         self.do_step_out_past_nodebug()
 
     @add_test_categories(['pyapi'])
-    @expectedFailureGcc("llvm.org/pr19247")
+    @decorators.expectedFailureAll(compiler="gcc", bugnumber="llvm.org/pr28549")
+    @decorators.expectedFailureAll(compiler="clang", compiler_version=[">=", "3.9"], archs=["i386"], bugnumber="llvm.org/pr28549")
     def test_step_over_with_python(self):
         """Test stepping over using avoid-no-debug with dwarf."""
         self.build()
@@ -33,7 +36,8 @@ class ReturnValueTestCase(TestBase):
         self.do_step_over_past_nodebug()
 
     @add_test_categories(['pyapi'])
-    @expectedFailureGcc("llvm.org/pr19247")
+    @decorators.expectedFailureAll(compiler="gcc", bugnumber="llvm.org/pr28549")
+    @decorators.expectedFailureAll(compiler="clang", compiler_version=[">=", "3.9"], archs=["i386"], bugnumber="llvm.org/pr28549")
     def test_step_in_with_python(self):
         """Test stepping in using avoid-no-debug with dwarf."""
         self.build()
diff --git a/packages/Python/lldbsuite/test/functionalities/stop-hook/TestStopHookCmd.py b/packages/Python/lldbsuite/test/functionalities/stop-hook/TestStopHookCmd.py
index 753491339c4c..93f846a06870 100644
--- a/packages/Python/lldbsuite/test/functionalities/stop-hook/TestStopHookCmd.py
+++ b/packages/Python/lldbsuite/test/functionalities/stop-hook/TestStopHookCmd.py
@@ -8,8 +8,9 @@ from __future__ import print_function
 
 import os
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbutil
 
 class StopHookCmdTestCase(TestBase):
 
diff --git a/packages/Python/lldbsuite/test/functionalities/stop-hook/TestStopHookMechanism.py b/packages/Python/lldbsuite/test/functionalities/stop-hook/TestStopHookMechanism.py
index 7785d85772e2..c42c1e563881 100644
--- a/packages/Python/lldbsuite/test/functionalities/stop-hook/TestStopHookMechanism.py
+++ b/packages/Python/lldbsuite/test/functionalities/stop-hook/TestStopHookMechanism.py
@@ -8,8 +8,10 @@ from __future__ import print_function
 
 import os
 import lldb
-from lldbsuite.test import configuration
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
+from lldbsuite.test import configuration
+from lldbsuite.test import lldbutil
 
 class StopHookMechanismTestCase(TestBase):
 
@@ -26,7 +28,7 @@ class StopHookMechanismTestCase(TestBase):
 
     @skipIfFreeBSD # llvm.org/pr15037
     @expectedFlakeyLinux('llvm.org/pr15037') # stop-hooks sometimes fail to fire on Linux
-    @expectedFailureHostWindows("llvm.org/pr22274: need a pexpect replacement for windows")
+    @expectedFailureAll(hostoslist=["windows"], bugnumber="llvm.org/pr22274: need a pexpect replacement for windows")
     def test(self):
         """Test the stop-hook mechanism."""
         self.build()
diff --git a/packages/Python/lldbsuite/test/functionalities/stop-hook/multiple_threads/TestStopHookMultipleThreads.py b/packages/Python/lldbsuite/test/functionalities/stop-hook/multiple_threads/TestStopHookMultipleThreads.py
index c7fb53d495e6..57395832dc21 100644
--- a/packages/Python/lldbsuite/test/functionalities/stop-hook/multiple_threads/TestStopHookMultipleThreads.py
+++ b/packages/Python/lldbsuite/test/functionalities/stop-hook/multiple_threads/TestStopHookMultipleThreads.py
@@ -8,8 +8,10 @@ from __future__ import print_function
 
 import os, time
 import lldb
-from lldbsuite.test import configuration
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
+from lldbsuite.test import configuration
+from lldbsuite.test import lldbutil
 
 class StopHookForMultipleThreadsTestCase(TestBase):
 
@@ -29,7 +31,7 @@ class StopHookForMultipleThreadsTestCase(TestBase):
 
     @expectedFlakeyFreeBSD("llvm.org/pr15037")
     @expectedFlakeyLinux("llvm.org/pr15037") # stop hooks sometimes fail to fire on Linux
-    @expectedFailureHostWindows("llvm.org/pr22274: need a pexpect replacement for windows")
+    @expectedFailureAll(hostoslist=["windows"], bugnumber="llvm.org/pr22274: need a pexpect replacement for windows")
     def test_stop_hook_multiple_threads(self):
         """Test that lldb stop-hook works for multiple threads."""
         self.build(dictionary=self.d)
diff --git a/packages/Python/lldbsuite/test/functionalities/target_command/TestTargetCommand.py b/packages/Python/lldbsuite/test/functionalities/target_command/TestTargetCommand.py
index 0ab965d2aa16..126f6e4dab80 100644
--- a/packages/Python/lldbsuite/test/functionalities/target_command/TestTargetCommand.py
+++ b/packages/Python/lldbsuite/test/functionalities/target_command/TestTargetCommand.py
@@ -8,8 +8,9 @@ from __future__ import print_function
 
 import lldb
 import sys
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbutil
 
 class targetCommandTestCase(TestBase):
 
diff --git a/packages/Python/lldbsuite/test/functionalities/thread/backtrace_all/TestBacktraceAll.py b/packages/Python/lldbsuite/test/functionalities/thread/backtrace_all/TestBacktraceAll.py
index 91bc68577a43..902adacb2abd 100644
--- a/packages/Python/lldbsuite/test/functionalities/thread/backtrace_all/TestBacktraceAll.py
+++ b/packages/Python/lldbsuite/test/functionalities/thread/backtrace_all/TestBacktraceAll.py
@@ -5,8 +5,9 @@ Test regression for Bug 25251.
 import os, time
 import unittest2
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbutil
 
 class BreakpointAfterJoinTestCase(TestBase):
 
diff --git a/packages/Python/lldbsuite/test/functionalities/thread/break_after_join/TestBreakAfterJoin.py b/packages/Python/lldbsuite/test/functionalities/thread/break_after_join/TestBreakAfterJoin.py
index 43397a122391..8ef0fb0a000d 100644
--- a/packages/Python/lldbsuite/test/functionalities/thread/break_after_join/TestBreakAfterJoin.py
+++ b/packages/Python/lldbsuite/test/functionalities/thread/break_after_join/TestBreakAfterJoin.py
@@ -8,8 +8,9 @@ from __future__ import print_function
 
 import os, time
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbutil
 
 class BreakpointAfterJoinTestCase(TestBase):
 
@@ -21,9 +22,9 @@ class BreakpointAfterJoinTestCase(TestBase):
         # Find the line number for our breakpoint.
         self.breakpoint = line_number('main.cpp', '// Set breakpoint here')
 
-    @expectedFailureDarwin("llvm.org/pr15824") # thread states not properly maintained
-    @expectedFailureFreeBSD("llvm.org/pr18190") # thread states not properly maintained
-    @expectedFailureLinux("llvm.org/pr15824") # thread states not properly maintained
+    @expectedFailureAll(oslist=["linux"], bugnumber="llvm.org/pr15824 thread states not properly maintained")
+    @expectedFailureAll(oslist=lldbplatformutil.getDarwinOSTriples(), bugnumber="llvm.org/pr15824 thread states not properly maintained")
+    @expectedFailureAll(oslist=["freebsd"], bugnumber="llvm.org/pr18190 thread states not properly maintained")
     def test(self):
         """Test breakpoint handling after a thread join."""
         self.build(dictionary=self.getBuildFlags())
diff --git a/packages/Python/lldbsuite/test/functionalities/thread/break_after_join/main.cpp b/packages/Python/lldbsuite/test/functionalities/thread/break_after_join/main.cpp
index a63079524ee2..f9f33fda82bb 100644
--- a/packages/Python/lldbsuite/test/functionalities/thread/break_after_join/main.cpp
+++ b/packages/Python/lldbsuite/test/functionalities/thread/break_after_join/main.cpp
@@ -19,24 +19,12 @@
 
 volatile int g_test = 0;
 
-// Note that although hogging the CPU while waiting for a variable to change
-// would be terrible in production code, it's great for testing since it
-// avoids a lot of messy context switching to get multiple threads synchronized.
-#define do_nothing()  
-
-#define pseudo_barrier_wait(bar) \
-    --bar;                       \
-    while (bar > 0)              \
-        do_nothing();
-
-#define pseudo_barrier_init(bar, count) (bar = count)
-
 // A barrier to synchronize all the threads.
-std::atomic_int g_barrier1;
+pseudo_barrier_t g_barrier1;
 
 // A barrier to keep the threads from exiting until after the breakpoint has
 // been passed.
-std::atomic_int g_barrier2;
+pseudo_barrier_t g_barrier2;
 
 void *
 break_thread_func ()
diff --git a/packages/Python/lldbsuite/test/functionalities/thread/concurrent_events/TestConcurrentEvents.py b/packages/Python/lldbsuite/test/functionalities/thread/concurrent_events/TestConcurrentEvents.py
index 9eb25b68765a..30adcccd203f 100644
--- a/packages/Python/lldbsuite/test/functionalities/thread/concurrent_events/TestConcurrentEvents.py
+++ b/packages/Python/lldbsuite/test/functionalities/thread/concurrent_events/TestConcurrentEvents.py
@@ -17,11 +17,11 @@ from __future__ import print_function
 import unittest2
 import os, time
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbutil
 
 @skipIfWindows
-@expectedFailureAll(archs=['mips64', 'mips64el']) # Atomic sequences are not supported yet for MIPS in LLDB. 
 class ConcurrentEventsTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
@@ -30,24 +30,28 @@ class ConcurrentEventsTestCase(TestBase):
     ## Tests for multiple threads that generate a single event.
     #
     @unittest2.skipIf(TestBase.skipLongRunningTest(), "Skip this long running test")
+    @expectedFailureAll(triple = '^mips') # Atomic sequences are not supported yet for MIPS in LLDB.
     def test_many_breakpoints(self):
         """Test 100 breakpoints from 100 threads."""
         self.build(dictionary=self.getBuildFlags())
         self.do_thread_actions(num_breakpoint_threads=100)
 
     @unittest2.skipIf(TestBase.skipLongRunningTest(), "Skip this long running test")
+    @expectedFailureAll(triple = '^mips') # Atomic sequences are not supported yet for MIPS in LLDB.
     def test_many_watchpoints(self):
         """Test 100 watchpoints from 100 threads."""
         self.build(dictionary=self.getBuildFlags())
         self.do_thread_actions(num_watchpoint_threads=100)
 
     @unittest2.skipIf(TestBase.skipLongRunningTest(), "Skip this long running test")
+    @expectedFailureAll(triple = '^mips') # Atomic sequences are not supported yet for MIPS in LLDB.
     def test_many_signals(self):
         """Test 100 signals from 100 threads."""
         self.build(dictionary=self.getBuildFlags())
         self.do_thread_actions(num_signal_threads=100)
 
     @unittest2.skipIf(TestBase.skipLongRunningTest(), "Skip this long running test")
+    @expectedFailureAll(triple = '^mips') # Atomic sequences are not supported yet for MIPS in LLDB.
     def test_many_crash(self):
         """Test 100 threads that cause a segfault."""
         self.build(dictionary=self.getBuildFlags())
@@ -58,18 +62,21 @@ class ConcurrentEventsTestCase(TestBase):
     ## Tests for concurrent signal and breakpoint
     #
     @skipIfFreeBSD # timing out on buildbot
+    @expectedFailureAll(triple = '^mips') # Atomic sequences are not supported yet for MIPS in LLDB.
     def test_signal_break(self):
         """Test signal and a breakpoint in multiple threads."""
         self.build(dictionary=self.getBuildFlags())
         self.do_thread_actions(num_breakpoint_threads=1, num_signal_threads=1)
 
     @skipIfFreeBSD # timing out on buildbot
+    @expectedFailureAll(triple = '^mips') # Atomic sequences are not supported yet for MIPS in LLDB.
     def test_delay_signal_break(self):
         """Test (1-second delay) signal and a breakpoint in multiple threads."""
         self.build(dictionary=self.getBuildFlags())
         self.do_thread_actions(num_breakpoint_threads=1, num_delay_signal_threads=1)
 
     @skipIfFreeBSD # timing out on buildbot
+    @expectedFailureAll(triple = '^mips') # Atomic sequences are not supported yet for MIPS in LLDB.
     def test_signal_delay_break(self):
         """Test signal and a (1 second delay) breakpoint in multiple threads."""
         self.build(dictionary=self.getBuildFlags())
@@ -81,6 +88,7 @@ class ConcurrentEventsTestCase(TestBase):
     #
     @skipIfFreeBSD # timing out on buildbot
     @skipIfRemoteDueToDeadlock
+    @expectedFailureAll(triple = '^mips') # Atomic sequences are not supported yet for MIPS in LLDB.
     def test_watch_break(self):
         """Test watchpoint and a breakpoint in multiple threads."""
         self.build(dictionary=self.getBuildFlags())
@@ -88,6 +96,7 @@ class ConcurrentEventsTestCase(TestBase):
 
     @skipIfFreeBSD # timing out on buildbot
     @skipIfRemoteDueToDeadlock
+    @expectedFailureAll(triple = '^mips') # Atomic sequences are not supported yet for MIPS in LLDB.
     def test_delay_watch_break(self):
         """Test (1-second delay) watchpoint and a breakpoint in multiple threads."""
         self.build(dictionary=self.getBuildFlags())
@@ -95,6 +104,7 @@ class ConcurrentEventsTestCase(TestBase):
 
     @skipIfFreeBSD # timing out on buildbot
     @skipIfRemoteDueToDeadlock
+    @expectedFailureAll(triple = '^mips') # Atomic sequences are not supported yet for MIPS in LLDB.
     def test_watch_break_delay(self):
         """Test watchpoint and a (1 second delay) breakpoint in multiple threads."""
         self.build(dictionary=self.getBuildFlags())
@@ -105,6 +115,7 @@ class ConcurrentEventsTestCase(TestBase):
     #
     @skipIfFreeBSD # timing out on buildbot
     @skipIfRemoteDueToDeadlock
+    @expectedFailureAll(triple = '^mips') # Atomic sequences are not supported yet for MIPS in LLDB.
     def test_signal_watch(self):
         """Test a watchpoint and a signal in multiple threads."""
         self.build(dictionary=self.getBuildFlags())
@@ -112,6 +123,7 @@ class ConcurrentEventsTestCase(TestBase):
 
     @skipIfFreeBSD # timing out on buildbot
     @skipIfRemoteDueToDeadlock
+    @expectedFailureAll(triple = '^mips') # Atomic sequences are not supported yet for MIPS in LLDB.
     def test_delay_signal_watch(self):
         """Test a watchpoint and a (1 second delay) signal in multiple threads."""
         self.build(dictionary=self.getBuildFlags())
@@ -119,7 +131,7 @@ class ConcurrentEventsTestCase(TestBase):
 
     @skipIfFreeBSD # timing out on buildbot
     @skipIfRemoteDueToDeadlock
-    @expectedFailureAll("llvm.org/pr16714", oslist=["linux"], archs=["i386"])
+    @expectedFailureAll(triple = '^mips') # Atomic sequences are not supported yet for MIPS in LLDB.
     def test_signal_delay_watch(self):
         """Test a (1 second delay) watchpoint and a signal in multiple threads."""
         self.build(dictionary=self.getBuildFlags())
@@ -130,12 +142,14 @@ class ConcurrentEventsTestCase(TestBase):
     ## Tests for multiple breakpoint threads
     #
     @skipIfFreeBSD # timing out on buildbot
+    @expectedFailureAll(triple = '^mips') # Atomic sequences are not supported yet for MIPS in LLDB.
     def test_two_breakpoint_threads(self):
         """Test two threads that trigger a breakpoint. """
         self.build(dictionary=self.getBuildFlags())
         self.do_thread_actions(num_breakpoint_threads=2)
 
     @skipIfFreeBSD # timing out on buildbot
+    @expectedFailureAll(triple = '^mips') # Atomic sequences are not supported yet for MIPS in LLDB.
     def test_breakpoint_one_delay_breakpoint_threads(self):
         """Test threads that trigger a breakpoint where one thread has a 1 second delay. """
         self.build(dictionary=self.getBuildFlags())
@@ -143,12 +157,14 @@ class ConcurrentEventsTestCase(TestBase):
                                num_delay_breakpoint_threads=1)
 
     @skipIfFreeBSD # timing out on buildbot
+    @expectedFailureAll(triple = '^mips') # Atomic sequences are not supported yet for MIPS in LLDB.
     def test_two_breakpoints_one_signal(self):
         """Test two threads that trigger a breakpoint and one signal thread. """
         self.build(dictionary=self.getBuildFlags())
         self.do_thread_actions(num_breakpoint_threads=2, num_signal_threads=1)
 
     @skipIfFreeBSD # timing out on buildbot
+    @expectedFailureAll(triple = '^mips') # Atomic sequences are not supported yet for MIPS in LLDB.
     def test_breakpoint_delay_breakpoint_one_signal(self):
         """Test two threads that trigger a breakpoint (one with a 1 second delay) and one signal thread. """
         self.build(dictionary=self.getBuildFlags())
@@ -157,6 +173,7 @@ class ConcurrentEventsTestCase(TestBase):
                                num_signal_threads=1)
 
     @skipIfFreeBSD # timing out on buildbot
+    @expectedFailureAll(triple = '^mips') # Atomic sequences are not supported yet for MIPS in LLDB.
     def test_two_breakpoints_one_delay_signal(self):
         """Test two threads that trigger a breakpoint and one (1 second delay) signal thread. """
         self.build(dictionary=self.getBuildFlags())
@@ -164,6 +181,7 @@ class ConcurrentEventsTestCase(TestBase):
 
     @skipIfFreeBSD # timing out on buildbot
     @skipIfRemoteDueToDeadlock
+    @expectedFailureAll(triple = '^mips') # Atomic sequences are not supported yet for MIPS in LLDB.
     def test_two_breakpoints_one_watchpoint(self):
         """Test two threads that trigger a breakpoint and one watchpoint thread. """
         self.build(dictionary=self.getBuildFlags())
@@ -171,6 +189,7 @@ class ConcurrentEventsTestCase(TestBase):
 
     @skipIfFreeBSD # timing out on buildbot
     @skipIfRemoteDueToDeadlock
+    @expectedFailureAll(triple = '^mips') # Atomic sequences are not supported yet for MIPS in LLDB.
     def test_breakpoints_delayed_breakpoint_one_watchpoint(self):
         """Test a breakpoint, a delayed breakpoint, and one watchpoint thread. """
         self.build(dictionary=self.getBuildFlags())
@@ -183,6 +202,7 @@ class ConcurrentEventsTestCase(TestBase):
     #
     @skipIfFreeBSD # timing out on buildbot
     @skipIfRemoteDueToDeadlock
+    @expectedFailureAll(triple = '^mips') # Atomic sequences are not supported yet for MIPS in LLDB.
     def test_two_watchpoint_threads(self):
         """Test two threads that trigger a watchpoint. """
         self.build(dictionary=self.getBuildFlags())
@@ -190,6 +210,7 @@ class ConcurrentEventsTestCase(TestBase):
 
     @skipIfFreeBSD # timing out on buildbot
     @skipIfRemoteDueToDeadlock
+    @expectedFailureAll(triple = '^mips') # Atomic sequences are not supported yet for MIPS in LLDB.
     def test_watchpoint_with_delay_watchpoint_threads(self):
         """Test two threads that trigger a watchpoint where one thread has a 1 second delay. """
         self.build(dictionary=self.getBuildFlags())
@@ -198,6 +219,7 @@ class ConcurrentEventsTestCase(TestBase):
 
     @skipIfFreeBSD # timing out on buildbot
     @skipIfRemoteDueToDeadlock
+    @expectedFailureAll(triple = '^mips') # Atomic sequences are not supported yet for MIPS in LLDB.
     def test_two_watchpoints_one_breakpoint(self):
         """Test two threads that trigger a watchpoint and one breakpoint thread. """
         self.build(dictionary=self.getBuildFlags())
@@ -205,6 +227,7 @@ class ConcurrentEventsTestCase(TestBase):
 
     @skipIfFreeBSD # timing out on buildbot
     @skipIfRemoteDueToDeadlock
+    @expectedFailureAll(triple = '^mips') # Atomic sequences are not supported yet for MIPS in LLDB.
     def test_two_watchpoints_one_delay_breakpoint(self):
         """Test two threads that trigger a watchpoint and one (1 second delay) breakpoint thread. """
         self.build(dictionary=self.getBuildFlags())
@@ -212,6 +235,7 @@ class ConcurrentEventsTestCase(TestBase):
 
     @skipIfFreeBSD # timing out on buildbot
     @skipIfRemoteDueToDeadlock
+    @expectedFailureAll(triple = '^mips') # Atomic sequences are not supported yet for MIPS in LLDB.
     def test_watchpoint_delay_watchpoint_one_breakpoint(self):
         """Test two threads that trigger a watchpoint (one with a 1 second delay) and one breakpoint thread. """
         self.build(dictionary=self.getBuildFlags())
@@ -221,6 +245,7 @@ class ConcurrentEventsTestCase(TestBase):
 
     @skipIfFreeBSD # timing out on buildbot
     @skipIfRemoteDueToDeadlock
+    @expectedFailureAll(triple = '^mips') # Atomic sequences are not supported yet for MIPS in LLDB.
     def test_two_watchpoints_one_signal(self):
         """Test two threads that trigger a watchpoint and one signal thread. """
         self.build(dictionary=self.getBuildFlags())
@@ -231,6 +256,7 @@ class ConcurrentEventsTestCase(TestBase):
     #
     @skipIfFreeBSD # timing out on buildbot
     @skipIfRemoteDueToDeadlock
+    @expectedFailureAll(triple = '^mips') # Atomic sequences are not supported yet for MIPS in LLDB.
     def test_signal_watch_break(self):
         """Test a signal/watchpoint/breakpoint in multiple threads."""
         self.build(dictionary=self.getBuildFlags())
@@ -240,6 +266,7 @@ class ConcurrentEventsTestCase(TestBase):
 
     @skipIfFreeBSD # timing out on buildbot
     @skipIfRemoteDueToDeadlock
+    @expectedFailureAll(triple = '^mips') # Atomic sequences are not supported yet for MIPS in LLDB.
     def test_signal_watch_break(self):
         """Test one signal thread with 5 watchpoint and breakpoint threads."""
         self.build(dictionary=self.getBuildFlags())
@@ -249,6 +276,7 @@ class ConcurrentEventsTestCase(TestBase):
 
     @skipIfFreeBSD # timing out on buildbot
     @skipIfRemoteDueToDeadlock
+    @expectedFailureAll(triple = '^mips') # Atomic sequences are not supported yet for MIPS in LLDB.
     def test_signal_watch_break(self):
         """Test with 5 watchpoint and breakpoint threads."""
         self.build(dictionary=self.getBuildFlags())
@@ -260,6 +288,7 @@ class ConcurrentEventsTestCase(TestBase):
     ## Test for crashing threads happening concurrently with other events
     #
     @skipIfFreeBSD # timing out on buildbot
+    @expectedFailureAll(triple = '^mips') # Atomic sequences are not supported yet for MIPS in LLDB.
     def test_crash_with_break(self):
         """ Test a thread that crashes while another thread hits a breakpoint."""
         self.build(dictionary=self.getBuildFlags())
@@ -267,12 +296,14 @@ class ConcurrentEventsTestCase(TestBase):
 
     @skipIfFreeBSD # timing out on buildbot
     @skipIfRemoteDueToDeadlock
+    @expectedFailureAll(triple = '^mips') # Atomic sequences are not supported yet for MIPS in LLDB.
     def test_crash_with_watchpoint(self):
         """ Test a thread that crashes while another thread hits a watchpoint."""
         self.build(dictionary=self.getBuildFlags())
         self.do_thread_actions(num_crash_threads=1, num_watchpoint_threads=1)
 
     @skipIfFreeBSD # timing out on buildbot
+    @expectedFailureAll(triple = '^mips') # Atomic sequences are not supported yet for MIPS in LLDB.
     def test_crash_with_signal(self):
         """ Test a thread that crashes while another thread generates a signal."""
         self.build(dictionary=self.getBuildFlags())
@@ -280,6 +311,7 @@ class ConcurrentEventsTestCase(TestBase):
 
     @skipIfFreeBSD # timing out on buildbot
     @skipIfRemoteDueToDeadlock
+    @expectedFailureAll(triple = '^mips') # Atomic sequences are not supported yet for MIPS in LLDB.
     def test_crash_with_watchpoint_breakpoint_signal(self):
         """ Test a thread that crashes while other threads generate a signal and hit a watchpoint and breakpoint. """
         self.build(dictionary=self.getBuildFlags())
@@ -290,6 +322,7 @@ class ConcurrentEventsTestCase(TestBase):
 
     @skipIfFreeBSD # timing out on buildbot
     @skipIfRemoteDueToDeadlock
+    @expectedFailureAll(triple = '^mips') # Atomic sequences are not supported yet for MIPS in LLDB.
     def test_delayed_crash_with_breakpoint_watchpoint(self):
         """ Test a thread with a delayed crash while other threads hit a watchpoint and a breakpoint. """
         self.build(dictionary=self.getBuildFlags())
@@ -298,6 +331,7 @@ class ConcurrentEventsTestCase(TestBase):
                                num_watchpoint_threads=1)
 
     @skipIfFreeBSD # timing out on buildbot
+    @expectedFailureAll(triple = '^mips') # Atomic sequences are not supported yet for MIPS in LLDB.
     def test_delayed_crash_with_breakpoint_signal(self):
         """ Test a thread with a delayed crash while other threads generate a signal and hit a breakpoint. """
         self.build(dictionary=self.getBuildFlags())
diff --git a/packages/Python/lldbsuite/test/functionalities/thread/concurrent_events/main.cpp b/packages/Python/lldbsuite/test/functionalities/thread/concurrent_events/main.cpp
index ac2535cd2bff..10b55bff3ba4 100644
--- a/packages/Python/lldbsuite/test/functionalities/thread/concurrent_events/main.cpp
+++ b/packages/Python/lldbsuite/test/functionalities/thread/concurrent_events/main.cpp
@@ -23,22 +23,10 @@ using namespace std;
 #include <sys/types.h>
 #include <unistd.h>
 
-// Note that although hogging the CPU while waiting for a variable to change
-// would be terrible in production code, it's great for testing since it
-// avoids a lot of messy context switching to get multiple threads synchronized.
-#define do_nothing()
-
-#define pseudo_barrier_wait(bar) \
-    --bar;                       \
-    while (bar > 0)              \
-        do_nothing();
-
-#define pseudo_barrier_init(bar, count) (bar = count)
-
 typedef std::vector<std::pair<unsigned, void*(*)(void*)> > action_counts;
 typedef std::vector<pthread_t> thread_vector;
 
-std::atomic_int g_barrier;
+pseudo_barrier_t g_barrier;
 int g_breakpoint = 0;
 int g_sigusr1_count = 0;
 std::atomic_int g_watchme;
diff --git a/packages/Python/lldbsuite/test/functionalities/thread/crash_during_step/TestCrashDuringStep.py b/packages/Python/lldbsuite/test/functionalities/thread/crash_during_step/TestCrashDuringStep.py
index 24b5bf0dad36..edd1e885ca9e 100644
--- a/packages/Python/lldbsuite/test/functionalities/thread/crash_during_step/TestCrashDuringStep.py
+++ b/packages/Python/lldbsuite/test/functionalities/thread/crash_during_step/TestCrashDuringStep.py
@@ -8,8 +8,9 @@ from __future__ import print_function
 
 import os
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbutil
 
 class CreateDuringStepTestCase(TestBase):
 
@@ -19,9 +20,10 @@ class CreateDuringStepTestCase(TestBase):
         TestBase.setUp(self)
         self.breakpoint = line_number('main.cpp', '// Set breakpoint here')
 
-    @expectedFailureWindows("llvm.org/pr24778")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778")
     @expectedFailureAndroid("llvm.org/pr24497", archs=['arm', 'aarch64'])
-    @expectedFailureAll(archs=['mips', 'mipsel', 'mips64', 'mips64el'])    # IO error due to breakpoint at invalid address
+    @expectedFailureAll(oslist=["linux"], archs=["arm"], bugnumber="llvm.org/pr24497")
+    @expectedFailureAll(triple = re.compile('^mips'))    # IO error due to breakpoint at invalid address
     def test_step_inst_with(self):
         """Test thread creation during step-inst handling."""
         self.build(dictionary=self.getBuildFlags())
@@ -38,11 +40,8 @@ class CreateDuringStepTestCase(TestBase):
 
         # The stop reason should be breakpoint.
         self.assertEqual(process.GetState(), lldb.eStateStopped, PROCESS_STOPPED)
-        self.assertEqual(lldbutil.get_stopped_thread(process, lldb.eStopReasonBreakpoint).IsValid(), 1,
-                STOPPED_DUE_TO_BREAKPOINT)
-
-        thread = process.GetThreadAtIndex(0)
-        self.assertTrue(thread and thread.IsValid(), "Thread is valid")
+        thread = lldbutil.get_stopped_thread(process, lldb.eStopReasonBreakpoint)
+        self.assertTrue(thread.IsValid(), STOPPED_DUE_TO_BREAKPOINT)
 
         # Keep stepping until the inferior crashes
         while process.GetState() == lldb.eStateStopped and not lldbutil.is_thread_crashed(self, thread):
diff --git a/packages/Python/lldbsuite/test/functionalities/thread/create_after_attach/TestCreateAfterAttach.py b/packages/Python/lldbsuite/test/functionalities/thread/create_after_attach/TestCreateAfterAttach.py
index 977254343aa0..1cb97355395f 100644
--- a/packages/Python/lldbsuite/test/functionalities/thread/create_after_attach/TestCreateAfterAttach.py
+++ b/packages/Python/lldbsuite/test/functionalities/thread/create_after_attach/TestCreateAfterAttach.py
@@ -8,8 +8,9 @@ from __future__ import print_function
 
 import os, time
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbutil
 
 class CreateAfterAttachTestCase(TestBase):
 
@@ -29,7 +30,6 @@ class CreateAfterAttachTestCase(TestBase):
                    # for FreeBSD.
     @skipIfRemote
     @skipIfWindows # Windows doesn't have fork.
-    @expectedFlakeyLinux("llvm.org/pr16229") # 1/100 dosep, build 3546, clang-3.5 x84_64
     @skipIfiOSSimulator
     def test_create_after_attach_with_fork(self):
         """Test thread creation after process attach."""
diff --git a/packages/Python/lldbsuite/test/functionalities/thread/create_during_step/TestCreateDuringStep.py b/packages/Python/lldbsuite/test/functionalities/thread/create_during_step/TestCreateDuringStep.py
index 046a86509c0f..9401826e304e 100644
--- a/packages/Python/lldbsuite/test/functionalities/thread/create_during_step/TestCreateDuringStep.py
+++ b/packages/Python/lldbsuite/test/functionalities/thread/create_during_step/TestCreateDuringStep.py
@@ -8,35 +8,36 @@ from __future__ import print_function
 
 import os, time
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbutil
 
 class CreateDuringStepTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @expectedFailureDarwin("llvm.org/pr15824") # thread states not properly maintained
-    @expectedFailureFreeBSD("llvm.org/pr18190") # thread states not properly maintained
-    @expectedFailureLinux("llvm.org/pr15824") # thread states not properly maintained
-    @expectedFailureWindows("llvm.org/pr24668") # Breakpoints not resolved correctly
+    @expectedFailureAll(oslist=["linux"], bugnumber="llvm.org/pr15824 thread states not properly maintained")
+    @expectedFailureAll(oslist=lldbplatformutil.getDarwinOSTriples(), bugnumber="llvm.org/pr15824 thread states not properly maintained")
+    @expectedFailureAll(oslist=["freebsd"], bugnumber="llvm.org/pr18190 thread states not properly maintained")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24668: Breakpoints not resolved correctly")
     def test_step_inst(self):
         """Test thread creation during step-inst handling."""
         self.build(dictionary=self.getBuildFlags())
         self.create_during_step_base("thread step-inst -m all-threads", 'stop reason = instruction step')
 
-    @expectedFailureDarwin("llvm.org/pr15824") # thread states not properly maintained
-    @expectedFailureFreeBSD("llvm.org/pr18190") # thread states not properly maintained
-    @expectedFailureLinux("llvm.org/pr15824") # thread states not properly maintained
-    @expectedFailureWindows("llvm.org/pr24668") # Breakpoints not resolved correctly
+    @expectedFailureAll(oslist=["linux"], bugnumber="llvm.org/pr15824 thread states not properly maintained")
+    @expectedFailureAll(oslist=lldbplatformutil.getDarwinOSTriples(), bugnumber="llvm.org/pr15824 thread states not properly maintained")
+    @expectedFailureAll(oslist=["freebsd"], bugnumber="llvm.org/pr18190 thread states not properly maintained")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24668: Breakpoints not resolved correctly")
     def test_step_over(self):
         """Test thread creation during step-over handling."""
         self.build(dictionary=self.getBuildFlags())
         self.create_during_step_base("thread step-over -m all-threads", 'stop reason = step over')
 
-    @expectedFailureDarwin("llvm.org/pr15824") # thread states not properly maintained
-    @expectedFailureFreeBSD("llvm.org/pr18190") # thread states not properly maintained
-    @expectedFailureLinux("llvm.org/pr15824") # thread states not properly maintained
-    @expectedFailureWindows("llvm.org/pr24668") # Breakpoints not resolved correctly
+    @expectedFailureAll(oslist=["linux"], bugnumber="llvm.org/pr15824 thread states not properly maintained")
+    @expectedFailureAll(oslist=lldbplatformutil.getDarwinOSTriples(), bugnumber="llvm.org/pr15824 thread states not properly maintained")
+    @expectedFailureAll(oslist=["freebsd"], bugnumber="llvm.org/pr18190 thread states not properly maintained")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24668: Breakpoints not resolved correctly")
     def test_step_in(self):
         """Test thread creation during step-in handling."""
         self.build(dictionary=self.getBuildFlags())
diff --git a/packages/Python/lldbsuite/test/functionalities/thread/create_during_step/main.cpp b/packages/Python/lldbsuite/test/functionalities/thread/create_during_step/main.cpp
index 3a00248c022a..70681fd11603 100644
--- a/packages/Python/lldbsuite/test/functionalities/thread/create_during_step/main.cpp
+++ b/packages/Python/lldbsuite/test/functionalities/thread/create_during_step/main.cpp
@@ -13,19 +13,9 @@
 #include <atomic>
 #include <thread>
 
-// Note that although hogging the CPU while waiting for a variable to change
-// would be terrible in production code, it's great for testing since it
-// avoids a lot of messy context switching to get multiple threads synchronized.
 #define do_nothing()
 
-#define pseudo_barrier_wait(bar) \
-    --bar;                       \
-    while (bar > 0)              \
-        do_nothing();
-
-#define pseudo_barrier_init(bar, count) (bar = count)
-
-std::atomic_int g_barrier;
+pseudo_barrier_t g_barrier;
 
 volatile int g_thread_created = 0;
 volatile int g_test = 0;
diff --git a/packages/Python/lldbsuite/test/functionalities/thread/exit_during_break/TestExitDuringBreak.py b/packages/Python/lldbsuite/test/functionalities/thread/exit_during_break/TestExitDuringBreak.py
index f999ffe108f3..2c394263d36e 100644
--- a/packages/Python/lldbsuite/test/functionalities/thread/exit_during_break/TestExitDuringBreak.py
+++ b/packages/Python/lldbsuite/test/functionalities/thread/exit_during_break/TestExitDuringBreak.py
@@ -8,8 +8,9 @@ from __future__ import print_function
 
 import os, time
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbutil
 
 class ExitDuringBreakpointTestCase(TestBase):
 
@@ -21,10 +22,10 @@ class ExitDuringBreakpointTestCase(TestBase):
         # Find the line number for our breakpoint.
         self.breakpoint = line_number('main.cpp', '// Set breakpoint here')
 
-    @expectedFailureDarwin("llvm.org/pr15824") # thread states not properly maintained
-    @expectedFailureFreeBSD("llvm.org/pr18190") # thread states not properly maintained
-    @expectedFailureLinux("llvm.org/pr15824") # thread states not properly maintained
-    @expectedFailureWindows("llvm.org/pr24668") # Breakpoints not resolved correctly
+    @expectedFailureAll(oslist=["linux"], bugnumber="llvm.org/pr15824 thread states not properly maintained")
+    @expectedFailureAll(oslist=lldbplatformutil.getDarwinOSTriples(), bugnumber="llvm.org/pr15824 thread states not properly maintained")
+    @expectedFailureAll(oslist=["freebsd"], bugnumber="llvm.org/pr18190 thread states not properly maintained")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24668: Breakpoints not resolved correctly")
     def test(self):
         """Test thread exit during breakpoint handling."""
         self.build(dictionary=self.getBuildFlags())
diff --git a/packages/Python/lldbsuite/test/functionalities/thread/exit_during_break/main.cpp b/packages/Python/lldbsuite/test/functionalities/thread/exit_during_break/main.cpp
index 3570637207d2..a032da835ea6 100644
--- a/packages/Python/lldbsuite/test/functionalities/thread/exit_during_break/main.cpp
+++ b/packages/Python/lldbsuite/test/functionalities/thread/exit_during_break/main.cpp
@@ -19,27 +19,15 @@
 
 volatile int g_test = 0;
 
-// Note that although hogging the CPU while waiting for a variable to change
-// would be terrible in production code, it's great for testing since it
-// avoids a lot of messy context switching to get multiple threads synchronized.
-#define do_nothing()  
-
-#define pseudo_barrier_wait(bar) \
-    --bar;                       \
-    while (bar > 0)              \
-        do_nothing();
-
-#define pseudo_barrier_init(bar, count) (bar = count)
-
 // A barrier to synchronize all the threads except the one that will exit.
-std::atomic_int g_barrier1;
+pseudo_barrier_t g_barrier1;
 
 // A barrier to synchronize all the threads including the one that will exit.
-std::atomic_int g_barrier2;
+pseudo_barrier_t g_barrier2;
 
 // A barrier to keep the first group of threads from exiting until after the
 // breakpoint has been passed.
-std::atomic_int g_barrier3;
+pseudo_barrier_t g_barrier3;
 
 void *
 break_thread_func ()
diff --git a/packages/Python/lldbsuite/test/functionalities/thread/exit_during_step/TestExitDuringStep.py b/packages/Python/lldbsuite/test/functionalities/thread/exit_during_step/TestExitDuringStep.py
index 67d1c96fd342..af4a022ed0c1 100644
--- a/packages/Python/lldbsuite/test/functionalities/thread/exit_during_step/TestExitDuringStep.py
+++ b/packages/Python/lldbsuite/test/functionalities/thread/exit_during_step/TestExitDuringStep.py
@@ -8,42 +8,31 @@ from __future__ import print_function
 
 import os, time
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbutil
 
 class ExitDuringStepTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @expectedFailureDarwin("llvm.org/pr15824") # thread states not properly maintained
-    @expectedFailureFreeBSD("llvm.org/pr18190") # thread states not properly maintained
-    @expectedFailureLinux("llvm.org/pr15824") # thread states not properly maintained
-    @expectedFailureWindows("llvm.org/pr24681")
-    def test_thread_state_is_stopped(self):
-        """Test thread exit during step handling."""
-        self.build(dictionary=self.getBuildFlags())
-        self.exit_during_step_base("thread step-in -m all-threads", 'stop reason = step in', True)
-
     @skipIfFreeBSD # llvm.org/pr21411: test is hanging
-    @expectedFailureWindows("llvm.org/pr24681")
     def test(self):
         """Test thread exit during step handling."""
         self.build(dictionary=self.getBuildFlags())
-        self.exit_during_step_base("thread step-inst -m all-threads", 'stop reason = instruction step', False)
+        self.exit_during_step_base("thread step-inst -m all-threads", 'stop reason = instruction step')
 
     @skipIfFreeBSD # llvm.org/pr21411: test is hanging
-    @expectedFailureWindows("llvm.org/pr24681")
     def test_step_over(self):
         """Test thread exit during step-over handling."""
         self.build(dictionary=self.getBuildFlags())
-        self.exit_during_step_base("thread step-over -m all-threads", 'stop reason = step over', False)
+        self.exit_during_step_base("thread step-over -m all-threads", 'stop reason = step over')
 
     @skipIfFreeBSD # llvm.org/pr21411: test is hanging
-    @expectedFailureWindows("llvm.org/pr24681")
     def test_step_in(self):
         """Test thread exit during step-in handling."""
         self.build(dictionary=self.getBuildFlags())
-        self.exit_during_step_base("thread step-in -m all-threads", 'stop reason = step in', False)
+        self.exit_during_step_base("thread step-in -m all-threads", 'stop reason = step in')
 
     def setUp(self):
         # Call super's setUp().
@@ -52,7 +41,7 @@ class ExitDuringStepTestCase(TestBase):
         self.breakpoint = line_number('main.cpp', '// Set breakpoint here')
         self.continuepoint = line_number('main.cpp', '// Continue from here')
 
-    def exit_during_step_base(self, step_cmd, step_stop_reason, test_thread_state):
+    def exit_during_step_base(self, step_cmd, step_stop_reason):
         """Test thread exit during step handling."""
         exe = os.path.join(os.getcwd(), "a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
@@ -76,37 +65,16 @@ class ExitDuringStepTestCase(TestBase):
         target = self.dbg.GetSelectedTarget()
         process = target.GetProcess()
 
-        # Get the number of threads
         num_threads = process.GetNumThreads()
-
         # Make sure we see all three threads
-        self.assertTrue(num_threads == 3, 'Number of expected threads and actual threads do not match.')
-
-        # Get the thread objects
-        thread1 = process.GetThreadAtIndex(0)
-        thread2 = process.GetThreadAtIndex(1)
-        thread3 = process.GetThreadAtIndex(2)
-
-        # Make sure all threads are stopped
-        if test_thread_state:
-            self.assertTrue(thread1.IsStopped(), "Thread 1 didn't stop during breakpoint")
-            self.assertTrue(thread2.IsStopped(), "Thread 2 didn't stop during breakpoint")
-            self.assertTrue(thread3.IsStopped(), "Thread 3 didn't stop during breakpoint")
-            return
-
-        # Find the thread that is stopped at the breakpoint
-        stepping_thread = None
-        for thread in process:
-            expected_bp_desc = "breakpoint %s." % self.bp_num
-            stop_desc = thread.GetStopDescription(100)
-            if stop_desc and (expected_bp_desc in stop_desc):
-                stepping_thread = thread
-                break
-        self.assertTrue(stepping_thread != None, "unable to find thread stopped at %s" % expected_bp_desc)
+        self.assertGreaterEqual(num_threads, 3, 'Number of expected threads and actual threads do not match.')
+
+        stepping_thread = lldbutil.get_one_thread_stopped_at_breakpoint_id(process, self.bp_num)
+        self.assertIsNotNone(stepping_thread, "Could not find a thread stopped at the breakpoint")
 
         current_line = self.breakpoint
         stepping_frame = stepping_thread.GetFrameAtIndex(0)
-        self.assertTrue(current_line == stepping_frame.GetLineEntry().GetLine(), "Starting line for stepping doesn't match breakpoint line.")
+        self.assertEqual(current_line, stepping_frame.GetLineEntry().GetLine(), "Starting line for stepping doesn't match breakpoint line.")
 
         # Keep stepping until we've reached our designated continue point
         while current_line != self.continuepoint:
@@ -122,16 +90,16 @@ class ExitDuringStepTestCase(TestBase):
 
             current_line = frame.GetLineEntry().GetLine()
 
-            self.assertTrue(current_line >= self.breakpoint, "Stepped to unexpected line, " + str(current_line))
-            self.assertTrue(current_line <= self.continuepoint, "Stepped to unexpected line, " + str(current_line))
+            self.assertGreaterEqual(current_line, self.breakpoint, "Stepped to unexpected line, " + str(current_line))
+            self.assertLessEqual(current_line, self.continuepoint, "Stepped to unexpected line, " + str(current_line))
 
         self.runCmd("thread list")
 
         # Update the number of threads
-        num_threads = process.GetNumThreads()
+        new_num_threads = process.GetNumThreads()
 
         # Check to see that we reduced the number of threads as expected
-        self.assertTrue(num_threads == 2, 'Number of expected threads and actual threads do not match after thread exit.')
+        self.assertEqual(new_num_threads, num_threads-1, 'Number of threads did not reduce by 1 after thread exit.')
 
         self.expect("thread list", 'Process state is stopped due to step',
                 substrs = ['stopped',
@@ -141,4 +109,4 @@ class ExitDuringStepTestCase(TestBase):
         self.runCmd("continue")
 
         # At this point, the inferior process should have exited.
-        self.assertTrue(process.GetState() == lldb.eStateExited, PROCESS_EXITED)
+        self.assertEqual(process.GetState(), lldb.eStateExited, PROCESS_EXITED)
diff --git a/packages/Python/lldbsuite/test/functionalities/thread/exit_during_step/main.cpp b/packages/Python/lldbsuite/test/functionalities/thread/exit_during_step/main.cpp
index d1b364b8baa2..45adf28ce813 100644
--- a/packages/Python/lldbsuite/test/functionalities/thread/exit_during_step/main.cpp
+++ b/packages/Python/lldbsuite/test/functionalities/thread/exit_during_step/main.cpp
@@ -12,20 +12,10 @@
 
 #include <thread>
 
-// Note that although hogging the CPU while waiting for a variable to change
-// would be terrible in production code, it's great for testing since it
-// avoids a lot of messy context switching to get multiple threads synchronized.
 #define do_nothing()
 
-#define pseudo_barrier_wait(bar) \
-    --bar;                       \
-    while (bar > 0)              \
-        do_nothing();
-
-#define pseudo_barrier_init(bar, count) (bar = count)
-
 // A barrier to synchronize thread start.
-volatile int g_barrier;
+pseudo_barrier_t g_barrier;
 
 volatile int g_thread_exited = 0;
 
diff --git a/packages/Python/lldbsuite/test/functionalities/thread/jump/TestThreadJump.py b/packages/Python/lldbsuite/test/functionalities/thread/jump/TestThreadJump.py
index 768e2fe4f87a..4c55bcd982a7 100644
--- a/packages/Python/lldbsuite/test/functionalities/thread/jump/TestThreadJump.py
+++ b/packages/Python/lldbsuite/test/functionalities/thread/jump/TestThreadJump.py
@@ -8,8 +8,9 @@ from __future__ import print_function
 
 import os, time
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbutil
 
 class ThreadJumpTestCase(TestBase):
 
diff --git a/packages/Python/lldbsuite/test/functionalities/thread/multi_break/TestMultipleBreakpoints.py b/packages/Python/lldbsuite/test/functionalities/thread/multi_break/TestMultipleBreakpoints.py
index 9dd212412216..d4b1eb32a9ae 100644
--- a/packages/Python/lldbsuite/test/functionalities/thread/multi_break/TestMultipleBreakpoints.py
+++ b/packages/Python/lldbsuite/test/functionalities/thread/multi_break/TestMultipleBreakpoints.py
@@ -8,8 +8,9 @@ from __future__ import print_function
 
 import os, time
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbutil
 
 class MultipleBreakpointTestCase(TestBase):
 
@@ -21,10 +22,10 @@ class MultipleBreakpointTestCase(TestBase):
         # Find the line number for our breakpoint.
         self.breakpoint = line_number('main.cpp', '// Set breakpoint here')
 
-    @expectedFailureDarwin("llvm.org/pr15824") # thread states not properly maintained
-    @expectedFailureFreeBSD("llvm.org/pr18190") # thread states not properly maintained
-    @expectedFailureLinux("llvm.org/pr15824") # thread states not properly maintained
-    @expectedFailureWindows("llvm.org/pr24668") # Breakpoints not resolved correctly
+    @expectedFailureAll(oslist=["linux"], bugnumber="llvm.org/pr15824 thread states not properly maintained")
+    @expectedFailureAll(oslist=lldbplatformutil.getDarwinOSTriples(), bugnumber="llvm.org/pr15824 thread states not properly maintained")
+    @expectedFailureAll(oslist=["freebsd"], bugnumber="llvm.org/pr18190 thread states not properly maintained")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24668: Breakpoints not resolved correctly")
     def test(self):
         """Test simultaneous breakpoints in multiple threads."""
         self.build(dictionary=self.getBuildFlags())
@@ -55,7 +56,7 @@ class MultipleBreakpointTestCase(TestBase):
         num_threads = process.GetNumThreads()
 
         # Make sure we see all three threads
-        self.assertTrue(num_threads == 3, 'Number of expected threads and actual threads do not match.')
+        self.assertTrue(num_threads >= 3, 'Number of expected threads and actual threads do not match.')
 
         # Get the thread objects
         thread1 = process.GetThreadAtIndex(0)
diff --git a/packages/Python/lldbsuite/test/functionalities/thread/multi_break/main.cpp b/packages/Python/lldbsuite/test/functionalities/thread/multi_break/main.cpp
index 01f4b8f98ea7..c3d695dbc745 100644
--- a/packages/Python/lldbsuite/test/functionalities/thread/multi_break/main.cpp
+++ b/packages/Python/lldbsuite/test/functionalities/thread/multi_break/main.cpp
@@ -15,19 +15,7 @@
 #include <atomic>
 #include <thread>
 
-// Note that although hogging the CPU while waiting for a variable to change
-// would be terrible in production code, it's great for testing since it
-// avoids a lot of messy context switching to get multiple threads synchronized.
-#define do_nothing()
-
-#define pseudo_barrier_wait(bar) \
-    --bar;                       \
-    while (bar > 0)              \
-        do_nothing();
-
-#define pseudo_barrier_init(bar, count) (bar = count)
-
-std::atomic_int g_barrier;
+pseudo_barrier_t g_barrier;
 
 volatile int g_test = 0;
 
diff --git a/packages/Python/lldbsuite/test/functionalities/thread/state/TestThreadStates.py b/packages/Python/lldbsuite/test/functionalities/thread/state/TestThreadStates.py
index 4938ec50453e..5afb57bf4ba8 100644
--- a/packages/Python/lldbsuite/test/functionalities/thread/state/TestThreadStates.py
+++ b/packages/Python/lldbsuite/test/functionalities/thread/state/TestThreadStates.py
@@ -9,25 +9,26 @@ from __future__ import print_function
 import unittest2
 import os, time
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbutil
 
 class ThreadStateTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @expectedFailureDarwin("rdar://15367566")
-    @expectedFailureFreeBSD('llvm.org/pr15824')
-    @expectedFailureLinux("llvm.org/pr15824") # thread states not properly maintained
+    @expectedFailureAll(oslist=["linux"], bugnumber="llvm.org/pr15824 thread states not properly maintained")
+    @expectedFailureAll(oslist=lldbplatformutil.getDarwinOSTriples(), bugnumber="llvm.org/pr15824 thread states not properly maintained")
+    @expectedFailureAll(oslist=["freebsd"], bugnumber="llvm.org/pr18190 thread states not properly maintained")
     def test_state_after_breakpoint(self):
         """Test thread state after breakpoint."""
         self.build(dictionary=self.getBuildFlags(use_cpp11=False))
         self.thread_state_after_breakpoint_test()
 
     @skipIfDarwin # 'llvm.org/pr23669', cause Python crash randomly
-    @expectedFailureDarwin('llvm.org/pr23669')
-    @expectedFailureFreeBSD('llvm.org/pr15824')
-    @expectedFailureWindows("llvm.org/pr24660")
+    @expectedFailureAll(oslist=lldbplatformutil.getDarwinOSTriples(), bugnumber="llvm.org/pr23669")
+    @expectedFailureAll(oslist=["freebsd"], bugnumber="llvm.org/pr15824")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24660")
     def test_state_after_continue(self):
         """Test thread state after continue."""
         self.build(dictionary=self.getBuildFlags(use_cpp11=False))
@@ -35,7 +36,7 @@ class ThreadStateTestCase(TestBase):
 
     @skipIfDarwin # 'llvm.org/pr23669', cause Python crash randomly
     @expectedFailureDarwin('llvm.org/pr23669')
-    @expectedFailureWindows("llvm.org/pr24660")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24660")
     @unittest2.expectedFailure("llvm.org/pr16712") # thread states not properly maintained
     def test_state_after_expression(self):
         """Test thread state after expression."""
@@ -43,14 +44,14 @@ class ThreadStateTestCase(TestBase):
         self.thread_state_after_expression_test()
 
     @unittest2.expectedFailure("llvm.org/pr16712") # thread states not properly maintained
-    @expectedFailureWindows("llvm.org/pr24668") # Breakpoints not resolved correctly
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24668: Breakpoints not resolved correctly")
     def test_process_interrupt(self):
         """Test process interrupt."""
         self.build(dictionary=self.getBuildFlags(use_cpp11=False))
         self.process_interrupt_test()
 
     @unittest2.expectedFailure("llvm.org/pr15824") # thread states not properly maintained
-    @expectedFailureWindows("llvm.org/pr24668") # Breakpoints not resolved correctly
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24668: Breakpoints not resolved correctly")
     def test_process_state(self):
         """Test thread states (comprehensive)."""
         self.build(dictionary=self.getBuildFlags(use_cpp11=False))
@@ -69,28 +70,17 @@ class ThreadStateTestCase(TestBase):
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         # This should create a breakpoint in the main thread.
-        lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.break_1, num_expected_locations=1)
+        bp = lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.break_1, num_expected_locations=1)
 
         # Run the program.
         self.runCmd("run", RUN_SUCCEEDED)
 
-        # The stop reason of the thread should be breakpoint.
-        self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
-            substrs = ['stopped',
-                       '* thread #1',
-                       'stop reason = breakpoint'])
-
         # Get the target process
         target = self.dbg.GetSelectedTarget()
         process = target.GetProcess()
 
-        # Get the number of threads
-        num_threads = process.GetNumThreads()
-
-        self.assertTrue(num_threads == 1, 'Number of expected threads and actual threads do not match.')
-
-        # Get the thread object
-        thread = process.GetThreadAtIndex(0)
+        thread = lldbutil.get_stopped_thread(process, lldb.eStopReasonBreakpoint)
+        self.assertIsNotNone(thread)
 
         # Make sure the thread is in the stopped state.
         self.assertTrue(thread.IsStopped(), "Thread state isn't \'stopped\' during breakpoint 1.")
@@ -99,11 +89,11 @@ class ThreadStateTestCase(TestBase):
         # Kill the process
         self.runCmd("process kill")
 
-    def wait_for_running_event(self):
+    def wait_for_running_event(self, process):
         listener = self.dbg.GetListener()
         if lldb.remote_platform:
-            lldbutil.expect_state_changes(self, listener, [lldb.eStateConnected])
-        lldbutil.expect_state_changes(self, listener, [lldb.eStateRunning])
+            lldbutil.expect_state_changes(self, listener, process, [lldb.eStateConnected])
+        lldbutil.expect_state_changes(self, listener, process, [lldb.eStateRunning])
 
     def thread_state_after_continue_test(self):
         """Test thread state after continue."""
@@ -117,28 +107,17 @@ class ThreadStateTestCase(TestBase):
         # Run the program.
         self.runCmd("run", RUN_SUCCEEDED)
 
-        # The stop reason of the thread should be breakpoint.
-        self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
-            substrs = ['stopped',
-                       '* thread #1',
-                       'stop reason = breakpoint'])
-
         # Get the target process
         target = self.dbg.GetSelectedTarget()
         process = target.GetProcess()
 
-        # Get the number of threads
-        num_threads = process.GetNumThreads()
-
-        self.assertTrue(num_threads == 1, 'Number of expected threads and actual threads do not match.')
-
-        # Get the thread object
-        thread = process.GetThreadAtIndex(0)
+        thread = lldbutil.get_stopped_thread(process, lldb.eStopReasonBreakpoint)
+        self.assertIsNotNone(thread)
 
         # Continue, the inferior will go into an infinite loop waiting for 'g_test' to change.
         self.dbg.SetAsync(True)
         self.runCmd("continue")
-        self.wait_for_running_event()
+        self.wait_for_running_event(process)
 
         # Check the thread state. It should be running.
         self.assertFalse(thread.IsStopped(), "Thread state is \'stopped\' when it should be running.")
@@ -162,23 +141,12 @@ class ThreadStateTestCase(TestBase):
         # Run the program.
         self.runCmd("run", RUN_SUCCEEDED)
 
-        # The stop reason of the thread should be breakpoint.
-        self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
-            substrs = ['stopped',
-                       '* thread #1',
-                       'stop reason = breakpoint'])
-
         # Get the target process
         target = self.dbg.GetSelectedTarget()
         process = target.GetProcess()
 
-        # Get the number of threads
-        num_threads = process.GetNumThreads()
-
-        self.assertTrue(num_threads == 1, 'Number of expected threads and actual threads do not match.')
-
-        # Get the thread object
-        thread = process.GetThreadAtIndex(0)
+        thread = lldbutil.get_stopped_thread(process, lldb.eStopReasonBreakpoint)
+        self.assertIsNotNone(thread)
 
         # Get the inferior out of its loop
         self.runCmd("expression g_test = 1")
@@ -202,25 +170,17 @@ class ThreadStateTestCase(TestBase):
         # Run the program.
         self.runCmd("run", RUN_SUCCEEDED)
 
-        # The stop reason of the thread should be breakpoint.
-        self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
-            substrs = ['stopped',
-                       '* thread #1',
-                       'stop reason = breakpoint'])
-
         # Get the target process
         target = self.dbg.GetSelectedTarget()
         process = target.GetProcess()
 
-        # Get the number of threads
-        num_threads = process.GetNumThreads()
-
-        self.assertTrue(num_threads == 1, 'Number of expected threads and actual threads do not match.')
+        thread = lldbutil.get_stopped_thread(process, lldb.eStopReasonBreakpoint)
+        self.assertIsNotNone(thread)
 
         # Continue, the inferior will go into an infinite loop waiting for 'g_test' to change.
         self.dbg.SetAsync(True)
         self.runCmd("continue")
-        self.wait_for_running_event()
+        self.wait_for_running_event(process)
 
         # Go back to synchronous interactions
         self.dbg.SetAsync(False)
@@ -228,11 +188,7 @@ class ThreadStateTestCase(TestBase):
         # Stop the process
         self.runCmd("process interrupt")
 
-        # The stop reason of the thread should be signal.
-        self.expect("process status", STOPPED_DUE_TO_SIGNAL,
-            substrs = ['stopped',
-                       '* thread #1',
-                       'stop reason = signal'])
+        self.assertEqual(thread.GetStopReason(), lldb.eStopReasonSignal)
 
         # Get the inferior out of its loop
         self.runCmd("expression g_test = 1")
@@ -252,23 +208,11 @@ class ThreadStateTestCase(TestBase):
         # Run the program.
         self.runCmd("run", RUN_SUCCEEDED)
 
-        # The stop reason of the thread should be breakpoint.
-        self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
-            substrs = ['stopped',
-                       '* thread #1',
-                       'stop reason = breakpoint'])
-
         # Get the target process
         target = self.dbg.GetSelectedTarget()
         process = target.GetProcess()
-
-        # Get the number of threads
-        num_threads = process.GetNumThreads()
-
-        self.assertTrue(num_threads == 1, 'Number of expected threads and actual threads do not match.')
-
-        # Get the thread object
-        thread = process.GetThreadAtIndex(0)
+        thread = lldbutil.get_stopped_thread(process, lldb.eStopReasonBreakpoint)
+        self.assertIsNotNone(thread)
 
         # Make sure the thread is in the stopped state.
         self.assertTrue(thread.IsStopped(), "Thread state isn't \'stopped\' during breakpoint 1.")
@@ -277,7 +221,7 @@ class ThreadStateTestCase(TestBase):
         # Continue, the inferior will go into an infinite loop waiting for 'g_test' to change.
         self.dbg.SetAsync(True)
         self.runCmd("continue")
-        self.wait_for_running_event()
+        self.wait_for_running_event(process)
 
         # Check the thread state. It should be running.
         self.assertFalse(thread.IsStopped(), "Thread state is \'stopped\' when it should be running.")
@@ -289,11 +233,7 @@ class ThreadStateTestCase(TestBase):
         # Stop the process
         self.runCmd("process interrupt")
 
-        # The stop reason of the thread should be signal.
-        self.expect("process status", STOPPED_DUE_TO_SIGNAL,
-            substrs = ['stopped',
-                       '* thread #1',
-                       'stop reason = signal'])
+        self.assertEqual(thread.GetState(), lldb.eStopReasonSignal)
 
         # Check the thread state
         self.assertTrue(thread.IsStopped(), "Thread state isn't \'stopped\' after process stop.")
@@ -306,20 +246,12 @@ class ThreadStateTestCase(TestBase):
         self.assertTrue(thread.IsStopped(), "Thread state isn't \'stopped\' after expression evaluation.")
         self.assertFalse(thread.IsSuspended(), "Thread state is \'suspended\' after expression evaluation.")
 
-        # The stop reason of the thread should be signal.
-        self.expect("process status", STOPPED_DUE_TO_SIGNAL,
-            substrs = ['stopped',
-                       '* thread #1',
-                       'stop reason = signal'])
+        self.assertEqual(thread.GetState(), lldb.eStopReasonSignal)
 
         # Run to breakpoint 2
         self.runCmd("continue")
 
-        # The stop reason of the thread should be breakpoint.
-        self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
-            substrs = ['stopped',
-                       '* thread #1',
-                       'stop reason = breakpoint'])
+        self.assertEqual(thread.GetState(), lldb.eStopReasonBreakpoint)
 
         # Make sure both threads are stopped
         self.assertTrue(thread.IsStopped(), "Thread state isn't \'stopped\' during breakpoint 2.")
@@ -329,4 +261,4 @@ class ThreadStateTestCase(TestBase):
         self.runCmd("continue")
 
         # At this point, the inferior process should have exited.
-        self.assertTrue(process.GetState() == lldb.eStateExited, PROCESS_EXITED)
+        self.assertEqual(process.GetState(), lldb.eStateExited, PROCESS_EXITED)
diff --git a/packages/Python/lldbsuite/test/functionalities/thread/step_out/TestThreadStepOut.py b/packages/Python/lldbsuite/test/functionalities/thread/step_out/TestThreadStepOut.py
index b2d966c4c0f3..735ee80d624e 100644
--- a/packages/Python/lldbsuite/test/functionalities/thread/step_out/TestThreadStepOut.py
+++ b/packages/Python/lldbsuite/test/functionalities/thread/step_out/TestThreadStepOut.py
@@ -8,35 +8,36 @@ from __future__ import print_function
 
 import os, time
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbutil
 
 class ThreadStepOutTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @skipIfLinux                              # Test occasionally times out on the Linux build bot
-    @expectedFailureLinux("llvm.org/pr23477") # Test occasionally times out on the Linux build bot
-    @expectedFailureFreeBSD("llvm.org/pr18066") # inferior does not exit
-    @expectedFailureWindows # Test crashes
+    @expectedFailureAll(oslist=["linux"], bugnumber="llvm.org/pr23477 Test occasionally times out on the Linux build bot")
+    @expectedFailureAll(oslist=["freebsd"], bugnumber="llvm.org/pr18066 inferior does not exit")
+    @expectedFailureAll(oslist=["windows"])
     def test_step_single_thread(self):
         """Test thread step out on one thread via command interpreter. """
         self.build(dictionary=self.getBuildFlags())
         self.step_out_test(self.step_out_single_thread_with_cmd)
 
     @skipIfLinux                              # Test occasionally times out on the Linux build bot
-    @expectedFailureLinux("llvm.org/pr23477") # Test occasionally times out on the Linux build bot
-    @expectedFailureFreeBSD("llvm.org/pr19347") # 2nd thread stops at breakpoint
-    @expectedFailureWindows # Test crashes
+    @expectedFailureAll(oslist=["linux"], bugnumber="llvm.org/pr23477 Test occasionally times out on the Linux build bot")
+    @expectedFailureAll(oslist=["freebsd"], bugnumber="llvm.org/pr19347 2nd thread stops at breakpoint")
+    @expectedFailureAll(oslist=["windows"])
     def test_step_all_threads(self):
         """Test thread step out on all threads via command interpreter. """
         self.build(dictionary=self.getBuildFlags())
         self.step_out_test(self.step_out_all_threads_with_cmd)
 
     @skipIfLinux                              # Test occasionally times out on the Linux build bot
-    @expectedFailureLinux("llvm.org/pr23477") # Test occasionally times out on the Linux build bot
-    @expectedFailureFreeBSD("llvm.org/pr19347")
-    @expectedFailureWindows("llvm.org/pr24681")
+    @expectedFailureAll(oslist=["linux"], bugnumber="llvm.org/pr23477 Test occasionally times out on the Linux build bot")
+    @expectedFailureAll(oslist=["freebsd"], bugnumber="llvm.org/pr19347 2nd thread stops at breakpoint")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24681")
     def test_python(self):
         """Test thread step out on one thread via Python API (dwarf)."""
         self.build(dictionary=self.getBuildFlags())
diff --git a/packages/Python/lldbsuite/test/functionalities/thread/step_out/main.cpp b/packages/Python/lldbsuite/test/functionalities/thread/step_out/main.cpp
index b4c6216d6bfe..31f9a1576b92 100644
--- a/packages/Python/lldbsuite/test/functionalities/thread/step_out/main.cpp
+++ b/packages/Python/lldbsuite/test/functionalities/thread/step_out/main.cpp
@@ -13,19 +13,7 @@
 #include <atomic>
 #include <thread>
 
-// Note that although hogging the CPU while waiting for a variable to change
-// would be terrible in production code, it's great for testing since it
-// avoids a lot of messy context switching to get multiple threads synchronized.
-#define do_nothing()
-
-#define pseudo_barrier_wait(bar) \
-    --bar;                       \
-    while (bar > 0)              \
-        do_nothing();
-
-#define pseudo_barrier_init(bar, count) (bar = count)
-
-std::atomic_int g_barrier;
+pseudo_barrier_t g_barrier;
 
 volatile int g_test = 0;
 
diff --git a/packages/Python/lldbsuite/test/functionalities/thread/thread_exit/TestThreadExit.py b/packages/Python/lldbsuite/test/functionalities/thread/thread_exit/TestThreadExit.py
index f785401277a4..2ba6f2e57f2b 100644
--- a/packages/Python/lldbsuite/test/functionalities/thread/thread_exit/TestThreadExit.py
+++ b/packages/Python/lldbsuite/test/functionalities/thread/thread_exit/TestThreadExit.py
@@ -24,7 +24,6 @@ class ThreadExitTestCase(TestBase):
         self.break_3 = line_number('main.cpp', '// Set third breakpoint here')
         self.break_4 = line_number('main.cpp', '// Set fourth breakpoint here')
 
-    @expectedFailureWindows("llvm.org/pr24681")
     def test(self):
         """Test thread exit handling."""
         self.build(dictionary=self.getBuildFlags())
@@ -32,10 +31,10 @@ class ThreadExitTestCase(TestBase):
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         # This should create a breakpoint with 1 location.
-        lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.break_1, num_expected_locations=1)
-        lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.break_2, num_expected_locations=1)
-        lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.break_3, num_expected_locations=1)
-        lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.break_4, num_expected_locations=1)
+        bp1_id = lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.break_1, num_expected_locations=1)
+        bp2_id = lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.break_2, num_expected_locations=1)
+        bp3_id = lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.break_3, num_expected_locations=1)
+        bp4_id = lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.break_4, num_expected_locations=1)
 
         # The breakpoint list should show 1 locations.
         self.expect("breakpoint list -f", "Breakpoint location shown correctly",
@@ -46,71 +45,46 @@ class ThreadExitTestCase(TestBase):
 
         # Run the program.
         self.runCmd("run", RUN_SUCCEEDED)
-
-        # The stop reason of the thread should be breakpoint 1.
-        self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT + " 1",
-            substrs = ['stopped',
-                       '* thread #1',
-                       'stop reason = breakpoint 1',
-                       'thread #2'])
-
         # Get the target process
         target = self.dbg.GetSelectedTarget()
         process = target.GetProcess()
 
+        stopped_thread = lldbutil.get_one_thread_stopped_at_breakpoint_id(process, bp1_id)
+        self.assertIsNotNone(stopped_thread, "Process is not stopped at breakpoint 1")
+
         # Get the number of threads
         num_threads = process.GetNumThreads()
-
-        self.assertTrue(num_threads == 2, 'Number of expected threads and actual threads do not match at breakpoint 1.')
+        self.assertGreaterEqual(num_threads, 2, 'Number of expected threads and actual threads do not match at breakpoint 1.')
 
         # Run to the second breakpoint
         self.runCmd("continue")
-
-        # The stop reason of the thread should be breakpoint 1.
-        self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT + " 2",
-            substrs = ['stopped',
-                       'thread #1',
-                       'thread #2',
-                       'stop reason = breakpoint 2',
-                       'thread #3'])
+        stopped_thread = lldbutil.get_one_thread_stopped_at_breakpoint_id(process, bp2_id)
+        self.assertIsNotNone(stopped_thread, "Process is not stopped at breakpoint 2")
 
         # Update the number of threads
-        num_threads = process.GetNumThreads()
-
-        self.assertTrue(num_threads == 3, 'Number of expected threads and actual threads do not match at breakpoint 2.')
+        new_num_threads = process.GetNumThreads()
+        self.assertEqual(new_num_threads, num_threads+1, 'Number of expected threads did not increase by 1 at bp 2.')
 
         # Run to the third breakpoint
         self.runCmd("continue")
-
-        # The stop reason of the thread should be breakpoint 3.
-        self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT + " 3",
-            substrs = ['stopped',
-                       'thread #1',
-                       'stop reason = breakpoint 3',
-                       'thread #3',
-                       ])
+        stopped_thread = lldbutil.get_one_thread_stopped_at_breakpoint_id(process, bp3_id)
+        self.assertIsNotNone(stopped_thread, "Process is not stopped at breakpoint 3")
 
         # Update the number of threads
-        num_threads = process.GetNumThreads()
-
-        self.assertTrue(num_threads == 2, 'Number of expected threads and actual threads do not match at breakpoint 3.')
+        new_num_threads = process.GetNumThreads()
+        self.assertEqual(new_num_threads, num_threads, 'Number of expected threads is not equal to original number of threads at bp 3.')
 
         # Run to the fourth breakpoint
         self.runCmd("continue")
-
-        # The stop reason of the thread should be breakpoint 4.
-        self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT + " 4",
-            substrs = ['stopped',
-                       'thread #1',
-                       'stop reason = breakpoint 4'])
+        stopped_thread = lldbutil.get_one_thread_stopped_at_breakpoint_id(process, bp4_id)
+        self.assertIsNotNone(stopped_thread, "Process is not stopped at breakpoint 4")
 
         # Update the number of threads
-        num_threads = process.GetNumThreads()
-
-        self.assertTrue(num_threads == 1, 'Number of expected threads and actual threads do not match at breakpoint 4.')
+        new_num_threads = process.GetNumThreads()
+        self.assertEqual(new_num_threads, num_threads-1, 'Number of expected threads did not decrease by 1 at bp 4.')
 
         # Run to completion
         self.runCmd("continue")
 
         # At this point, the inferior process should have exited.
-        self.assertTrue(process.GetState() == lldb.eStateExited, PROCESS_EXITED)
+        self.assertEqual(process.GetState(), lldb.eStateExited, PROCESS_EXITED)
diff --git a/packages/Python/lldbsuite/test/functionalities/thread/thread_exit/main.cpp b/packages/Python/lldbsuite/test/functionalities/thread/thread_exit/main.cpp
index e498db7895d2..c57db9f48527 100644
--- a/packages/Python/lldbsuite/test/functionalities/thread/thread_exit/main.cpp
+++ b/packages/Python/lldbsuite/test/functionalities/thread/thread_exit/main.cpp
@@ -12,21 +12,9 @@
 #include <atomic>
 #include <thread>
 
-// Note that although hogging the CPU while waiting for a variable to change
-// would be terrible in production code, it's great for testing since it
-// avoids a lot of messy context switching to get multiple threads synchronized.
-#define do_nothing()
-
-#define pseudo_barrier_wait(bar) \
-    --bar;                       \
-    while (bar > 0)              \
-        do_nothing();
-
-#define pseudo_barrier_init(bar, count) (bar = count)
-
-std::atomic_int g_barrier1;
-std::atomic_int g_barrier2;
-std::atomic_int g_barrier3;
+pseudo_barrier_t g_barrier1;
+pseudo_barrier_t g_barrier2;
+pseudo_barrier_t g_barrier3;
 
 void *
 thread1 ()
diff --git a/packages/Python/lldbsuite/test/functionalities/thread/thread_specific_break/TestThreadSpecificBreakpoint.py b/packages/Python/lldbsuite/test/functionalities/thread/thread_specific_break/TestThreadSpecificBreakpoint.py
index 3c69b6667f7d..12bacabd0d78 100644
--- a/packages/Python/lldbsuite/test/functionalities/thread/thread_specific_break/TestThreadSpecificBreakpoint.py
+++ b/packages/Python/lldbsuite/test/functionalities/thread/thread_specific_break/TestThreadSpecificBreakpoint.py
@@ -9,15 +9,16 @@ from __future__ import print_function
 import os, time
 import re
 import lldb
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
 
 class ThreadSpecificBreakTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @add_test_categories(['pyapi'])
-    @expectedFailureWindows # Thread specific breakpoints cause the inferior to crash
+    @expectedFailureAll(oslist=["windows"])
     def test_python(self):
         """Test that we obey thread conditioned breakpoints."""
         self.build()
diff --git a/packages/Python/lldbsuite/test/functionalities/thread/thread_specific_break_plus_condition/TestThreadSpecificBpPlusCondition.py b/packages/Python/lldbsuite/test/functionalities/thread/thread_specific_break_plus_condition/TestThreadSpecificBpPlusCondition.py
index 68c96a0fba75..ccb58c965b3f 100644
--- a/packages/Python/lldbsuite/test/functionalities/thread/thread_specific_break_plus_condition/TestThreadSpecificBpPlusCondition.py
+++ b/packages/Python/lldbsuite/test/functionalities/thread/thread_specific_break_plus_condition/TestThreadSpecificBpPlusCondition.py
@@ -10,17 +10,17 @@ from __future__ import print_function
 import os, time
 import re
 import lldb
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
 
 class ThreadSpecificBreakPlusConditionTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @skipIfFreeBSD # test frequently times out or hangs
-    @expectedFailureFreeBSD('llvm.org/pr18522') # hits break in another thread in testrun
+    @expectedFailureAll(oslist=['freebsd'], bugnumber='llvm.org/pr18522') # hits break in another thread in testrun
     @add_test_categories(['pyapi'])
-    @expectedFlakeyLinux # this test fails 6/100 dosep runs
     def test_python(self):
         """Test that we obey thread conditioned breakpoints."""
         self.build()
diff --git a/packages/Python/lldbsuite/test/functionalities/tsan/basic/Makefile b/packages/Python/lldbsuite/test/functionalities/tsan/basic/Makefile
new file mode 100644
index 000000000000..c930ae563fc1
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/tsan/basic/Makefile
@@ -0,0 +1,6 @@
+LEVEL = ../../../make
+
+C_SOURCES := main.c
+CFLAGS_EXTRAS := -fsanitize=thread -g
+
+include $(LEVEL)/Makefile.rules
diff --git a/packages/Python/lldbsuite/test/functionalities/tsan/basic/TestTsanBasic.py b/packages/Python/lldbsuite/test/functionalities/tsan/basic/TestTsanBasic.py
new file mode 100644
index 000000000000..44fa9cedc86c
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/tsan/basic/TestTsanBasic.py
@@ -0,0 +1,118 @@
+"""
+Tests basic ThreadSanitizer support (detecting a data race).
+"""
+
+import os, time
+import lldb
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test.decorators import *
+import lldbsuite.test.lldbutil as lldbutil
+import json
+
+class TsanBasicTestCase(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    @expectedFailureAll(oslist=["linux"], bugnumber="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
+    @skipUnlessThreadSanitizer
+    def test (self):
+        self.build ()
+        self.tsan_tests ()
+
+    def setUp(self):
+        # Call super's setUp().
+        TestBase.setUp(self)
+        self.line_malloc = line_number('main.c', '// malloc line')
+        self.line_thread1 = line_number('main.c', '// thread1 line')
+        self.line_thread2 = line_number('main.c', '// thread2 line')
+
+    def tsan_tests (self):
+        exe = os.path.join (os.getcwd(), "a.out")
+        self.expect("file " + exe, patterns = [ "Current executable set to .*a.out" ])
+
+        self.runCmd("run")
+
+        stop_reason = self.dbg.GetSelectedTarget().process.GetSelectedThread().GetStopReason()
+        if stop_reason == lldb.eStopReasonExec:
+            # On OS X 10.10 and older, we need to re-exec to enable interceptors.
+            self.runCmd("continue")
+
+        # the stop reason of the thread should be breakpoint.
+        self.expect("thread list", "A data race should be detected",
+            substrs = ['stopped', 'stop reason = Data race detected'])
+
+        self.assertEqual(self.dbg.GetSelectedTarget().process.GetSelectedThread().GetStopReason(), lldb.eStopReasonInstrumentation)
+
+        # test that the TSan dylib is present
+        self.expect("image lookup -n __tsan_get_current_report", "__tsan_get_current_report should be present",
+            substrs = ['1 match found'])
+
+        # We should be stopped in __tsan_on_report
+        process = self.dbg.GetSelectedTarget().process
+        thread = process.GetSelectedThread()
+        frame = thread.GetSelectedFrame()
+        self.assertTrue("__tsan_on_report" in frame.GetFunctionName())
+
+        # The stopped thread backtrace should contain either line1 or line2 from main.c.
+        found = False
+        for i in range(0, thread.GetNumFrames()):
+            frame = thread.GetFrameAtIndex(i)
+            if frame.GetLineEntry().GetFileSpec().GetFilename() == "main.c":
+                if frame.GetLineEntry().GetLine() == self.line_thread1:
+                    found = True
+                if frame.GetLineEntry().GetLine() == self.line_thread2:
+                    found = True
+        self.assertTrue(found)
+
+        self.expect("thread info -s", "The extended stop info should contain the TSan provided fields",
+            substrs = ["instrumentation_class", "description", "mops"])
+
+        output_lines = self.res.GetOutput().split('\n')
+        json_line = '\n'.join(output_lines[2:])
+        data = json.loads(json_line)
+        self.assertEqual(data["instrumentation_class"], "ThreadSanitizer")
+        self.assertEqual(data["issue_type"], "data-race")
+        self.assertEqual(len(data["mops"]), 2)
+
+        backtraces = thread.GetStopReasonExtendedBacktraces(lldb.eInstrumentationRuntimeTypeAddressSanitizer)
+        self.assertEqual(backtraces.GetSize(), 0)
+
+        backtraces = thread.GetStopReasonExtendedBacktraces(lldb.eInstrumentationRuntimeTypeThreadSanitizer)
+        self.assertTrue(backtraces.GetSize() >= 2)
+
+        # First backtrace is a memory operation
+        thread = backtraces.GetThreadAtIndex(0)
+        found = False
+        for i in range(0, thread.GetNumFrames()):
+            frame = thread.GetFrameAtIndex(i)
+            if frame.GetLineEntry().GetFileSpec().GetFilename() == "main.c":
+                if frame.GetLineEntry().GetLine() == self.line_thread1:
+                    found = True
+                if frame.GetLineEntry().GetLine() == self.line_thread2:
+                    found = True
+        self.assertTrue(found)
+
+        # Second backtrace is a memory operation
+        thread = backtraces.GetThreadAtIndex(1)
+        found = False
+        for i in range(0, thread.GetNumFrames()):
+            frame = thread.GetFrameAtIndex(i)
+            if frame.GetLineEntry().GetFileSpec().GetFilename() == "main.c":
+                if frame.GetLineEntry().GetLine() == self.line_thread1:
+                    found = True
+                if frame.GetLineEntry().GetLine() == self.line_thread2:
+                    found = True
+        self.assertTrue(found)
+
+        self.runCmd("continue")
+
+        # the stop reason of the thread should be a SIGABRT.
+        self.expect("thread list", "We should be stopped due a SIGABRT",
+            substrs = ['stopped', 'stop reason = signal SIGABRT'])
+
+        # test that we're in pthread_kill now (TSan abort the process)
+        self.expect("thread list", "We should be stopped in pthread_kill",
+            substrs = ['pthread_kill'])
diff --git a/packages/Python/lldbsuite/test/functionalities/tsan/basic/main.c b/packages/Python/lldbsuite/test/functionalities/tsan/basic/main.c
new file mode 100644
index 000000000000..c082b01a57c7
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/tsan/basic/main.c
@@ -0,0 +1,37 @@
+//===-- main.c --------------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+char *pointer;
+
+void *f1(void *p) {
+    pointer[0] = 'x'; // thread1 line
+    return NULL;
+}
+
+void *f2(void *p) {
+    pointer[0] = 'y'; // thread2 line
+    return NULL;
+}
+
+int main (int argc, char const *argv[])
+{
+    pointer = (char *)malloc(10); // malloc line
+
+    pthread_t t1, t2;
+    pthread_create(&t1, NULL, f1, NULL);
+    pthread_create(&t2, NULL, f2, NULL);
+
+    pthread_join(t1, NULL);
+    pthread_join(t2, NULL);
+
+    return 0;
+}
diff --git a/packages/Python/lldbsuite/test/functionalities/tsan/cpp_global_location/Makefile b/packages/Python/lldbsuite/test/functionalities/tsan/cpp_global_location/Makefile
new file mode 100644
index 000000000000..a58194779074
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/tsan/cpp_global_location/Makefile
@@ -0,0 +1,6 @@
+LEVEL = ../../../make
+
+CXX_SOURCES := main.cpp
+CFLAGS_EXTRAS := -fsanitize=thread -g
+
+include $(LEVEL)/Makefile.rules
diff --git a/packages/Python/lldbsuite/test/functionalities/tsan/cpp_global_location/TestTsanCPPGlobalLocation.py b/packages/Python/lldbsuite/test/functionalities/tsan/cpp_global_location/TestTsanCPPGlobalLocation.py
new file mode 100644
index 000000000000..230ff982da0d
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/tsan/cpp_global_location/TestTsanCPPGlobalLocation.py
@@ -0,0 +1,54 @@
+"""
+Tests that TSan correctly reports the filename and line number of a racy global C++ variable.
+"""
+
+import os, time
+import lldb
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test.decorators import *
+import lldbsuite.test.lldbutil as lldbutil
+import json
+
+class TsanCPPGlobalLocationTestCase(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    @expectedFailureAll(oslist=["linux"], bugnumber="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
+    @skipUnlessThreadSanitizer
+    def test (self):
+        self.build ()
+        self.tsan_tests ()
+
+    def setUp(self):
+        # Call super's setUp().
+        TestBase.setUp(self)
+
+    def tsan_tests (self):
+        exe = os.path.join (os.getcwd(), "a.out")
+        self.expect("file " + exe, patterns = [ "Current executable set to .*a.out" ])
+
+        self.runCmd("run")
+
+        stop_reason = self.dbg.GetSelectedTarget().process.GetSelectedThread().GetStopReason()
+        if stop_reason == lldb.eStopReasonExec:
+            # On OS X 10.10 and older, we need to re-exec to enable interceptors.
+            self.runCmd("continue")
+
+        # the stop reason of the thread should be breakpoint.
+        self.expect("thread list", "A data race should be detected",
+            substrs = ['stopped', 'stop reason = Data race detected'])
+
+        self.expect("thread info -s", "The extended stop info should contain the TSan provided fields",
+            substrs = ["instrumentation_class", "description", "mops"])
+
+        output_lines = self.res.GetOutput().split('\n')
+        json_line = '\n'.join(output_lines[2:])
+        data = json.loads(json_line)
+        self.assertEqual(data["instrumentation_class"], "ThreadSanitizer")
+        self.assertEqual(data["issue_type"], "data-race")
+
+        self.assertTrue(data["location_filename"].endswith("/main.cpp"))
+        self.assertEqual(data["location_line"], line_number('main.cpp', '// global variable'))
diff --git a/packages/Python/lldbsuite/test/functionalities/tsan/cpp_global_location/main.cpp b/packages/Python/lldbsuite/test/functionalities/tsan/cpp_global_location/main.cpp
new file mode 100644
index 000000000000..80f72ae83cf7
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/tsan/cpp_global_location/main.cpp
@@ -0,0 +1,38 @@
+//===-- main.cpp ------------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+long my_global_variable;  // global variable
+
+void *f1(void *p) {
+    my_global_variable = 42;
+    return NULL;
+}
+
+void *f2(void *p) {
+    my_global_variable = 43;
+    return NULL;
+}
+
+int main (int argc, char const *argv[])
+{
+    pthread_t t1;
+    pthread_create(&t1, NULL, f1, NULL);
+
+    pthread_t t2;
+    pthread_create(&t2, NULL, f2, NULL);
+
+    pthread_join(t1, NULL);
+    pthread_join(t2, NULL);
+
+    return 0;
+}
diff --git a/packages/Python/lldbsuite/test/functionalities/tsan/global_location/Makefile b/packages/Python/lldbsuite/test/functionalities/tsan/global_location/Makefile
new file mode 100644
index 000000000000..c930ae563fc1
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/tsan/global_location/Makefile
@@ -0,0 +1,6 @@
+LEVEL = ../../../make
+
+C_SOURCES := main.c
+CFLAGS_EXTRAS := -fsanitize=thread -g
+
+include $(LEVEL)/Makefile.rules
diff --git a/packages/Python/lldbsuite/test/functionalities/tsan/global_location/TestTsanGlobalLocation.py b/packages/Python/lldbsuite/test/functionalities/tsan/global_location/TestTsanGlobalLocation.py
new file mode 100644
index 000000000000..b268c46fead3
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/tsan/global_location/TestTsanGlobalLocation.py
@@ -0,0 +1,54 @@
+"""
+Tests that TSan correctly reports the filename and line number of a racy global variable.
+"""
+
+import os, time
+import lldb
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test.decorators import *
+import lldbsuite.test.lldbutil as lldbutil
+import json
+
+class TsanGlobalLocationTestCase(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    @expectedFailureAll(oslist=["linux"], bugnumber="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
+    @skipUnlessThreadSanitizer
+    def test (self):
+        self.build ()
+        self.tsan_tests ()
+
+    def setUp(self):
+        # Call super's setUp().
+        TestBase.setUp(self)
+
+    def tsan_tests (self):
+        exe = os.path.join (os.getcwd(), "a.out")
+        self.expect("file " + exe, patterns = [ "Current executable set to .*a.out" ])
+
+        self.runCmd("run")
+
+        stop_reason = self.dbg.GetSelectedTarget().process.GetSelectedThread().GetStopReason()
+        if stop_reason == lldb.eStopReasonExec:
+            # On OS X 10.10 and older, we need to re-exec to enable interceptors.
+            self.runCmd("continue")
+
+        # the stop reason of the thread should be breakpoint.
+        self.expect("thread list", "A data race should be detected",
+            substrs = ['stopped', 'stop reason = Data race detected'])
+
+        self.expect("thread info -s", "The extended stop info should contain the TSan provided fields",
+            substrs = ["instrumentation_class", "description", "mops"])
+
+        output_lines = self.res.GetOutput().split('\n')
+        json_line = '\n'.join(output_lines[2:])
+        data = json.loads(json_line)
+        self.assertEqual(data["instrumentation_class"], "ThreadSanitizer")
+        self.assertEqual(data["issue_type"], "data-race")
+        
+        self.assertTrue(data["location_filename"].endswith("/main.c"))
+        self.assertEqual(data["location_line"], line_number('main.c', '// global variable'))
diff --git a/packages/Python/lldbsuite/test/functionalities/tsan/global_location/main.c b/packages/Python/lldbsuite/test/functionalities/tsan/global_location/main.c
new file mode 100644
index 000000000000..caa2c3cb43cd
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/tsan/global_location/main.c
@@ -0,0 +1,38 @@
+//===-- main.c --------------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+long my_global_variable;  // global variable
+
+void *f1(void *p) {
+    my_global_variable = 42;
+    return NULL;
+}
+
+void *f2(void *p) {
+    my_global_variable = 43;
+    return NULL;
+}
+
+int main (int argc, char const *argv[])
+{
+    pthread_t t1;
+    pthread_create(&t1, NULL, f1, NULL);
+
+    pthread_t t2;
+    pthread_create(&t2, NULL, f2, NULL);
+
+    pthread_join(t1, NULL);
+    pthread_join(t2, NULL);
+
+    return 0;
+}
diff --git a/packages/Python/lldbsuite/test/functionalities/tsan/multiple/Makefile b/packages/Python/lldbsuite/test/functionalities/tsan/multiple/Makefile
new file mode 100644
index 000000000000..c930ae563fc1
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/tsan/multiple/Makefile
@@ -0,0 +1,6 @@
+LEVEL = ../../../make
+
+C_SOURCES := main.c
+CFLAGS_EXTRAS := -fsanitize=thread -g
+
+include $(LEVEL)/Makefile.rules
diff --git a/packages/Python/lldbsuite/test/functionalities/tsan/multiple/TestTsanMultiple.py b/packages/Python/lldbsuite/test/functionalities/tsan/multiple/TestTsanMultiple.py
new file mode 100644
index 000000000000..c22501141cca
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/tsan/multiple/TestTsanMultiple.py
@@ -0,0 +1,69 @@
+"""
+Test ThreadSanitizer when multiple different issues are found.
+"""
+
+import os, time
+import lldb
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test.decorators import *
+import lldbsuite.test.lldbutil as lldbutil
+import json
+
+class TsanMultipleTestCase(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    @expectedFailureAll(oslist=["linux"], bugnumber="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
+    @skipUnlessThreadSanitizer
+    def test (self):
+        self.build ()
+        self.tsan_tests ()
+
+    def setUp(self):
+        # Call super's setUp().
+        TestBase.setUp(self)
+
+    def tsan_tests (self):
+        exe = os.path.join (os.getcwd(), "a.out")
+        self.expect("file " + exe, patterns = [ "Current executable set to .*a.out" ])
+
+        self.runCmd("env TSAN_OPTIONS=abort_on_error=0")
+
+        self.runCmd("run")
+
+        stop_reason = self.dbg.GetSelectedTarget().process.GetSelectedThread().GetStopReason()
+        if stop_reason == lldb.eStopReasonExec:
+            # On OS X 10.10 and older, we need to re-exec to enable interceptors.
+            self.runCmd("continue")
+
+        report_count = 0
+        while self.dbg.GetSelectedTarget().process.GetSelectedThread().GetStopReason() == lldb.eStopReasonInstrumentation:
+            report_count += 1
+
+            stop_description = self.dbg.GetSelectedTarget().process.GetSelectedThread().GetStopDescription(100)
+
+            self.assertTrue(
+                 (stop_description == "Data race detected") or
+                 (stop_description == "Use of deallocated memory detected") or
+                 (stop_description == "Thread leak detected") or
+                 (stop_description == "Use of an uninitialized or destroyed mutex detected") or
+                 (stop_description == "Unlock of an unlocked mutex (or by a wrong thread) detected")
+            )
+
+            self.expect("thread info -s", "The extended stop info should contain the TSan provided fields",
+                substrs = ["instrumentation_class", "description", "mops"])
+
+            output_lines = self.res.GetOutput().split('\n')
+            json_line = '\n'.join(output_lines[2:])
+            data = json.loads(json_line)
+            self.assertEqual(data["instrumentation_class"], "ThreadSanitizer")
+
+            backtraces = self.dbg.GetSelectedTarget().process.GetSelectedThread().GetStopReasonExtendedBacktraces(lldb.eInstrumentationRuntimeTypeThreadSanitizer)
+            self.assertTrue(backtraces.GetSize() >= 1)
+
+            self.runCmd("continue")
+
+        self.assertEqual(self.dbg.GetSelectedTarget().process.GetState(), lldb.eStateExited, PROCESS_EXITED)
diff --git a/packages/Python/lldbsuite/test/functionalities/tsan/multiple/main.m b/packages/Python/lldbsuite/test/functionalities/tsan/multiple/main.m
new file mode 100644
index 000000000000..f7c48b45422b
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/tsan/multiple/main.m
@@ -0,0 +1,138 @@
+//===-- main.c --------------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#import <Foundation/Foundation.h>
+#import <pthread.h>
+
+long my_global;
+
+void *Thread1(void *arg) {
+    my_global = 42;
+    return NULL;
+}
+
+void *Thread2(void *arg) {
+    my_global = 144;
+    return NULL;
+}
+
+void TestDataRace1() {
+    pthread_t t1, t2;
+    pthread_create(&t1, NULL, Thread1, NULL);
+    pthread_create(&t2, NULL, Thread2, NULL);
+    
+    pthread_join(t1, NULL);
+    pthread_join(t2, NULL);
+}
+
+void TestInvalidMutex() {
+    pthread_mutex_t m = {0};
+    pthread_mutex_lock(&m);
+    
+    pthread_mutex_init(&m, NULL);
+    pthread_mutex_lock(&m);
+    pthread_mutex_unlock(&m);
+    pthread_mutex_destroy(&m);
+    pthread_mutex_lock(&m);
+}
+
+void TestMutexWrongLock() {
+    pthread_mutex_t m = {0};
+    pthread_mutex_init(&m, NULL);
+    pthread_mutex_unlock(&m);
+}
+
+long some_global;
+
+void TestDataRaceBlocks1() {
+    dispatch_queue_t q = dispatch_queue_create("my.queue", DISPATCH_QUEUE_CONCURRENT);
+    
+    for (int i = 0; i < 2; i++) {
+        dispatch_async(q, ^{
+            some_global++;  // race 1
+            
+            usleep(100000);  // force the blocks to be on different threads
+        });
+    }
+    
+    usleep(100000);
+    dispatch_barrier_sync(q, ^{ });
+}
+
+void TestDataRaceBlocks2() {
+    dispatch_queue_t q = dispatch_queue_create("my.queue2", DISPATCH_QUEUE_CONCURRENT);
+    
+    char *c;
+    
+    c = malloc((rand() % 1000) + 10);
+    for (int i = 0; i < 2; i++) {
+        dispatch_async(q, ^{
+            c[0] = 'x';  // race 2
+            fprintf(stderr, "tid: %p\n", pthread_self());
+            usleep(100000);  // force the blocks to be on different threads
+        });
+    }
+    dispatch_barrier_sync(q, ^{ });
+    
+    free(c);
+}
+
+void TestUseAfterFree() {
+    char *c;
+    
+    c = malloc((rand() % 1000) + 10);
+    free(c);
+    c[0] = 'x';
+}
+
+void TestRacePipe() {
+    dispatch_queue_t q = dispatch_queue_create("my.queue3", DISPATCH_QUEUE_CONCURRENT);
+    
+    int a[2];
+    pipe(a);
+    int fd = a[0];
+    
+    for (int i = 0; i < 2; i++) {
+        dispatch_async(q, ^{
+            write(fd, "abc", 3);
+            usleep(100000);  // force the blocks to be on different threads
+        });
+        dispatch_async(q, ^{
+            close(fd);
+            usleep(100000);
+        });
+    }
+    
+    dispatch_barrier_sync(q, ^{ });
+}
+
+void TestThreadLeak() {
+    pthread_t t1;
+    pthread_create(&t1, NULL, Thread1, NULL);
+}
+
+int main(int argc, const char * argv[]) {
+    TestDataRace1();
+    
+    TestInvalidMutex();
+    
+    TestMutexWrongLock();
+    
+    TestDataRaceBlocks1();
+    
+    TestDataRaceBlocks2();
+    
+    TestUseAfterFree();
+    
+    TestRacePipe();
+    
+    TestThreadLeak();
+
+    return 0;
+}
diff --git a/packages/Python/lldbsuite/test/functionalities/tsan/thread_leak/Makefile b/packages/Python/lldbsuite/test/functionalities/tsan/thread_leak/Makefile
new file mode 100644
index 000000000000..c930ae563fc1
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/tsan/thread_leak/Makefile
@@ -0,0 +1,6 @@
+LEVEL = ../../../make
+
+C_SOURCES := main.c
+CFLAGS_EXTRAS := -fsanitize=thread -g
+
+include $(LEVEL)/Makefile.rules
diff --git a/packages/Python/lldbsuite/test/functionalities/tsan/thread_leak/TestTsanThreadLeak.py b/packages/Python/lldbsuite/test/functionalities/tsan/thread_leak/TestTsanThreadLeak.py
new file mode 100644
index 000000000000..ed620093c1f3
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/tsan/thread_leak/TestTsanThreadLeak.py
@@ -0,0 +1,40 @@
+"""
+Tests ThreadSanitizer's support to detect a leaked thread.
+"""
+
+import os, time
+import lldb
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test.decorators import *
+import lldbsuite.test.lldbutil as lldbutil
+import json
+
+class TsanThreadLeakTestCase(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    @expectedFailureAll(oslist=["linux"], bugnumber="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
+    @skipUnlessThreadSanitizer
+    def test (self):
+        self.build ()
+        self.tsan_tests ()
+
+    def tsan_tests (self):
+        exe = os.path.join (os.getcwd(), "a.out")
+        self.expect("file " + exe, patterns = [ "Current executable set to .*a.out" ])
+
+        self.runCmd("run")
+
+        stop_reason = self.dbg.GetSelectedTarget().process.GetSelectedThread().GetStopReason()
+        if stop_reason == lldb.eStopReasonExec:
+            # On OS X 10.10 and older, we need to re-exec to enable interceptors.
+            self.runCmd("continue")
+
+        # the stop reason of the thread should be breakpoint.
+        self.expect("thread list", "A thread leak should be detected",
+            substrs = ['stopped', 'stop reason = Thread leak detected'])
+
+        self.assertEqual(self.dbg.GetSelectedTarget().process.GetSelectedThread().GetStopReason(), lldb.eStopReasonInstrumentation)
diff --git a/packages/Python/lldbsuite/test/functionalities/tsan/thread_leak/main.c b/packages/Python/lldbsuite/test/functionalities/tsan/thread_leak/main.c
new file mode 100644
index 000000000000..3c17e228487b
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/tsan/thread_leak/main.c
@@ -0,0 +1,24 @@
+//===-- main.c --------------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+void *f1(void *p) {
+    printf("hello\n");
+    return NULL;
+}
+
+int main (int argc, char const *argv[])
+{
+    pthread_t t1;
+    pthread_create(&t1, NULL, f1, NULL);
+
+    return 0;
+}
diff --git a/packages/Python/lldbsuite/test/functionalities/tsan/thread_numbers/Makefile b/packages/Python/lldbsuite/test/functionalities/tsan/thread_numbers/Makefile
new file mode 100644
index 000000000000..c930ae563fc1
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/tsan/thread_numbers/Makefile
@@ -0,0 +1,6 @@
+LEVEL = ../../../make
+
+C_SOURCES := main.c
+CFLAGS_EXTRAS := -fsanitize=thread -g
+
+include $(LEVEL)/Makefile.rules
diff --git a/packages/Python/lldbsuite/test/functionalities/tsan/thread_numbers/TestTsanThreadNumbers.py b/packages/Python/lldbsuite/test/functionalities/tsan/thread_numbers/TestTsanThreadNumbers.py
new file mode 100644
index 000000000000..c7905bcb1c1d
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/tsan/thread_numbers/TestTsanThreadNumbers.py
@@ -0,0 +1,68 @@
+"""
+Tests that TSan and LLDB have correct thread numbers.
+"""
+
+import os, time
+import lldb
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test.decorators import *
+import lldbsuite.test.lldbutil as lldbutil
+import json
+
+class TsanThreadNumbersTestCase(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    @expectedFailureAll(oslist=["linux"], bugnumber="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
+    @skipUnlessThreadSanitizer
+    def test (self):
+        self.build ()
+        self.tsan_tests ()
+
+    def setUp(self):
+        # Call super's setUp().
+        TestBase.setUp(self)
+
+    def tsan_tests (self):
+        exe = os.path.join (os.getcwd(), "a.out")
+        self.expect("file " + exe, patterns = [ "Current executable set to .*a.out" ])
+
+        self.runCmd("run")
+
+        stop_reason = self.dbg.GetSelectedTarget().process.GetSelectedThread().GetStopReason()
+        if stop_reason == lldb.eStopReasonExec:
+            # On OS X 10.10 and older, we need to re-exec to enable interceptors.
+            self.runCmd("continue")
+
+        # the stop reason of the thread should be breakpoint.
+        self.expect("thread list", "A data race should be detected",
+            substrs = ['stopped', 'stop reason = Data race detected'])
+
+        self.assertEqual(self.dbg.GetSelectedTarget().process.GetSelectedThread().GetStopReason(), lldb.eStopReasonInstrumentation)
+
+        report_thread_id = self.dbg.GetSelectedTarget().process.GetSelectedThread().GetIndexID()
+
+        self.expect("thread info -s", "The extended stop info should contain the TSan provided fields",
+            substrs = ["instrumentation_class", "description", "mops"])
+
+        output_lines = self.res.GetOutput().split('\n')
+        json_line = '\n'.join(output_lines[2:])
+        data = json.loads(json_line)
+        self.assertEqual(data["instrumentation_class"], "ThreadSanitizer")
+        self.assertEqual(data["issue_type"], "data-race")
+        self.assertEqual(len(data["mops"]), 2)
+
+        self.assertEqual(data["mops"][0]["thread_id"], report_thread_id)
+
+        other_thread_id = data["mops"][1]["thread_id"]
+        self.assertTrue(other_thread_id != report_thread_id)
+        other_thread = self.dbg.GetSelectedTarget().process.GetThreadByIndexID(other_thread_id)
+        self.assertTrue(other_thread.IsValid())
+
+        self.runCmd("thread select %d" % other_thread_id)
+
+        self.expect("thread backtrace", "The other thread should be stopped in f1 or f2",
+            substrs = ["a.out", "main.c"])
diff --git a/packages/Python/lldbsuite/test/functionalities/tsan/thread_numbers/main.c b/packages/Python/lldbsuite/test/functionalities/tsan/thread_numbers/main.c
new file mode 100644
index 000000000000..04ebb723c3b7
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/tsan/thread_numbers/main.c
@@ -0,0 +1,58 @@
+//===-- main.c --------------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+char *pointer;
+
+void *nothing(void *p) {
+    return NULL;
+}
+
+void *f1(void *p) {
+    pointer[0] = 'x';
+    sleep(100);
+    return NULL;
+}
+
+void *f2(void *p) {
+    pointer[0] = 'y';
+    sleep(100);
+    return NULL;
+}
+
+int main (int argc, char const *argv[])
+{
+    pointer = (char *)malloc(10);
+
+    for (int i = 0; i < 3; i++) {
+        pthread_t t;
+        pthread_create(&t, NULL, nothing, NULL);
+        pthread_join(t, NULL);
+    }
+
+    pthread_t t1;
+    pthread_create(&t1, NULL, f1, NULL);
+
+    for (int i = 0; i < 3; i++) {
+        pthread_t t;
+        pthread_create(&t, NULL, nothing, NULL);
+        pthread_join(t, NULL);
+    }
+
+    pthread_t t2;
+    pthread_create(&t2, NULL, f2, NULL);
+
+    pthread_join(t1, NULL);
+    pthread_join(t2, NULL);
+
+    return 0;
+}
diff --git a/packages/Python/lldbsuite/test/functionalities/tty/TestTerminal.py b/packages/Python/lldbsuite/test/functionalities/tty/TestTerminal.py
index 5697c2c37283..cebba1b4c573 100644
--- a/packages/Python/lldbsuite/test/functionalities/tty/TestTerminal.py
+++ b/packages/Python/lldbsuite/test/functionalities/tty/TestTerminal.py
@@ -9,8 +9,9 @@ from __future__ import print_function
 import unittest2
 import os, time
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbutil
 
 class LaunchInTerminalTestCase(TestBase):
 
diff --git a/packages/Python/lldbsuite/test/functionalities/type_completion/TestTypeCompletion.py b/packages/Python/lldbsuite/test/functionalities/type_completion/TestTypeCompletion.py
index 5a238b7d3542..2bf10204ea6b 100644
--- a/packages/Python/lldbsuite/test/functionalities/type_completion/TestTypeCompletion.py
+++ b/packages/Python/lldbsuite/test/functionalities/type_completion/TestTypeCompletion.py
@@ -8,14 +8,15 @@ from __future__ import print_function
 
 import os, time
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbutil
 
 class TypeCompletionTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @expectedFailureIcc # often fails with 'NameAndAddress should be valid'
+    @expectedFailureAll(compiler="icc", bugnumber="often fails with 'NameAndAddress should be valid.")
     # Fails with gcc 4.8.1 with llvm.org/pr15301 LLDB prints incorrect sizes of STL containers
     def test_with_run_command(self):
         """Check that types only get completed when necessary."""
diff --git a/packages/Python/lldbsuite/test/functionalities/type_lookup/TestTypeLookup.py b/packages/Python/lldbsuite/test/functionalities/type_lookup/TestTypeLookup.py
index ca0b1f1d1e53..774eb437b78e 100644
--- a/packages/Python/lldbsuite/test/functionalities/type_lookup/TestTypeLookup.py
+++ b/packages/Python/lldbsuite/test/functionalities/type_lookup/TestTypeLookup.py
@@ -6,11 +6,12 @@ from __future__ import print_function
 
 
 
+import datetime
 import os, time
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import datetime
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbutil
 
 class TypeLookupTestCase(TestBase):
 
@@ -41,3 +42,4 @@ class TypeLookupTestCase(TestBase):
         self.expect('type lookup NSURL', substrs=['NSURL'])
         self.expect('type lookup NSArray', substrs=['NSArray'])
         self.expect('type lookup NSObject', substrs=['NSObject', 'isa'])
+        self.expect('type lookup PleaseDontBeARealTypeThatExists', substrs=["no type was found matching 'PleaseDontBeARealTypeThatExists'"])
diff --git a/packages/Python/lldbsuite/test/functionalities/unwind/ehframe/Makefile b/packages/Python/lldbsuite/test/functionalities/unwind/ehframe/Makefile
new file mode 100644
index 000000000000..289d25698ffb
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/unwind/ehframe/Makefile
@@ -0,0 +1,7 @@
+LEVEL = ../../../make
+
+C_SOURCES := main.c
+
+CFLAGS ?= -g -fomit-frame-pointer
+
+include $(LEVEL)/Makefile.rules
diff --git a/packages/Python/lldbsuite/test/functionalities/unwind/ehframe/TestEhFrameUnwind.py b/packages/Python/lldbsuite/test/functionalities/unwind/ehframe/TestEhFrameUnwind.py
new file mode 100644
index 000000000000..e17d5d36d394
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/unwind/ehframe/TestEhFrameUnwind.py
@@ -0,0 +1,51 @@
+"""
+Test that we can backtrace correctly from Non ABI functions on the stack
+"""
+
+from __future__ import print_function
+
+
+
+import os, time
+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+class EHFrameBasedUnwind(TestBase):
+    mydir = TestBase.compute_mydir(__file__)
+
+	
+    @skipUnlessPlatform(['linux'])
+    @skipIf(archs=["aarch64", "arm", "i386", "i686"])
+    def test (self):
+        """Test that we can backtrace correctly from Non ABI  functions on the stack"""
+        self.build()
+        self.setTearDownCleanup()
+
+        exe = os.path.join(os.getcwd(), "a.out")
+        target = self.dbg.CreateTarget(exe)
+
+        self.assertTrue(target, VALID_TARGET)
+
+        lldbutil.run_break_set_by_symbol (self, "func")
+
+        process = target.LaunchSimple (["abc", "xyz"], None, self.get_process_working_directory())
+
+        if not process:
+            self.fail("SBTarget.Launch() failed")
+
+        if process.GetState() != lldb.eStateStopped:
+            self.fail("Process should be in the 'stopped' state, "
+                      "instead the actual state is: '%s'" %
+                      lldbutil.state_type_to_str(process.GetState()))
+
+        stacktraces = lldbutil.print_stacktraces(process, string_buffer=True)
+        self.expect(stacktraces, exe=False,
+            substrs = ['(int)argc=3'])
+
+        self.runCmd("thread step-inst")
+
+        stacktraces = lldbutil.print_stacktraces(process, string_buffer=True)
+        self.expect(stacktraces, exe=False,
+            substrs = ['(int)argc=3'])
diff --git a/packages/Python/lldbsuite/test/functionalities/unwind/ehframe/main.c b/packages/Python/lldbsuite/test/functionalities/unwind/ehframe/main.c
new file mode 100644
index 000000000000..f62f7d814f38
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/unwind/ehframe/main.c
@@ -0,0 +1,20 @@
+void func() {
+	__asm__ (
+		"pushq $0x10;"
+		".cfi_def_cfa_offset 16;"
+		"jmp label;"
+		"movq $0x48, %rax;"
+"label: subq $0x38, %rax;"
+		"movq $0x48, %rcx;"
+		"movq $0x48, %rdx;"
+		"movq $0x48, %rax;"
+		"popq %rax;"
+	);
+
+}
+
+
+int main(int argc, char const *argv[])
+{
+	func();
+}
\ No newline at end of file
diff --git a/packages/Python/lldbsuite/test/functionalities/unwind/noreturn/TestNoreturnUnwind.py b/packages/Python/lldbsuite/test/functionalities/unwind/noreturn/TestNoreturnUnwind.py
index c0a311f7ac9e..62c6c16080a3 100644
--- a/packages/Python/lldbsuite/test/functionalities/unwind/noreturn/TestNoreturnUnwind.py
+++ b/packages/Python/lldbsuite/test/functionalities/unwind/noreturn/TestNoreturnUnwind.py
@@ -8,13 +8,13 @@ from __future__ import print_function
 
 import os, time
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbutil
 
 class NoreturnUnwind(TestBase):
     mydir = TestBase.compute_mydir(__file__)
 
-    @expectedFailurei386("llvm.org/pr25338")
     @skipIfWindows # clang-cl does not support gcc style attributes.
     def test (self):
         """Test that we can backtrace correctly with 'noreturn' functions on the stack"""
diff --git a/packages/Python/lldbsuite/test/functionalities/unwind/sigtramp/TestSigtrampUnwind.py b/packages/Python/lldbsuite/test/functionalities/unwind/sigtramp/TestSigtrampUnwind.py
index ddfb1122b6f1..d2b36412f1f0 100644
--- a/packages/Python/lldbsuite/test/functionalities/unwind/sigtramp/TestSigtrampUnwind.py
+++ b/packages/Python/lldbsuite/test/functionalities/unwind/sigtramp/TestSigtrampUnwind.py
@@ -8,8 +8,9 @@ from __future__ import print_function
 
 import os, time
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbutil
 
 class SigtrampUnwind(TestBase):
     mydir = TestBase.compute_mydir(__file__)
diff --git a/packages/Python/lldbsuite/test/functionalities/unwind/standard/TestStandardUnwind.py b/packages/Python/lldbsuite/test/functionalities/unwind/standard/TestStandardUnwind.py
index 3f88e7b6e1aa..20532c6fc675 100644
--- a/packages/Python/lldbsuite/test/functionalities/unwind/standard/TestStandardUnwind.py
+++ b/packages/Python/lldbsuite/test/functionalities/unwind/standard/TestStandardUnwind.py
@@ -17,8 +17,9 @@ from __future__ import print_function
 import unittest2
 import os, time
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbutil
 
 test_source_dirs = ["."]
 
diff --git a/packages/Python/lldbsuite/test/functionalities/value_md5_crash/TestValueMD5Crash.py b/packages/Python/lldbsuite/test/functionalities/value_md5_crash/TestValueMD5Crash.py
index 763ecc94c2eb..cbea7d22cc44 100644
--- a/packages/Python/lldbsuite/test/functionalities/value_md5_crash/TestValueMD5Crash.py
+++ b/packages/Python/lldbsuite/test/functionalities/value_md5_crash/TestValueMD5Crash.py
@@ -8,8 +8,9 @@ from __future__ import print_function
 
 import os, time
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbutil
 
 class ValueMD5CrashTestCase(TestBase):
 
@@ -21,7 +22,7 @@ class ValueMD5CrashTestCase(TestBase):
         # Find the line number to break at.
         self.line = line_number('main.cpp', '// break here')
 
-    @expectedFailureWindows("llvm.org/pr24663")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24663")
     def test_with_run_command(self):
         """Verify that the hash computing logic for ValueObject's values can't crash us."""
         self.build()
diff --git a/packages/Python/lldbsuite/test/functionalities/watchpoint/hello_watchlocation/TestWatchLocation.py b/packages/Python/lldbsuite/test/functionalities/watchpoint/hello_watchlocation/TestWatchLocation.py
index f0a0b5ab99d0..933f21a90bbf 100644
--- a/packages/Python/lldbsuite/test/functionalities/watchpoint/hello_watchlocation/TestWatchLocation.py
+++ b/packages/Python/lldbsuite/test/functionalities/watchpoint/hello_watchlocation/TestWatchLocation.py
@@ -9,8 +9,9 @@ from __future__ import print_function
 import os, time
 import re
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbutil
 
 class HelloWatchLocationTestCase(TestBase):
 
@@ -30,8 +31,11 @@ class HelloWatchLocationTestCase(TestBase):
         self.d = {'CXX_SOURCES': self.source, 'EXE': self.exe_name}
 
     @expectedFailureAndroid(archs=['arm', 'aarch64']) # Watchpoints not supported
-    @expectedFailureWindows("llvm.org/pr24446") # WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows
-    @expectedFailureAll(archs=['mips', 'mipsel', 'mips64', 'mips64el']) # Most of the MIPS boards provide only one H/W watchpoints, and S/W watchpoints are not supported yet
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
+    @expectedFailureAll(triple = re.compile('^mips')) # Most of the MIPS boards provide only one H/W watchpoints, and S/W watchpoints are not supported yet
+    @expectedFailureAll(archs=['s390x']) # SystemZ also currently supports only one H/W watchpoint
+    @expectedFailureAll(oslist=["linux"], archs=["arm", "aarch64"], bugnumber="llvm.org/pr27795")
+    @skipIfDarwin
     def test_hello_watchlocation(self):
         """Test watching a location with '-s size' option."""
         self.build(dictionary=self.d)
@@ -52,9 +56,6 @@ class HelloWatchLocationTestCase(TestBase):
                        'stop reason = breakpoint'])
 
         # Now let's set a write-type watchpoint pointed to by 'g_char_ptr'.
-        # The main.cpp, by design, misbehaves by not following the agreed upon
-        # protocol of using a mutex while accessing the global pool and by not
-        # incrmenting the global pool by 2.
         self.expect("watchpoint set expression -w write -s 1 -- g_char_ptr", WATCHPOINT_CREATED,
             substrs = ['Watchpoint created', 'size = 1', 'type = w'])
         # Get a hold of the watchpoint id just created, it is used later on to
diff --git a/packages/Python/lldbsuite/test/functionalities/watchpoint/hello_watchlocation/main.cpp b/packages/Python/lldbsuite/test/functionalities/watchpoint/hello_watchlocation/main.cpp
index 59b0afc6d5f7..e20a6d988c84 100644
--- a/packages/Python/lldbsuite/test/functionalities/watchpoint/hello_watchlocation/main.cpp
+++ b/packages/Python/lldbsuite/test/functionalities/watchpoint/hello_watchlocation/main.cpp
@@ -43,15 +43,13 @@ uint32_t
 access_pool (bool flag = false)
 {
     static std::mutex g_access_mutex;
-    if (!flag)
-        g_access_mutex.lock();
+    g_access_mutex.lock();
 
     char old_val = *g_char_ptr;
     if (flag)
         do_bad_thing_with_location(g_char_ptr, old_val + 1);
 
-    if (!flag)
-        g_access_mutex.unlock();
+    g_access_mutex.unlock();
     return *g_char_ptr;
 }
 
diff --git a/packages/Python/lldbsuite/test/functionalities/watchpoint/hello_watchpoint/TestMyFirstWatchpoint.py b/packages/Python/lldbsuite/test/functionalities/watchpoint/hello_watchpoint/TestMyFirstWatchpoint.py
index 57467c38d5f8..5214c7f5e089 100644
--- a/packages/Python/lldbsuite/test/functionalities/watchpoint/hello_watchpoint/TestMyFirstWatchpoint.py
+++ b/packages/Python/lldbsuite/test/functionalities/watchpoint/hello_watchpoint/TestMyFirstWatchpoint.py
@@ -8,8 +8,9 @@ from __future__ import print_function
 
 import os, time
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbutil
 
 class HelloWatchpointTestCase(TestBase):
 
@@ -31,7 +32,7 @@ class HelloWatchpointTestCase(TestBase):
         self.d = {'C_SOURCES': self.source, 'EXE': self.exe_name}
 
     @expectedFailureAndroid(archs=['arm', 'aarch64']) # Watchpoints not supported
-    @expectedFailureWindows("llvm.org/pr24446")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
     def test_hello_watchpoint_using_watchpoint_set(self):
         """Test a simple sequence of watchpoint creation and watchpoint hit."""
         self.build(dictionary=self.d)
diff --git a/packages/Python/lldbsuite/test/functionalities/watchpoint/multiple_threads/TestWatchpointMultipleThreads.py b/packages/Python/lldbsuite/test/functionalities/watchpoint/multiple_threads/TestWatchpointMultipleThreads.py
index 2318214a0d5c..af8306c9a20e 100644
--- a/packages/Python/lldbsuite/test/functionalities/watchpoint/multiple_threads/TestWatchpointMultipleThreads.py
+++ b/packages/Python/lldbsuite/test/functionalities/watchpoint/multiple_threads/TestWatchpointMultipleThreads.py
@@ -9,15 +9,16 @@ from __future__ import print_function
 import os, time
 import re
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbutil
 
 class WatchpointForMultipleThreadsTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @expectedFailureAndroid(archs=['arm', 'aarch64']) # Watchpoints not supported
-    @expectedFailureWindows("llvm.org/pr24446") # WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
     def test_watchpoint_multiple_threads(self):
         """Test that lldb watchpoint works for multiple threads."""
         self.build()
@@ -25,7 +26,7 @@ class WatchpointForMultipleThreadsTestCase(TestBase):
         self.hello_multiple_threads()
 
     @expectedFailureAndroid(archs=['arm', 'aarch64']) # Watchpoints not supported
-    @expectedFailureWindows("llvm.org/pr24446") # WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
     def test_watchpoint_multiple_threads_wp_set_and_then_delete(self):
         """Test that lldb watchpoint works for multiple threads, and after the watchpoint is deleted, the watchpoint event should no longer fires."""
         self.build()
@@ -57,9 +58,6 @@ class WatchpointForMultipleThreadsTestCase(TestBase):
                        'stop reason = breakpoint'])
 
         # Now let's set a write-type watchpoint for variable 'g_val'.
-        # The main.cpp, by design, misbehaves by not following the agreed upon
-        # protocol of using a mutex while accessing the global pool and by not
-        # writing to the variable.
         self.expect("watchpoint set variable -w write g_val", WATCHPOINT_CREATED,
             substrs = ['Watchpoint created', 'size = 4', 'type = w'])
 
@@ -101,9 +99,6 @@ class WatchpointForMultipleThreadsTestCase(TestBase):
                        'stop reason = breakpoint'])
 
         # Now let's set a write-type watchpoint for variable 'g_val'.
-        # The main.cpp, by design, misbehaves by not following the agreed upon
-        # protocol of using a mutex while accessing the global pool and by not
-        # writing to the variable.
         self.expect("watchpoint set variable -w write g_val", WATCHPOINT_CREATED,
             substrs = ['Watchpoint created', 'size = 4', 'type = w'])
 
diff --git a/packages/Python/lldbsuite/test/functionalities/watchpoint/multiple_threads/main.cpp b/packages/Python/lldbsuite/test/functionalities/watchpoint/multiple_threads/main.cpp
index 8a31041f8fca..7f2e5e6e6cb5 100644
--- a/packages/Python/lldbsuite/test/functionalities/watchpoint/multiple_threads/main.cpp
+++ b/packages/Python/lldbsuite/test/functionalities/watchpoint/multiple_threads/main.cpp
@@ -23,8 +23,7 @@ uint32_t
 access_pool (bool flag = false)
 {
     static std::mutex g_access_mutex;
-    if (!flag)
-        g_access_mutex.lock();
+    g_access_mutex.lock();
 
     uint32_t old_val = g_val;
     if (flag)
@@ -33,17 +32,14 @@ access_pool (bool flag = false)
         g_val = old_val + 1;
     }
 
-    if (!flag)
-        g_access_mutex.unlock();
+    g_access_mutex.unlock();
     return g_val;
 }
 
 void
 thread_func (uint32_t thread_index)
 {
-    // Break here in order to allow the thread
-    // to inherit the global watchpoint state.
-    printf ("%s (thread index = %u) startng...\n", __FUNCTION__, thread_index);
+    printf ("%s (thread index = %u) starting...\n", __FUNCTION__, thread_index);
 
     uint32_t count = 0;
     uint32_t val;
diff --git a/packages/Python/lldbsuite/test/functionalities/watchpoint/step_over_watchpoint/TestStepOverWatchpoint.py b/packages/Python/lldbsuite/test/functionalities/watchpoint/step_over_watchpoint/TestStepOverWatchpoint.py
index f51da36b72d7..22011f11352c 100644
--- a/packages/Python/lldbsuite/test/functionalities/watchpoint/step_over_watchpoint/TestStepOverWatchpoint.py
+++ b/packages/Python/lldbsuite/test/functionalities/watchpoint/step_over_watchpoint/TestStepOverWatchpoint.py
@@ -5,8 +5,9 @@ from __future__ import print_function
 
 
 import lldb
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
 
 
 class TestStepOverWatchpoint(TestBase):
@@ -17,8 +18,9 @@ class TestStepOverWatchpoint(TestBase):
         return ['basic_process']
 
     @expectedFailureAndroid(archs=['arm', 'aarch64']) # Watchpoints not supported
-    @expectedFailureLinux(bugnumber="llvm.org/pr26031", archs=['arm'])
-    @expectedFailureWindows("llvm.org/pr24446")
+    @expectedFailureAll(oslist=["linux"], archs=['aarch64', 'arm'], bugnumber="llvm.org/pr26031")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
+    @expectedFailureAll(archs=['s390x']) # Read-write watchpoints not supported on SystemZ
     def test(self):
         """Test stepping over watchpoints."""
         self.build()
@@ -73,7 +75,7 @@ class TestStepOverWatchpoint(TestBase):
 
         # Most of the MIPS boards provide only one H/W watchpoints, and S/W watchpoints are not supported yet
         arch = self.getArchitecture()
-        if arch in ['mips', 'mipsel', 'mips64', 'mips64el']:
+        if re.match("^mips",arch):
             self.runCmd("watchpoint delete 1")
 
         # resolve_location=True, read=False, write=True
diff --git a/packages/Python/lldbsuite/test/functionalities/watchpoint/watchpoint_commands/TestWatchpointCommands.py b/packages/Python/lldbsuite/test/functionalities/watchpoint/watchpoint_commands/TestWatchpointCommands.py
index 339de45a085a..4ce05af96e2e 100644
--- a/packages/Python/lldbsuite/test/functionalities/watchpoint/watchpoint_commands/TestWatchpointCommands.py
+++ b/packages/Python/lldbsuite/test/functionalities/watchpoint/watchpoint_commands/TestWatchpointCommands.py
@@ -8,8 +8,9 @@ from __future__ import print_function
 
 import os, time
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbutil
 
 class WatchpointCommandsTestCase(TestBase):
 
@@ -30,7 +31,8 @@ class WatchpointCommandsTestCase(TestBase):
         self.d = {'C_SOURCES': self.source, 'EXE': self.exe_name}
 
     @expectedFailureAndroid(archs=['arm', 'aarch64']) # Watchpoints not supported
-    @expectedFailureWindows("llvm.org/pr24446") # WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
+    @expectedFailureAll(archs=['s390x']) # Read-write watchpoints not supported on SystemZ
     def test_rw_watchpoint(self):
         """Test read_write watchpoint and expect to stop two times."""
         self.build(dictionary=self.d)
@@ -90,7 +92,8 @@ class WatchpointCommandsTestCase(TestBase):
             substrs = ['hit_count = 2'])
 
     @expectedFailureAndroid(archs=['arm', 'aarch64']) # Watchpoints not supported
-    @expectedFailureWindows("llvm.org/pr24446") # WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
+    @expectedFailureAll(archs=['s390x']) # Read-write watchpoints not supported on SystemZ
     def test_rw_watchpoint_delete(self):
         """Test delete watchpoint and expect not to stop for watchpoint."""
         self.build(dictionary=self.d)
@@ -135,7 +138,8 @@ class WatchpointCommandsTestCase(TestBase):
             substrs = ['exited'])
 
     @expectedFailureAndroid(archs=['arm', 'aarch64']) # Watchpoints not supported
-    @expectedFailureWindows("llvm.org/pr24446") # WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
+    @expectedFailureAll(archs=['s390x']) # Read-write watchpoints not supported on SystemZ
     def test_rw_watchpoint_set_ignore_count(self):
         """Test watchpoint ignore count and expect to not to stop at all."""
         self.build(dictionary=self.d)
@@ -184,7 +188,8 @@ class WatchpointCommandsTestCase(TestBase):
             substrs = ['hit_count = 2', 'ignore_count = 2'])
 
     @expectedFailureAndroid(archs=['arm', 'aarch64']) # Watchpoints not supported
-    @expectedFailureWindows("llvm.org/pr24446") # WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
+    @expectedFailureAll(archs=['s390x']) # Read-write watchpoints not supported on SystemZ
     def test_rw_disable_after_first_stop(self):
         """Test read_write watchpoint but disable it after the first stop."""
         self.build(dictionary=self.d)
@@ -243,7 +248,8 @@ class WatchpointCommandsTestCase(TestBase):
             substrs = ['hit_count = 1'])
 
     @expectedFailureAndroid(archs=['arm', 'aarch64']) # Watchpoints not supported
-    @expectedFailureWindows("llvm.org/pr24446") # WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
+    @expectedFailureAll(archs=['s390x']) # Read-write watchpoints not supported on SystemZ
     def test_rw_disable_then_enable(self):
         """Test read_write watchpoint, disable initially, then enable it."""
         self.build(dictionary=self.d)
diff --git a/packages/Python/lldbsuite/test/functionalities/watchpoint/watchpoint_commands/command/TestWatchpointCommandLLDB.py b/packages/Python/lldbsuite/test/functionalities/watchpoint/watchpoint_commands/command/TestWatchpointCommandLLDB.py
index f2bf90866330..ee276dd5687f 100644
--- a/packages/Python/lldbsuite/test/functionalities/watchpoint/watchpoint_commands/command/TestWatchpointCommandLLDB.py
+++ b/packages/Python/lldbsuite/test/functionalities/watchpoint/watchpoint_commands/command/TestWatchpointCommandLLDB.py
@@ -8,8 +8,9 @@ from __future__ import print_function
 
 import os, time
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbutil
 
 class WatchpointLLDBCommandTestCase(TestBase):
 
@@ -29,7 +30,8 @@ class WatchpointLLDBCommandTestCase(TestBase):
         self.d = {'CXX_SOURCES': self.source, 'EXE': self.exe_name}
 
     @expectedFailureAndroid(archs=['arm', 'aarch64']) # Watchpoints not supported
-    @expectedFailureWindows("llvm.org/pr24446") # WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows
+    @expectedFailureAll(oslist=["linux"], archs=["aarch64"], bugnumber="llvm.org/pr27710")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
     def test_watchpoint_command(self):
         """Test 'watchpoint command'."""
         self.build(dictionary=self.d)
@@ -83,7 +85,8 @@ class WatchpointLLDBCommandTestCase(TestBase):
             substrs = ['(int32_t)', 'cookie = 777'])
 
     @expectedFailureAndroid(archs=['arm', 'aarch64']) # Watchpoints not supported
-    @expectedFailureWindows("llvm.org/pr24446") # WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows
+    @expectedFailureAll(oslist=["linux"], archs=["aarch64"], bugnumber="llvm.org/pr27710")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
     def test_watchpoint_command_can_disable_a_watchpoint(self):
         """Test that 'watchpoint command' action can disable a watchpoint after it is triggered."""
         self.build(dictionary=self.d)
diff --git a/packages/Python/lldbsuite/test/functionalities/watchpoint/watchpoint_commands/command/TestWatchpointCommandPython.py b/packages/Python/lldbsuite/test/functionalities/watchpoint/watchpoint_commands/command/TestWatchpointCommandPython.py
index a476aebb8db9..f6ea4fc16861 100644
--- a/packages/Python/lldbsuite/test/functionalities/watchpoint/watchpoint_commands/command/TestWatchpointCommandPython.py
+++ b/packages/Python/lldbsuite/test/functionalities/watchpoint/watchpoint_commands/command/TestWatchpointCommandPython.py
@@ -8,8 +8,9 @@ from __future__ import print_function
 
 import os, time
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbutil
 
 class WatchpointPythonCommandTestCase(TestBase):
 
@@ -29,8 +30,9 @@ class WatchpointPythonCommandTestCase(TestBase):
         self.d = {'CXX_SOURCES': self.source, 'EXE': self.exe_name}
 
     @skipIfFreeBSD # timing out on buildbot
-    @expectedFailureWindows("llvm.org/pr24446") # WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
     @expectedFailureAndroid(archs=['arm', 'aarch64']) # Watchpoints not supported
+    @expectedFailureAll(oslist=["linux"], archs=["aarch64"], bugnumber="llvm.org/pr27710")
     def test_watchpoint_command(self):
         """Test 'watchpoint command'."""
         self.build(dictionary=self.d)
@@ -85,3 +87,57 @@ class WatchpointPythonCommandTestCase(TestBase):
         # The watchpoint command "forced" our global variable 'cookie' to become 777.
         self.expect("frame variable --show-globals cookie",
             substrs = ['(int32_t)', 'cookie = 777'])
+
+    @skipIfFreeBSD # timing out on buildbot
+    @expectedFailureAll(bugnumber="llvm.org/pr28055: continue in watchpoint commands disables the watchpoint")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
+    @expectedFailureAndroid(archs=['arm', 'aarch64']) # Watchpoints not supported
+    @expectedFailureAll(oslist=["linux"], archs=["aarch64"], bugnumber="llvm.org/pr27710")
+    def test_continue_in_watchpoint_command(self):
+        """Test continue in a watchpoint command."""
+        self.build(dictionary=self.d)
+        self.setTearDownCleanup(dictionary=self.d)
+
+        exe = os.path.join(os.getcwd(), self.exe_name)
+        self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
+
+        # Add a breakpoint to set a watchpoint when stopped on the breakpoint.
+        lldbutil.run_break_set_by_file_and_line (self, None, self.line, num_expected_locations=1)
+#        self.expect("breakpoint set -l %d" % self.line, BREAKPOINT_CREATED,
+#            startstr = "Breakpoint created: 1: file ='%s', line = %d, locations = 1" %
+#                       (self.source, self.line))#
+
+        # Run the program.
+        self.runCmd("run", RUN_SUCCEEDED)
+
+        # We should be stopped again due to the breakpoint.
+        # The stop reason of the thread should be breakpoint.
+        self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
+            substrs = ['stopped',
+                       'stop reason = breakpoint'])
+
+        # Now let's set a write-type watchpoint for 'global'.
+        self.expect("watchpoint set variable -w write global", WATCHPOINT_CREATED,
+            substrs = ['Watchpoint created', 'size = 4', 'type = w',
+                       '%s:%d' % (self.source, self.decl)])
+
+        cmd_script_file = os.path.join(os.getcwd(), "watchpoint_command.py")
+        self.runCmd("command script import '%s'"%(cmd_script_file))
+
+        self.runCmd('watchpoint command add -F watchpoint_command.watchpoint_command')
+
+        # List the watchpoint command we just added.
+        self.expect("watchpoint command list 1",
+            substrs = ['watchpoint_command.watchpoint_command'])
+
+        self.runCmd("process continue")
+
+        # We should be stopped again due to the watchpoint (write type).
+        # The stop reason of the thread should be watchpoint.
+        self.expect("thread backtrace", STOPPED_DUE_TO_WATCHPOINT,
+            substrs = ['stop reason = watchpoint'])
+
+        # We should have hit the watchpoint once, set cookie to 888, then continued to the
+        # second hit and set it to 999
+        self.expect("frame variable --show-globals cookie",
+            substrs = ['(int32_t)', 'cookie = 999'])
diff --git a/packages/Python/lldbsuite/test/functionalities/watchpoint/watchpoint_commands/command/watchpoint_command.py b/packages/Python/lldbsuite/test/functionalities/watchpoint/watchpoint_commands/command/watchpoint_command.py
new file mode 100644
index 000000000000..575a5160d219
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/watchpoint/watchpoint_commands/command/watchpoint_command.py
@@ -0,0 +1,14 @@
+import lldb
+
+num_hits = 0
+def watchpoint_command (frame, wp, dict):
+    global num_hits
+    if num_hits == 0:
+        print ("I stopped the first time")
+        frame.EvaluateExpression("cookie = 888")
+        num_hits += 1
+        frame.thread.process.Continue()
+    else:
+        print ("I stopped the %d time"%(num_hits))
+        frame.EvaluateExpression("cookie = 999")
+
diff --git a/packages/Python/lldbsuite/test/functionalities/watchpoint/watchpoint_commands/condition/TestWatchpointConditionCmd.py b/packages/Python/lldbsuite/test/functionalities/watchpoint/watchpoint_commands/condition/TestWatchpointConditionCmd.py
index 355204a4ce1e..64e01e5cb937 100644
--- a/packages/Python/lldbsuite/test/functionalities/watchpoint/watchpoint_commands/condition/TestWatchpointConditionCmd.py
+++ b/packages/Python/lldbsuite/test/functionalities/watchpoint/watchpoint_commands/condition/TestWatchpointConditionCmd.py
@@ -8,8 +8,9 @@ from __future__ import print_function
 
 import os, time
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbutil
 
 class WatchpointConditionCmdTestCase(TestBase):
 
@@ -29,7 +30,8 @@ class WatchpointConditionCmdTestCase(TestBase):
         self.d = {'CXX_SOURCES': self.source, 'EXE': self.exe_name}
 
     @expectedFailureAndroid(archs=['arm', 'aarch64']) # Watchpoints not supported
-    @expectedFailureWindows("llvm.org/pr24446") # WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows
+    @expectedFailureAll(oslist=["linux"], archs=["aarch64"], bugnumber="llvm.org/pr27710")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
     def test_watchpoint_cond(self):
         """Test watchpoint condition."""
         self.build(dictionary=self.d)
diff --git a/packages/Python/lldbsuite/test/functionalities/watchpoint/watchpoint_events/TestWatchpointEvents.py b/packages/Python/lldbsuite/test/functionalities/watchpoint/watchpoint_events/TestWatchpointEvents.py
index e4d6e019c20e..fdeb4b8fa3b5 100644
--- a/packages/Python/lldbsuite/test/functionalities/watchpoint/watchpoint_events/TestWatchpointEvents.py
+++ b/packages/Python/lldbsuite/test/functionalities/watchpoint/watchpoint_events/TestWatchpointEvents.py
@@ -6,8 +6,9 @@ from __future__ import print_function
 
 import os, time
 import lldb
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
 
 class TestWatchpointEvents (TestBase):
 
@@ -21,7 +22,8 @@ class TestWatchpointEvents (TestBase):
 
     @add_test_categories(['pyapi'])
     @expectedFailureAndroid(archs=['arm', 'aarch64']) # Watchpoints not supported
-    @expectedFailureWindows("llvm.org/pr24446") # WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows
+    @expectedFailureAll(oslist=["linux"], archs=["aarch64"], bugnumber="llvm.org/pr27710")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
     def test_with_python_api(self):
         """Test that adding, deleting and modifying watchpoints sends the appropriate events."""
         self.build()
@@ -58,7 +60,7 @@ class TestWatchpointEvents (TestBase):
         self.listener.StartListeningForEvents (self.target_bcast, lldb.SBTarget.eBroadcastBitWatchpointChanged)
 
         error = lldb.SBError()
-        local_watch = local_var.Watch(True, True, True, error)
+        local_watch = local_var.Watch(True, False, True, error)
         if not error.Success():
             self.fail ("Failed to make watchpoint for local_var: %s"%(error.GetCString()))
 
diff --git a/packages/Python/lldbsuite/test/functionalities/watchpoint/watchpoint_on_vectors/TestValueOfVectorVariable.py b/packages/Python/lldbsuite/test/functionalities/watchpoint/watchpoint_on_vectors/TestValueOfVectorVariable.py
index 73752d2d18d5..c66ddb512884 100644
--- a/packages/Python/lldbsuite/test/functionalities/watchpoint/watchpoint_on_vectors/TestValueOfVectorVariable.py
+++ b/packages/Python/lldbsuite/test/functionalities/watchpoint/watchpoint_on_vectors/TestValueOfVectorVariable.py
@@ -8,15 +8,16 @@ from __future__ import print_function
 
 import os, time
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbutil
 
 class TestValueOfVectorVariableTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @expectedFailureAndroid(archs=['arm', 'aarch64']) # Watchpoints not supported
-    @expectedFailureWindows("llvm.org/pr24446") # WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
     def test_value_of_vector_variable_using_watchpoint_set(self):
         """Test verify displayed value of vector variable."""
         self.build(dictionary=self.d)
diff --git a/packages/Python/lldbsuite/test/functionalities/watchpoint/watchpoint_on_vectors/main.c b/packages/Python/lldbsuite/test/functionalities/watchpoint/watchpoint_on_vectors/main.c
index 98f8c477eb31..ac2370e32d2a 100644
--- a/packages/Python/lldbsuite/test/functionalities/watchpoint/watchpoint_on_vectors/main.c
+++ b/packages/Python/lldbsuite/test/functionalities/watchpoint/watchpoint_on_vectors/main.c
@@ -6,7 +6,7 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-typedef char v4i8 __attribute__ ((vector_size(4)));
+typedef signed char v4i8 __attribute__ ((vector_size(4)));
 v4i8 global_vector = {1, 2, 3, 4};
 
 int
diff --git a/packages/Python/lldbsuite/test/functionalities/watchpoint/watchpoint_set_command/TestWatchLocationWithWatchSet.py b/packages/Python/lldbsuite/test/functionalities/watchpoint/watchpoint_set_command/TestWatchLocationWithWatchSet.py
index 9301a6f9fd00..735a5678c4f9 100644
--- a/packages/Python/lldbsuite/test/functionalities/watchpoint/watchpoint_set_command/TestWatchLocationWithWatchSet.py
+++ b/packages/Python/lldbsuite/test/functionalities/watchpoint/watchpoint_set_command/TestWatchLocationWithWatchSet.py
@@ -8,8 +8,9 @@ from __future__ import print_function
 
 import os, time
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test import lldbutil
 
 class WatchLocationUsingWatchpointSetTestCase(TestBase):
 
@@ -27,8 +28,8 @@ class WatchLocationUsingWatchpointSetTestCase(TestBase):
         # Build dictionary to have unique executable names for each test method.
 
     @expectedFailureAndroid(archs=['arm', 'aarch64']) # Watchpoints not supported
-    @expectedFailureLinux(bugnumber="llvm.org/pr26031", archs=['arm'])
-    @expectedFailureWindows("llvm.org/pr24446") # WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows
+    @expectedFailureAll(oslist=["linux"], archs=['aarch64', 'arm'], bugnumber="llvm.org/pr26031")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
     def test_watchlocation_using_watchpoint_set(self):
         """Test watching a location with 'watchpoint set expression -w write -s size' option."""
         self.build()
diff --git a/packages/Python/lldbsuite/test/functionalities/watchpoint/watchpoint_set_command/TestWatchpointSetErrorCases.py b/packages/Python/lldbsuite/test/functionalities/watchpoint/watchpoint_set_command/TestWatchpointSetErrorCases.py
index 27c759e6fb64..43597ec28f59 100644
--- a/packages/Python/lldbsuite/test/functionalities/watchpoint/watchpoint_set_command/TestWatchpointSetErrorCases.py
+++ b/packages/Python/lldbsuite/test/functionalities/watchpoint/watchpoint_set_command/TestWatchpointSetErrorCases.py
@@ -8,6 +8,7 @@ from __future__ import print_function
 
 import os, time
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 import lldbsuite.test.lldbutil as lldbutil
 
@@ -24,6 +25,7 @@ class WatchpointSetErrorTestCase(TestBase):
         self.line = line_number(self.source, '// Set break point at this line.')
         # Build dictionary to have unique executable names for each test method.
 
+    @expectedFailureAll(oslist=["windows"])
     def test_error_cases_with_watchpoint_set(self):
         """Test error cases with the 'watchpoint set' command."""
         self.build()
diff --git a/packages/Python/lldbsuite/test/functionalities/watchpoint/watchpoint_size/Makefile b/packages/Python/lldbsuite/test/functionalities/watchpoint/watchpoint_size/Makefile
new file mode 100644
index 000000000000..b09a579159d4
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/watchpoint/watchpoint_size/Makefile
@@ -0,0 +1,5 @@
+LEVEL = ../../../make
+
+C_SOURCES := main.c
+
+include $(LEVEL)/Makefile.rules
diff --git a/packages/Python/lldbsuite/test/functionalities/watchpoint/watchpoint_size/TestWatchpointSizes.py b/packages/Python/lldbsuite/test/functionalities/watchpoint/watchpoint_size/TestWatchpointSizes.py
new file mode 100644
index 000000000000..55e36649ce10
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/watchpoint/watchpoint_size/TestWatchpointSizes.py
@@ -0,0 +1,117 @@
+"""
+Test watchpoint size cases (1-byte, 2-byte, 4-byte).
+Make sure we can watch all bytes, words or double words individually
+when they are packed in a 8-byte region.
+
+"""
+
+from __future__ import print_function
+
+import os, time
+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+class WatchpointSizeTestCase(TestBase):
+    NO_DEBUG_INFO_TESTCASE = True
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    def setUp(self):
+        # Call super's setUp().
+        TestBase.setUp(self)
+
+        # Source filename.
+        self.source = 'main.c'
+
+        # Output filename.
+        self.exe_name = 'a.out'
+        self.d = {'C_SOURCES': self.source, 'EXE': self.exe_name}
+
+    @expectedFailureAndroid(archs=['arm', 'aarch64']) # Watchpoints not supported
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
+    @expectedFailureAll(archs=['s390x']) # Read-write watchpoints not supported on SystemZ
+    def test_byte_size_watchpoints_with_byte_selection(self):
+        """Test to selectively watch different bytes in a 8-byte array."""
+        self.run_watchpoint_size_test('byteArray', 8, '1')
+
+    @expectedFailureAndroid(archs=['arm', 'aarch64']) # Watchpoints not supported
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
+    @expectedFailureAll(archs=['s390x']) # Read-write watchpoints not supported on SystemZ
+    def test_two_byte_watchpoints_with_word_selection(self):
+        """Test to selectively watch different words in an 8-byte word array."""
+        self.run_watchpoint_size_test('wordArray', 4, '2')
+
+    @expectedFailureAndroid(archs=['arm', 'aarch64']) # Watchpoints not supported
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
+    @expectedFailureAll(archs=['s390x']) # Read-write watchpoints not supported on SystemZ
+    def test_four_byte_watchpoints_with_dword_selection(self):
+        """Test to selectively watch two double words in an 8-byte dword array."""
+        self.run_watchpoint_size_test('dwordArray', 2, '4')
+
+    def run_watchpoint_size_test(self, arrayName, array_size, watchsize):
+        self.build(dictionary=self.d)
+        self.setTearDownCleanup(dictionary=self.d)
+
+        exe = os.path.join(os.getcwd(), self.exe_name)
+        self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
+
+        # Detect line number after which we are going to increment arrayName.
+        loc_line = line_number('main.c', '// About to write ' + arrayName)
+
+        # Set a breakpoint on the line detected above.
+        lldbutil.run_break_set_by_file_and_line (self, "main.c",loc_line,
+            num_expected_locations=1, loc_exact=True)
+
+        # Run the program.
+        self.runCmd("run", RUN_SUCCEEDED)
+
+        for i in range(array_size):
+            # We should be stopped again due to the breakpoint.
+            # The stop reason of the thread should be breakpoint.
+            self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
+                substrs = ['stopped', 'stop reason = breakpoint'])
+
+            # Set a read_write type watchpoint arrayName
+            watch_loc=arrayName+"[" + str(i) + "]"
+            self.expect("watchpoint set variable -w read_write " + watch_loc,
+                WATCHPOINT_CREATED,
+            substrs = ['Watchpoint created', 'size = ' + watchsize, 'type = rw'])
+
+            # Use the '-v' option to do verbose listing of the watchpoint.
+            # The hit count should be 0 initially.
+            self.expect("watchpoint list -v", substrs = ['hit_count = 0'])
+
+            self.runCmd("process continue")
+
+            # We should be stopped due to the watchpoint.
+            # The stop reason of the thread should be watchpoint.
+            self.expect("thread list", STOPPED_DUE_TO_WATCHPOINT,
+            substrs = ['stopped', 'stop reason = watchpoint'])
+
+            # Use the '-v' option to do verbose listing of the watchpoint.
+            # The hit count should now be 1.
+            self.expect("watchpoint list -v",
+                substrs = ['hit_count = 1'])
+
+            self.runCmd("process continue")
+
+            # We should be stopped due to the watchpoint.
+            # The stop reason of the thread should be watchpoint.
+            self.expect("thread list", STOPPED_DUE_TO_WATCHPOINT,
+            substrs = ['stopped', 'stop reason = watchpoint'])
+
+            # Use the '-v' option to do verbose listing of the watchpoint.
+            # The hit count should now be 1.
+            # Verify hit_count has been updated after value has been read.
+            self.expect("watchpoint list -v",
+                substrs = ['hit_count = 2'])
+
+            # Delete the watchpoint immediately, but set auto-confirm to true first.
+            self.runCmd("settings set auto-confirm true")
+            self.expect("watchpoint delete", substrs = ['All watchpoints removed.'])
+            # Restore the original setting of auto-confirm.
+            self.runCmd("settings clear auto-confirm")
+
+            self.runCmd("process continue")
diff --git a/packages/Python/lldbsuite/test/functionalities/watchpoint/watchpoint_size/main.c b/packages/Python/lldbsuite/test/functionalities/watchpoint/watchpoint_size/main.c
new file mode 100644
index 000000000000..ed9fed1e2113
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/watchpoint/watchpoint_size/main.c
@@ -0,0 +1,66 @@
+//===-- main.c --------------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#include <stdio.h>
+#include <stdint.h>
+
+uint64_t pad0 = 0;
+uint8_t byteArray[8] = {0};
+uint64_t pad1 = 0;
+uint16_t wordArray[4] = {0};
+uint64_t pad2 = 0;
+uint32_t dwordArray[2] = {0};
+
+int main(int argc, char** argv) {
+
+    int i;
+    uint8_t localByte;
+    uint16_t localWord;
+    uint32_t localDword;
+
+    for (i = 0; i < 8; i++)
+    {
+        printf("About to write byteArray[%d] ...\n", i); // About to write byteArray
+        pad0++;
+        byteArray[i] = 7;
+        pad1++;
+        localByte = byteArray[i]; // Here onwards we should'nt be stopped in loop
+        byteArray[i]++;
+        localByte = byteArray[i];
+    }
+
+    pad0 = 0;
+    pad1 = 0;
+
+    for (i = 0; i < 4; i++)
+    {
+        printf("About to write wordArray[%d] ...\n", i); // About to write wordArray
+        pad0++;
+        wordArray[i] = 7;
+        pad1++;
+        localWord = wordArray[i]; // Here onwards we should'nt be stopped in loop
+        wordArray[i]++;
+        localWord = wordArray[i];
+    }
+
+    pad0 = 0;
+    pad1 = 0;
+
+    for (i = 0; i < 2; i++)
+    {
+        printf("About to write dwordArray[%d] ...\n", i); // About to write dwordArray
+        pad0++;
+        dwordArray[i] = 7;
+        pad1++;
+        localDword = dwordArray[i]; // Here onwards we shouldn't be stopped in loop
+        dwordArray[i]++;
+        localDword = dwordArray[i];
+    }
+
+    return 0;
+}