Now that we have added a post-processing step for adding truth value testing to

those lldb objects which implement the IsValid() method, let's change the rest of
the test suite to use the more compact truth value testing pattern (the Python way).

llvm-svn: 131970

27 files changed, 137 insertions, 137 deletions

diff --git a/lldb/test/array_types/TestArrayTypes.py b/lldb/test/array_types/TestArrayTypes.py
index ec243208c3f..bf1ae12073b 100644
--- a/lldb/test/array_types/TestArrayTypes.py
+++ b/lldb/test/array_types/TestArrayTypes.py
@@ -95,10 +95,10 @@ class ArrayTypesTestCase(TestBase):
         exe = os.path.join(os.getcwd(), "a.out")
 
         target = self.dbg.CreateTarget(exe)
-        self.assertTrue(target.IsValid(), VALID_TARGET)
+        self.assertTrue(target, VALID_TARGET)
 
         breakpoint = target.BreakpointCreateByLocation("main.c", self.line)
-        self.assertTrue(breakpoint.IsValid(), VALID_BREAKPOINT)
+        self.assertTrue(breakpoint, VALID_BREAKPOINT)
 
         # Sanity check the print representation of breakpoint.
         bp = repr(breakpoint)
@@ -113,7 +113,7 @@ class ArrayTypesTestCase(TestBase):
         self.process = target.LaunchSimple(None, None, os.getcwd())
 
         self.process = target.GetProcess()
-        self.assertTrue(self.process.IsValid(), PROCESS_IS_VALID)
+        self.assertTrue(self.process, PROCESS_IS_VALID)
 
         # Sanity check the print representation of process.
         proc = repr(self.process)
diff --git a/lldb/test/bitfields/TestBitfields.py b/lldb/test/bitfields/TestBitfields.py
index 7381f7c7ca6..e192654153c 100644
--- a/lldb/test/bitfields/TestBitfields.py
+++ b/lldb/test/bitfields/TestBitfields.py
@@ -89,13 +89,13 @@ class BitfieldsTestCase(TestBase):
         exe = os.path.join(os.getcwd(), "a.out")
 
         target = self.dbg.CreateTarget(exe)
-        self.assertTrue(target.IsValid(), VALID_TARGET)
+        self.assertTrue(target, VALID_TARGET)
 
         breakpoint = target.BreakpointCreateByLocation("main.c", self.line)
-        self.assertTrue(breakpoint.IsValid(), VALID_BREAKPOINT)
+        self.assertTrue(breakpoint, VALID_BREAKPOINT)
 
         self.process = target.LaunchSimple(None, None, os.getcwd())
-        self.assertTrue(self.process.IsValid(), PROCESS_IS_VALID)
+        self.assertTrue(self.process, PROCESS_IS_VALID)
 
         # The stop reason of the thread should be breakpoint.
         thread = target.GetProcess().GetThreadAtIndex(0)
diff --git a/lldb/test/breakpoint_conditions/TestBreakpointConditions.py b/lldb/test/breakpoint_conditions/TestBreakpointConditions.py
index b3a550c2246..ea4186e6dec 100644
--- a/lldb/test/breakpoint_conditions/TestBreakpointConditions.py
+++ b/lldb/test/breakpoint_conditions/TestBreakpointConditions.py
@@ -104,12 +104,12 @@ class BreakpointConditionsTestCase(TestBase):
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)
-        self.assertTrue(target.IsValid(), VALID_TARGET)
+        self.assertTrue(target, VALID_TARGET)
 
         # Now create a breakpoint on main.c by name 'c'.
         breakpoint = target.BreakpointCreateByName('c', 'a.out')
         #print "breakpoint:", breakpoint
-        self.assertTrue(breakpoint.IsValid() and
+        self.assertTrue(breakpoint and
                         breakpoint.GetNumLocations() == 1,
                         VALID_BREAKPOINT)
 
@@ -129,7 +129,7 @@ class BreakpointConditionsTestCase(TestBase):
         # Get the breakpoint location from breakpoint after we verified that,
         # indeed, it has one location.
         location = breakpoint.GetLocationAtIndex(0)
-        self.assertTrue(location.IsValid() and
+        self.assertTrue(location and
                         location.IsEnabled(),
                         VALID_BREAKPOINT_LOCATION)
 
@@ -142,7 +142,7 @@ class BreakpointConditionsTestCase(TestBase):
         self.process = target.LaunchSimple(None, None, os.getcwd())
 
         self.process = target.GetProcess()
-        self.assertTrue(self.process.IsValid(), PROCESS_IS_VALID)
+        self.assertTrue(self.process, PROCESS_IS_VALID)
 
         # Frame #0 should be on self.line1 and the break condition should hold.
         from lldbutil import get_stopped_thread
diff --git a/lldb/test/breakpoint_ignore_count/TestBreakpointIgnoreCount.py b/lldb/test/breakpoint_ignore_count/TestBreakpointIgnoreCount.py
index 27156c1f08f..f36db669e0a 100644
--- a/lldb/test/breakpoint_ignore_count/TestBreakpointIgnoreCount.py
+++ b/lldb/test/breakpoint_ignore_count/TestBreakpointIgnoreCount.py
@@ -80,18 +80,18 @@ class BreakpointIgnoreCountTestCase(TestBase):
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)
-        self.assertTrue(target.IsValid(), VALID_TARGET)
+        self.assertTrue(target, VALID_TARGET)
 
         # Now create a breakpoint on main.c by name 'c'.
         breakpoint = target.BreakpointCreateByName('c', 'a.out')
-        self.assertTrue(breakpoint.IsValid() and
+        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.IsValid() and
+        self.assertTrue(location and
                         location.IsEnabled(),
                         VALID_BREAKPOINT_LOCATION)
 
@@ -104,7 +104,7 @@ class BreakpointIgnoreCountTestCase(TestBase):
         self.process = target.LaunchSimple(None, None, os.getcwd())
 
         self.process = target.GetProcess()
-        self.assertTrue(self.process.IsValid(), PROCESS_IS_VALID)
+        self.assertTrue(self.process, PROCESS_IS_VALID)
 
         # Frame#0 should be on main.c:37, frame#1 should be on main.c:25, and
         # frame#2 should be on main.c:48.
diff --git a/lldb/test/class_static/TestStaticVariables.py b/lldb/test/class_static/TestStaticVariables.py
index 12ff77853a5..e1aa9de8f56 100644
--- a/lldb/test/class_static/TestStaticVariables.py
+++ b/lldb/test/class_static/TestStaticVariables.py
@@ -74,16 +74,16 @@ class StaticVariableTestCase(TestBase):
         exe = os.path.join(os.getcwd(), "a.out")
 
         target = self.dbg.CreateTarget(exe)
-        self.assertTrue(target.IsValid(), VALID_TARGET)
+        self.assertTrue(target, VALID_TARGET)
 
         breakpoint = target.BreakpointCreateByLocation("main.cpp", self.line)
-        self.assertTrue(breakpoint.IsValid(), VALID_BREAKPOINT)
+        self.assertTrue(breakpoint, VALID_BREAKPOINT)
 
         # Now launch the process, and do not stop at entry point.
         self.process = target.LaunchSimple(None, None, os.getcwd())
 
         self.process = target.GetProcess()
-        self.assertTrue(self.process.IsValid(), PROCESS_IS_VALID)
+        self.assertTrue(self.process, PROCESS_IS_VALID)
 
         # The stop reason of the thread should be breakpoint.
         thread = self.process.GetThreadAtIndex(0)
diff --git a/lldb/test/class_types/TestClassTypes.py b/lldb/test/class_types/TestClassTypes.py
index 0205cc9362e..164e05c9101 100644
--- a/lldb/test/class_types/TestClassTypes.py
+++ b/lldb/test/class_types/TestClassTypes.py
@@ -97,10 +97,10 @@ class ClassTypesTestCase(TestBase):
         exe = os.path.join(os.getcwd(), "a.out")
 
         target = self.dbg.CreateTarget(exe)
-        self.assertTrue(target.IsValid(), VALID_TARGET)
+        self.assertTrue(target, VALID_TARGET)
 
         filespec = target.GetExecutable()
-        self.assertTrue(filespec.IsValid(), VALID_FILESPEC)
+        self.assertTrue(filespec, VALID_FILESPEC)
 
         fsDir = filespec.GetDirectory()
         fsFile = filespec.GetFilename()
@@ -111,7 +111,7 @@ class ClassTypesTestCase(TestBase):
         bpfilespec = lldb.SBFileSpec("main.cpp", False)
 
         breakpoint = target.BreakpointCreateByLocation(bpfilespec, self.line)
-        self.assertTrue(breakpoint.IsValid(), VALID_BREAKPOINT)
+        self.assertTrue(breakpoint, VALID_BREAKPOINT)
 
         # Verify the breakpoint just created.
         self.expect(repr(breakpoint), BREAKPOINT_CREATED, exe=False,
@@ -123,7 +123,7 @@ class ClassTypesTestCase(TestBase):
         self.process = target.Launch (self.dbg.GetListener(), None, None, os.ctermid(), os.ctermid(), os.ctermid(), None, 0, False, error)
         #self.breakAfterLaunch(self.process, "C::C(int, int, int)")
 
-        if not error.Success() or not self.process.IsValid():
+        if not error.Success() or not self.process:
             self.fail("SBTarget.Launch() failed")
 
         if self.process.GetState() != lldb.eStateStopped:
diff --git a/lldb/test/class_types/TestClassTypesDisassembly.py b/lldb/test/class_types/TestClassTypesDisassembly.py
index 5c144dc3297..3cb10dadf8a 100644
--- a/lldb/test/class_types/TestClassTypesDisassembly.py
+++ b/lldb/test/class_types/TestClassTypesDisassembly.py
@@ -100,7 +100,7 @@ class IterateFrameAndDisassembleTestCase(TestBase):
             if self.TraceOn():
                 print
                 print function
-            if function.IsValid():
+            if function:
                 # Get all instructions for this function and print them out.
                 insts = function.GetInstructions(target)
                 for inst in insts:
diff --git a/lldb/test/conditional_break/TestConditionalBreak.py b/lldb/test/conditional_break/TestConditionalBreak.py
index 1fe21db80e7..ea9df4e245e 100644
--- a/lldb/test/conditional_break/TestConditionalBreak.py
+++ b/lldb/test/conditional_break/TestConditionalBreak.py
@@ -46,16 +46,16 @@ class ConditionalBreakTestCase(TestBase):
         exe = os.path.join(os.getcwd(), "a.out")
 
         target = self.dbg.CreateTarget(exe)
-        self.assertTrue(target.IsValid(), VALID_TARGET)
+        self.assertTrue(target, VALID_TARGET)
 
         breakpoint = target.BreakpointCreateByName("c", exe)
-        self.assertTrue(breakpoint.IsValid(), VALID_BREAKPOINT)
+        self.assertTrue(breakpoint, VALID_BREAKPOINT)
 
         # Now launch the process, and do not stop at entry point.
         error = lldb.SBError()
         self.process = target.Launch (self.dbg.GetListener(), None, None, os.ctermid(), os.ctermid(), os.ctermid(), None, 0, False, error)
 
-        self.assertTrue(error.Success() and self.process.IsValid(), PROCESS_IS_VALID)
+        self.assertTrue(error.Success() and self.process, PROCESS_IS_VALID)
 
         # The stop reason of the thread should be breakpoint.
         self.assertTrue(self.process.GetState() == lldb.eStateStopped,
diff --git a/lldb/test/cpp/dynamic-value/TestDynamicValue.py b/lldb/test/cpp/dynamic-value/TestDynamicValue.py
index ae42847195d..c4ee6fd0b88 100644
--- a/lldb/test/cpp/dynamic-value/TestDynamicValue.py
+++ b/lldb/test/cpp/dynamic-value/TestDynamicValue.py
@@ -41,12 +41,12 @@ class DynamicValueTestCase(TestBase):
 
         # Get "this" as its static value
         
-        self.assertTrue (this_static.IsValid())
+        self.assertTrue (this_static)
         this_static_loc = int (this_static.GetValue(), 16)
         
         # Get "this" as its dynamic value
         
-        self.assertTrue (this_dynamic.IsValid())
+        self.assertTrue (this_dynamic)
         this_dynamic_typename = this_dynamic.GetTypeName()
         self.assertTrue (this_dynamic_typename.find('B') != -1)
         this_dynamic_loc = int (this_dynamic.GetValue(), 16)
@@ -65,7 +65,7 @@ class DynamicValueTestCase(TestBase):
         no_dynamic  = lldb.eNoDynamicValues
 
         this_dynamic_m_b_value = this_dynamic.GetChildMemberWithName('m_b_value', use_dynamic)
-        self.assertTrue (this_dynamic_m_b_value.IsValid())
+        self.assertTrue (this_dynamic_m_b_value)
         
         m_b_value = int (this_dynamic_m_b_value.GetValue(), 0)
         self.assertTrue (m_b_value == 10)
@@ -73,17 +73,17 @@ class DynamicValueTestCase(TestBase):
         # Make sure it is not in the static version
 
         this_static_m_b_value = this_static.GetChildMemberWithName('m_b_value', no_dynamic)
-        self.assertTrue (this_static_m_b_value.IsValid() == False)
+        self.assertFalse (this_static_m_b_value)
 
         # Okay, now let's make sure that we can get the dynamic type of a child element:
 
         contained_auto_ptr = this_dynamic.GetChildMemberWithName ('m_client_A', use_dynamic)
-        self.assertTrue (contained_auto_ptr.IsValid())
+        self.assertTrue (contained_auto_ptr)
         contained_b = contained_auto_ptr.GetChildMemberWithName ('_M_ptr', use_dynamic)
-        self.assertTrue (contained_b.IsValid())
+        self.assertTrue (contained_b)
         
         contained_b_static = contained_auto_ptr.GetChildMemberWithName ('_M_ptr', no_dynamic)
-        self.assertTrue (contained_b_static.IsValid())
+        self.assertTrue (contained_b_static)
         
         contained_b_addr = int (contained_b.GetValue(), 16)
         contained_b_static_addr = int (contained_b_static.GetValue(), 16)
@@ -97,20 +97,20 @@ class DynamicValueTestCase(TestBase):
         # Create a target from the debugger.
 
         target = self.dbg.CreateTarget (exe)
-        self.assertTrue(target.IsValid(), VALID_TARGET)
+        self.assertTrue(target, VALID_TARGET)
 
         # Set up our breakpoints:
 
         do_something_bpt = target.BreakpointCreateByLocation('pass-to-base.cpp', self.do_something_line)
-        self.assertTrue(do_something_bpt.IsValid(),
+        self.assertTrue(do_something_bpt,
                         VALID_BREAKPOINT)
 
         first_call_bpt = target.BreakpointCreateByLocation('pass-to-base.cpp', self.main_first_call_line)
-        self.assertTrue(first_call_bpt.IsValid(),
+        self.assertTrue(first_call_bpt,
                         VALID_BREAKPOINT)
 
         second_call_bpt = target.BreakpointCreateByLocation('pass-to-base.cpp', self.main_second_call_line)
-        self.assertTrue(second_call_bpt.IsValid(),
+        self.assertTrue(second_call_bpt,
                         VALID_BREAKPOINT)
 
         # Now launch the process, and do not stop at the entry point.
@@ -132,11 +132,11 @@ class DynamicValueTestCase(TestBase):
         no_dynamic  = lldb.eNoDynamicValues
 
         myB = frame.FindVariable ('myB', no_dynamic);
-        self.assertTrue (myB.IsValid())
+        self.assertTrue (myB)
         myB_loc = int (myB.GetLocation(), 16)
 
         otherB = frame.FindVariable('otherB', no_dynamic)
-        self.assertTrue (otherB.IsValid())
+        self.assertTrue (otherB)
         otherB_loc = int (otherB.GetLocation(), 16)
 
         # Okay now run to doSomething:
@@ -173,11 +173,11 @@ class DynamicValueTestCase(TestBase):
         # Now make sure we also get it right for a reference as well:
 
         anotherA_static = frame.FindVariable ('anotherA', False)
-        self.assertTrue (anotherA_static.IsValid())
+        self.assertTrue (anotherA_static)
         anotherA_static_addr = int (anotherA_static.GetValue(), 16)
 
         anotherA_dynamic = frame.FindVariable ('anotherA', True)
-        self.assertTrue (anotherA_dynamic.IsValid())
+        self.assertTrue (anotherA_dynamic)
         anotherA_dynamic_addr = int (anotherA_dynamic.GetValue(), 16)
         anotherA_dynamic_typename = anotherA_dynamic.GetTypeName()
         self.assertTrue (anotherA_dynamic_typename.find('B') != -1)
@@ -185,12 +185,12 @@ class DynamicValueTestCase(TestBase):
         self.assertTrue(anotherA_dynamic_addr < anotherA_static_addr)
 
         anotherA_m_b_value_dynamic = anotherA_dynamic.GetChildMemberWithName('m_b_value', True)
-        self.assertTrue (anotherA_m_b_value_dynamic.IsValid())
+        self.assertTrue (anotherA_m_b_value_dynamic)
         anotherA_m_b_val = int (anotherA_m_b_value_dynamic.GetValue(), 10)
         self.assertTrue (anotherA_m_b_val == 300)
 
         anotherA_m_b_value_static = anotherA_static.GetChildMemberWithName('m_b_value', True)
-        self.assertTrue (anotherA_m_b_value_static.IsValid() == False)
+        self.assertFalse (anotherA_m_b_value_static)
 
         # Okay, now continue again, and when we hit the second breakpoint in main
 
@@ -200,7 +200,7 @@ class DynamicValueTestCase(TestBase):
 
         frame = thread.GetFrameAtIndex(0)
         reallyA_value = frame.FindVariable ('reallyA', False)
-        self.assertTrue(reallyA_value.IsValid())
+        self.assertTrue(reallyA_value)
         reallyA_loc = int (reallyA_value.GetLocation(), 16)
         
         # Finally continue to doSomething again, and make sure we get the right value for anotherA,
@@ -212,7 +212,7 @@ class DynamicValueTestCase(TestBase):
 
         frame = thread.GetFrameAtIndex(0)
         anotherA_value = frame.FindVariable ('anotherA', True)
-        self.assertTrue(anotherA_value.IsValid())
+        self.assertTrue(anotherA_value)
         anotherA_loc = int (anotherA_value.GetValue(), 16)
         self.assertTrue (anotherA_loc == reallyA_loc)
         self.assertTrue (anotherA_value.GetTypeName().find ('B') == -1)
diff --git a/lldb/test/expression_command/test/TestExprs.py b/lldb/test/expression_command/test/TestExprs.py
index 9c056c59e21..e2ef4d9c003 100644
--- a/lldb/test/expression_command/test/TestExprs.py
+++ b/lldb/test/expression_command/test/TestExprs.py
@@ -86,12 +86,12 @@ class BasicExprCommandsTestCase(TestBase):
         exe = os.path.join(os.getcwd(), "a.out")
 
         target = self.dbg.CreateTarget(exe)
-        self.assertTrue(target.IsValid(), VALID_TARGET)
+        self.assertTrue(target, VALID_TARGET)
 
         # Create the breakpoint.
         filespec = lldb.SBFileSpec("main.cpp", False)
         breakpoint = target.BreakpointCreateByLocation(filespec, self.line)
-        self.assertTrue(breakpoint.IsValid(), VALID_BREAKPOINT)
+        self.assertTrue(breakpoint, VALID_BREAKPOINT)
 
         # Verify the breakpoint just created.
         self.expect(repr(breakpoint), BREAKPOINT_CREATED, exe=False,
@@ -103,7 +103,7 @@ class BasicExprCommandsTestCase(TestBase):
         error = lldb.SBError()
         self.process = target.Launch(self.dbg.GetListener(), ['X', 'Y', 'Z'], None, os.ctermid(), os.ctermid(), os.ctermid(), None, 0, False, error)
 
-        if not error.Success() or not self.process.IsValid():
+        if not error.Success() or not self.process:
             self.fail("SBTarget.LaunchProcess() failed")
 
         if self.process.GetState() != lldb.eStateStopped:
diff --git a/lldb/test/foundation/TestObjCMethods.py b/lldb/test/foundation/TestObjCMethods.py
index a51be3d28d3..a12370cf274 100644
--- a/lldb/test/foundation/TestObjCMethods.py
+++ b/lldb/test/foundation/TestObjCMethods.py
@@ -206,16 +206,16 @@ class FoundationTestCase(TestBase):
         exe = os.path.join(os.getcwd(), "a.out")
 
         target = self.dbg.CreateTarget(exe)
-        self.assertTrue(target.IsValid(), VALID_TARGET)
+        self.assertTrue(target, VALID_TARGET)
 
         break1 = target.BreakpointCreateByLocation(self.main_source, self.line)
-        self.assertTrue(break1.IsValid(), VALID_BREAKPOINT)
+        self.assertTrue(break1, VALID_BREAKPOINT)
 
         # Now launch the process, and do not stop at entry point.
         error = lldb.SBError()
         self.process = target.Launch (self.dbg.GetListener(), None, None, os.ctermid(), os.ctermid(), os.ctermid(), None, 0, False, error)
 
-        self.assertTrue(self.process.IsValid(), PROCESS_IS_VALID)
+        self.assertTrue(self.process, PROCESS_IS_VALID)
 
         # The stop reason of the thread should be breakpoint.
         thread = self.process.GetThreadAtIndex(0)
@@ -232,15 +232,15 @@ class FoundationTestCase(TestBase):
         self.assertTrue (line_number == self.line, "Hit the first breakpoint.")
 
         my_var = cur_frame.FindVariable("my")
-        self.assertTrue(my_var.IsValid(), "Made a variable object for my")
+        self.assertTrue(my_var, "Made a variable object for my")
 
         str_var = cur_frame.FindVariable("str")
-        self.assertTrue(str_var.IsValid(), "Made a variable object for str")
+        self.assertTrue(str_var, "Made a variable object for str")
 
         # Now make sure that the my->str == str:
 
         my_str_var = my_var.GetChildMemberWithName("str")
-        self.assertTrue(my_str_var.IsValid(), "Found a str ivar in my")
+        self.assertTrue(my_str_var, "Found a str ivar in my")
 
         str_value = int(str_var.GetValue(cur_frame), 0)
 
diff --git a/lldb/test/foundation/TestSymbolTable.py b/lldb/test/foundation/TestSymbolTable.py
index c86d90cf85e..eb866120fa5 100644
--- a/lldb/test/foundation/TestSymbolTable.py
+++ b/lldb/test/foundation/TestSymbolTable.py
@@ -42,7 +42,7 @@ class FoundationSymtabTestCase(TestBase):
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         target = self.dbg.CreateTarget(exe)
-        self.assertTrue(target.IsValid(), VALID_TARGET)
+        self.assertTrue(target, VALID_TARGET)
 
         # Launch the process, and do not stop at the entry point.
         process = target.LaunchSimple(None, None, os.getcwd())
@@ -55,13 +55,13 @@ class FoundationSymtabTestCase(TestBase):
         filespec = lldb.SBFileSpec(exe, False)
 
         module = target.FindModule(filespec)
-        self.assertTrue(module.IsValid(), VALID_MODULE)
+        self.assertTrue(module, VALID_MODULE)
 
         # Create the set of known symbols.  As we iterate through the symbol
         # table, remove the symbol from the set if it is a known symbol.
         expected_symbols = set(self.symbols_list)
         for symbol in module:
-            self.assertTrue(symbol.IsValid(), VALID_SYMBOL)
+            self.assertTrue(symbol, VALID_SYMBOL)
             #print "symbol:", symbol
             name = symbol.GetName()
             if name in expected_symbols:
diff --git a/lldb/test/hello_world/TestHelloWorld.py b/lldb/test/hello_world/TestHelloWorld.py
index fd7c7e3013a..aac6c66ec3a 100644
--- a/lldb/test/hello_world/TestHelloWorld.py
+++ b/lldb/test/hello_world/TestHelloWorld.py
@@ -67,7 +67,7 @@ class HelloWorldTestCase(TestBase):
         #self.runCmd("thread list")
 
         self.process = target.GetProcess()
-        self.assertTrue(self.process.IsValid(), PROCESS_IS_VALID)
+        self.assertTrue(self.process, PROCESS_IS_VALID)
 
         thread = self.process.GetThreadAtIndex(0)
         if thread.GetStopReason() != lldb.eStopReasonBreakpoint:
diff --git a/lldb/test/inferior-crashing/TestInferiorCrashing.py b/lldb/test/inferior-crashing/TestInferiorCrashing.py
index 66d69798386..bd61c2246c3 100644
--- a/lldb/test/inferior-crashing/TestInferiorCrashing.py
+++ b/lldb/test/inferior-crashing/TestInferiorCrashing.py
@@ -54,7 +54,7 @@ class CrashingInferiorTestCase(TestBase):
         exe = os.path.join(os.getcwd(), "a.out")
 
         target = self.dbg.CreateTarget(exe)
-        self.assertTrue(target.IsValid(), VALID_TARGET)
+        self.assertTrue(target, VALID_TARGET)
 
         # Now launch the process, and do not stop at entry point.
         # Both argv and envp are null.
diff --git a/lldb/test/macosx/universal/TestUniversal.py b/lldb/test/macosx/universal/TestUniversal.py
index d01e281e5fd..45b6c5d2574 100644
--- a/lldb/test/macosx/universal/TestUniversal.py
+++ b/lldb/test/macosx/universal/TestUniversal.py
@@ -45,7 +45,7 @@ class UniversalTestCase(TestBase):
         # Check whether we have a 64-bit process launched.
         target = self.dbg.GetSelectedTarget()
         process = target.GetProcess()
-        self.assertTrue(target.IsValid() and process.IsValid() and
+        self.assertTrue(target and process and
                         self.invoke(process, 'GetAddressByteSize') == 8,
                         "64-bit process launched")
 
@@ -73,7 +73,7 @@ class UniversalTestCase(TestBase):
         # Check whether we have a 32-bit process launched.
         target = self.dbg.GetSelectedTarget()
         process = target.GetProcess()
-        self.assertTrue(target.IsValid() and process.IsValid(),
+        self.assertTrue(target and process,
                         "32-bit process launched")
 
         pointerSize = self.invoke(process, 'GetAddressByteSize')
diff --git a/lldb/test/objc-dynamic-value/TestObjCDynamicValue.py b/lldb/test/objc-dynamic-value/TestObjCDynamicValue.py
index 56ceb49bef4..5e96b4e1ba3 100644
--- a/lldb/test/objc-dynamic-value/TestObjCDynamicValue.py
+++ b/lldb/test/objc-dynamic-value/TestObjCDynamicValue.py
@@ -39,10 +39,10 @@ class ObjCDynamicValueTestCase(TestBase):
                                                        '// Break here to see if we can step into real method.')
 
     def examine_SourceDerived_ptr (self, object):
-        self.assertTrue (object.IsValid())
+        self.assertTrue (object)
         self.assertTrue (object.GetTypeName().find ('SourceDerived') != -1)
         derivedValue = object.GetChildMemberWithName ('_derivedValue')
-        self.assertTrue (derivedValue.IsValid())
+        self.assertTrue (derivedValue)
         self.assertTrue (int (derivedValue.GetValue(), 0) == 30)
 
     def do_get_dynamic_vals(self):
@@ -52,17 +52,17 @@ class ObjCDynamicValueTestCase(TestBase):
         # Create a target from the debugger.
 
         target = self.dbg.CreateTarget (exe)
-        self.assertTrue(target.IsValid(), VALID_TARGET)
+        self.assertTrue(target, VALID_TARGET)
 
         # Set up our breakpoints:
 
         handle_SourceBase_bkpt = target.BreakpointCreateByLocation(self.source_name, self.handle_SourceBase)
-        self.assertTrue(handle_SourceBase_bkpt.IsValid() and
+        self.assertTrue(handle_SourceBase_bkpt and
                         handle_SourceBase_bkpt.GetNumLocations() == 1,
                         VALID_BREAKPOINT)
 
         main_before_setProperty_bkpt = target.BreakpointCreateByLocation(self.source_name, self.main_before_setProperty_line)
-        self.assertTrue(main_before_setProperty_bkpt.IsValid() and
+        self.assertTrue(main_before_setProperty_bkpt and
                         main_before_setProperty_bkpt.GetNumLocations() == 1,
                         VALID_BREAKPOINT)
 
@@ -82,7 +82,7 @@ class ObjCDynamicValueTestCase(TestBase):
 
         frame = thread.GetFrameAtIndex(0)
         myObserver = frame.FindVariable('myObserver', lldb.eDynamicCanRunTarget)
-        self.assertTrue (myObserver.IsValid())
+        self.assertTrue (myObserver)
         myObserver_source = myObserver.GetChildMemberWithName ('_source', lldb.eDynamicCanRunTarget)
         self.examine_SourceDerived_ptr (myObserver_source)
 
diff --git a/lldb/test/objc-stepping/TestObjCStepping.py b/lldb/test/objc-stepping/TestObjCStepping.py
index a0ea86890f6..80b6b9f04c9 100644
--- a/lldb/test/objc-stepping/TestObjCStepping.py
+++ b/lldb/test/objc-stepping/TestObjCStepping.py
@@ -43,30 +43,30 @@ class TestObjCStepping(TestBase):
         exe = os.path.join(os.getcwd(), "a.out")
 
         target = self.dbg.CreateTarget(exe)
-        self.assertTrue(target.IsValid(), VALID_TARGET)
+        self.assertTrue(target, VALID_TARGET)
 
         break1 = target.BreakpointCreateByLocation(self.main_source, self.line1)
-        self.assertTrue(break1.IsValid(), VALID_BREAKPOINT)
+        self.assertTrue(break1, VALID_BREAKPOINT)
 
         break2 = target.BreakpointCreateByLocation(self.main_source, self.line2)
-        self.assertTrue(break2.IsValid(), VALID_BREAKPOINT)
+        self.assertTrue(break2, VALID_BREAKPOINT)
 
         break3 = target.BreakpointCreateByLocation(self.main_source, self.line3)
-        self.assertTrue(break3.IsValid(), VALID_BREAKPOINT)
+        self.assertTrue(break3, VALID_BREAKPOINT)
 
         break4 = target.BreakpointCreateByLocation(self.main_source, self.line4)
-        self.assertTrue(break4.IsValid(), VALID_BREAKPOINT)
+        self.assertTrue(break4, VALID_BREAKPOINT)
 
         break5 = target.BreakpointCreateByLocation(self.main_source, self.line5)
-        self.assertTrue(break5.IsValid(), VALID_BREAKPOINT)
+        self.assertTrue(break5, VALID_BREAKPOINT)
 
         break_returnStruct_call_super = target.BreakpointCreateByLocation(self.main_source, self.source_returnsStruct_call_line)
-        self.assertTrue(break_returnStruct_call_super.IsValid(), VALID_BREAKPOINT)
+        self.assertTrue(break_returnStruct_call_super, VALID_BREAKPOINT)
 
         # Now launch the process, and do not stop at entry point.
         self.process = target.LaunchSimple (None, None, os.getcwd())
 
-        self.assertTrue(self.process.IsValid(), PROCESS_IS_VALID)
+        self.assertTrue(self.process, PROCESS_IS_VALID)
 
         # The stop reason of the thread should be breakpoint.
         thread = self.process.GetThreadAtIndex(0)
@@ -81,9 +81,9 @@ class TestObjCStepping(TestBase):
         self.assertTrue (line_number == self.line1, "Hit the first breakpoint.")
 
         mySource = thread.GetFrameAtIndex(0).FindVariable("mySource")
-        self.assertTrue(mySource.IsValid(), "Found mySource local variable.")
+        self.assertTrue(mySource, "Found mySource local variable.")
         mySource_isa = mySource.GetChildMemberWithName ("isa")
-        self.assertTrue(mySource_isa.IsValid(), "Found mySource->isa local variable.")
+        self.assertTrue(mySource_isa, "Found mySource->isa local variable.")
         mySource_isa.GetValue (thread.GetFrameAtIndex(0))
 
         # Lets delete mySource so we can check that after stepping a child variable
diff --git a/lldb/test/python_api/event/TestEvents.py b/lldb/test/python_api/event/TestEvents.py
index 74da057463c..7b21df16dd0 100644
--- a/lldb/test/python_api/event/TestEvents.py
+++ b/lldb/test/python_api/event/TestEvents.py
@@ -50,12 +50,12 @@ class EventAPITestCase(TestBase):
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)
-        self.assertTrue(target.IsValid(), VALID_TARGET)
+        self.assertTrue(target, VALID_TARGET)
 
         # Now create a breakpoint on main.c by name 'c'.
         breakpoint = target.BreakpointCreateByName('c', 'a.out')
         #print "breakpoint:", breakpoint
-        self.assertTrue(breakpoint.IsValid() and
+        self.assertTrue(breakpoint and
                         breakpoint.GetNumLocations() == 1,
                         VALID_BREAKPOINT)
 
@@ -67,15 +67,15 @@ class EventAPITestCase(TestBase):
         self.process = target.Launch (listener, None, None, os.ctermid(), os.ctermid(), os.ctermid(), None, 0, False, error)
 
         self.process = target.GetProcess()
-        self.assertTrue(self.process.IsValid(), PROCESS_IS_VALID)
+        self.assertTrue(self.process, PROCESS_IS_VALID)
 
         # Get a handle on the process's broadcaster.
         broadcaster = self.process.GetBroadcaster()
-        self.assertTrue(broadcaster.IsValid(), "Process with valid broadcaster")
+        self.assertTrue(broadcaster, "Process with valid broadcaster")
 
         # Create an empty event object.
         event = lldb.SBEvent()
-        self.assertFalse(event.IsValid(), "Event should not be valid initially")
+        self.assertFalse(event, "Event should not be valid initially")
 
         # Create MyListeningThread to wait for any kind of event.
         import threading
@@ -103,7 +103,7 @@ class EventAPITestCase(TestBase):
         # Wait until the 'MyListeningThread' terminates.
         my_thread.join()
 
-        self.assertTrue(event.IsValid(),
+        self.assertTrue(event,
                         "My listening thread successfully received an event")
 
     def do_add_listener_to_broadcaster(self):
@@ -112,12 +112,12 @@ class EventAPITestCase(TestBase):
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)
-        self.assertTrue(target.IsValid(), VALID_TARGET)
+        self.assertTrue(target, VALID_TARGET)
 
         # Now create a breakpoint on main.c by name 'c'.
         breakpoint = target.BreakpointCreateByName('c', 'a.out')
         #print "breakpoint:", breakpoint
-        self.assertTrue(breakpoint.IsValid() and
+        self.assertTrue(breakpoint and
                         breakpoint.GetNumLocations() == 1,
                         VALID_BREAKPOINT)
 
@@ -130,11 +130,11 @@ class EventAPITestCase(TestBase):
 
         # Get a handle on the process's broadcaster.
         broadcaster = self.process.GetBroadcaster()
-        self.assertTrue(broadcaster.IsValid(), "Process with valid broadcaster")
+        self.assertTrue(broadcaster, "Process with valid broadcaster")
 
         # Create an empty event object.
         event = lldb.SBEvent()
-        self.assertFalse(event.IsValid(), "Event should not be valid initially")
+        self.assertFalse(event, "Event should not be valid initially")
 
         # Create a listener object and register with the broadcaster.
         listener = lldb.SBListener("TestEvents.listener")
diff --git a/lldb/test/python_api/frame/TestFrames.py b/lldb/test/python_api/frame/TestFrames.py
index 7e920133abc..053da2453b6 100644
--- a/lldb/test/python_api/frame/TestFrames.py
+++ b/lldb/test/python_api/frame/TestFrames.py
@@ -31,12 +31,12 @@ class FrameAPITestCase(TestBase):
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)
-        self.assertTrue(target.IsValid(), VALID_TARGET)
+        self.assertTrue(target, VALID_TARGET)
 
         # Now create a breakpoint on main.c by name 'c'.
         breakpoint = target.BreakpointCreateByName('c', 'a.out')
         #print "breakpoint:", breakpoint
-        self.assertTrue(breakpoint.IsValid() and
+        self.assertTrue(breakpoint and
                         breakpoint.GetNumLocations() == 1,
                         VALID_BREAKPOINT)
 
@@ -87,10 +87,10 @@ class FrameAPITestCase(TestBase):
                 # but they should be valid.  Uses get_GPRs() from the lldbutil module.
                 gpr_reg_set = lldbutil.get_GPRs(frame)
                 pc_value = gpr_reg_set.GetChildMemberWithName("pc")
-                self.assertTrue (pc_value.IsValid(), "We should have a valid PC.")
+                self.assertTrue (pc_value, "We should have a valid PC.")
                 self.assertTrue (int(pc_value.GetValue(frame), 0) == frame.GetPC(), "PC gotten as a value should equal frame's GetPC")
                 sp_value = gpr_reg_set.GetChildMemberWithName("sp")
-                self.assertTrue (sp_value.IsValid(), "We should have a valid Stack Pointer.")
+                self.assertTrue (sp_value, "We should have a valid Stack Pointer.")
                 self.assertTrue (int(sp_value.GetValue(frame), 0) == frame.GetSP(), "SP gotten as a value should equal frame's GetSP")
 
             print >> session, "---"
diff --git a/lldb/test/python_api/function_symbol/TestDisasmAPI.py b/lldb/test/python_api/function_symbol/TestDisasmAPI.py
index 662860564e1..1ac0d206650 100644
--- a/lldb/test/python_api/function_symbol/TestDisasmAPI.py
+++ b/lldb/test/python_api/function_symbol/TestDisasmAPI.py
@@ -38,17 +38,17 @@ class DisasmAPITestCase(TestBase):
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)
-        self.assertTrue(target.IsValid(), VALID_TARGET)
+        self.assertTrue(target, VALID_TARGET)
 
         # Now create the two breakpoints inside function 'a'.
         breakpoint1 = target.BreakpointCreateByLocation('main.c', self.line1)
         breakpoint2 = target.BreakpointCreateByLocation('main.c', self.line2)
         #print "breakpoint1:", breakpoint1
         #print "breakpoint2:", breakpoint2
-        self.assertTrue(breakpoint1.IsValid() and
+        self.assertTrue(breakpoint1 and
                         breakpoint1.GetNumLocations() == 1,
                         VALID_BREAKPOINT)
-        self.assertTrue(breakpoint2.IsValid() and
+        self.assertTrue(breakpoint2 and
                         breakpoint2.GetNumLocations() == 1,
                         VALID_BREAKPOINT)
 
@@ -56,7 +56,7 @@ class DisasmAPITestCase(TestBase):
         self.process = target.LaunchSimple(None, None, os.getcwd())
 
         self.process = target.GetProcess()
-        self.assertTrue(self.process.IsValid(), PROCESS_IS_VALID)
+        self.assertTrue(self.process, PROCESS_IS_VALID)
 
         # Frame #0 should be on self.line1.
         self.assertTrue(self.process.GetState() == lldb.eStateStopped)
@@ -72,7 +72,7 @@ class DisasmAPITestCase(TestBase):
         # Now call SBTarget.ResolveSymbolContextForAddress() with address1.
         context1 = target.ResolveSymbolContextForAddress(address1, lldb.eSymbolContextEverything)
 
-        self.assertTrue(context1.IsValid())
+        self.assertTrue(context1)
         if self.TraceOn():
             print "context1:", context1
 
@@ -88,7 +88,7 @@ class DisasmAPITestCase(TestBase):
         # Verify that the symbol and the function has the same address range per function 'a'.
         symbol = context1.GetSymbol()
         function = frame0.GetFunction()
-        self.assertTrue(symbol.IsValid() and function.IsValid())
+        self.assertTrue(symbol and function)
 
         disasm_output = lldbutil.disassemble(target, symbol)
         if self.TraceOn():
diff --git a/lldb/test/python_api/function_symbol/TestSymbolAPI.py b/lldb/test/python_api/function_symbol/TestSymbolAPI.py
index df3759d436c..913543781bf 100644
--- a/lldb/test/python_api/function_symbol/TestSymbolAPI.py
+++ b/lldb/test/python_api/function_symbol/TestSymbolAPI.py
@@ -38,17 +38,17 @@ class SymbolAPITestCase(TestBase):
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)
-        self.assertTrue(target.IsValid(), VALID_TARGET)
+        self.assertTrue(target, VALID_TARGET)
 
         # Now create the two breakpoints inside function 'a'.
         breakpoint1 = target.BreakpointCreateByLocation('main.c', self.line1)
         breakpoint2 = target.BreakpointCreateByLocation('main.c', self.line2)
         #print "breakpoint1:", breakpoint1
         #print "breakpoint2:", breakpoint2
-        self.assertTrue(breakpoint1.IsValid() and
+        self.assertTrue(breakpoint1 and
                         breakpoint1.GetNumLocations() == 1,
                         VALID_BREAKPOINT)
-        self.assertTrue(breakpoint2.IsValid() and
+        self.assertTrue(breakpoint2 and
                         breakpoint2.GetNumLocations() == 1,
                         VALID_BREAKPOINT)
 
@@ -56,7 +56,7 @@ class SymbolAPITestCase(TestBase):
         self.process = target.LaunchSimple(None, None, os.getcwd())
 
         self.process = target.GetProcess()
-        self.assertTrue(self.process.IsValid(), PROCESS_IS_VALID)
+        self.assertTrue(self.process, PROCESS_IS_VALID)
 
         # Frame #0 should be on self.line1.
         self.assertTrue(self.process.GetState() == lldb.eStateStopped)
diff --git a/lldb/test/python_api/interpreter/TestCommandInterpreterAPI.py b/lldb/test/python_api/interpreter/TestCommandInterpreterAPI.py
index c448181f988..8620824005c 100644
--- a/lldb/test/python_api/interpreter/TestCommandInterpreterAPI.py
+++ b/lldb/test/python_api/interpreter/TestCommandInterpreterAPI.py
@@ -35,11 +35,11 @@ class CommandInterpreterAPICase(TestBase):
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)
-        self.assertTrue(target.IsValid(), VALID_TARGET)
+        self.assertTrue(target, VALID_TARGET)
 
         # Retrieve the associated command interpreter from our debugger.
         ci = self.dbg.GetCommandInterpreter()
-        self.assertTrue(ci.IsValid(), VALID_COMMAND_INTERPRETER)
+        self.assertTrue(ci, VALID_COMMAND_INTERPRETER)
 
         # Exercise some APIs....
 
@@ -61,7 +61,7 @@ class CommandInterpreterAPICase(TestBase):
 
         # Assigning to self.process so it gets cleaned up during test tear down.
         self.process = ci.GetProcess()
-        self.assertTrue(self.process.IsValid())
+        self.assertTrue(self.process)
 
         import lldbutil
         if self.process.GetState() != lldb.eStateStopped:
diff --git a/lldb/test/python_api/process/TestProcessAPI.py b/lldb/test/python_api/process/TestProcessAPI.py
index a2f432afe84..4e014cc3b3e 100644
--- a/lldb/test/python_api/process/TestProcessAPI.py
+++ b/lldb/test/python_api/process/TestProcessAPI.py
@@ -69,10 +69,10 @@ class ProcessAPITestCase(TestBase):
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         target = self.dbg.CreateTarget(exe)
-        self.assertTrue(target.IsValid(), VALID_TARGET)
+        self.assertTrue(target, VALID_TARGET)
 
         breakpoint = target.BreakpointCreateByLocation("main.cpp", self.line)
-        self.assertTrue(breakpoint.IsValid(), VALID_BREAKPOINT)
+        self.assertTrue(breakpoint, VALID_BREAKPOINT)
 
         # Launch the process, and do not stop at the entry point.
         error = lldb.SBError()
@@ -111,10 +111,10 @@ class ProcessAPITestCase(TestBase):
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         target = self.dbg.CreateTarget(exe)
-        self.assertTrue(target.IsValid(), VALID_TARGET)
+        self.assertTrue(target, VALID_TARGET)
 
         breakpoint = target.BreakpointCreateByLocation("main.cpp", self.line)
-        self.assertTrue(breakpoint.IsValid(), VALID_BREAKPOINT)
+        self.assertTrue(breakpoint, VALID_BREAKPOINT)
 
         # Launch the process, and do not stop at the entry point.
         error = lldb.SBError()
@@ -162,10 +162,10 @@ class ProcessAPITestCase(TestBase):
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         target = self.dbg.CreateTarget(exe)
-        self.assertTrue(target.IsValid(), VALID_TARGET)
+        self.assertTrue(target, VALID_TARGET)
 
         breakpoint = target.BreakpointCreateByLocation("main.cpp", self.line)
-        self.assertTrue(breakpoint.IsValid(), VALID_BREAKPOINT)
+        self.assertTrue(breakpoint, VALID_BREAKPOINT)
 
         # Launch the process, and do not stop at the entry point.
         error = lldb.SBError()
@@ -251,7 +251,7 @@ class ProcessAPITestCase(TestBase):
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         target = self.dbg.CreateTarget(exe)
-        self.assertTrue(target.IsValid(), VALID_TARGET)
+        self.assertTrue(target, VALID_TARGET)
 
         # Launch the process, and do not stop at the entry point.
         error = lldb.SBError()
diff --git a/lldb/test/python_api/symbol-context/TestSymbolContext.py b/lldb/test/python_api/symbol-context/TestSymbolContext.py
index 6213490aea9..88386bcd45f 100644
--- a/lldb/test/python_api/symbol-context/TestSymbolContext.py
+++ b/lldb/test/python_api/symbol-context/TestSymbolContext.py
@@ -37,12 +37,12 @@ class SymbolContextAPITestCase(TestBase):
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)
-        self.assertTrue(target.IsValid(), VALID_TARGET)
+        self.assertTrue(target, VALID_TARGET)
 
         # Now create a breakpoint on main.c by name 'c'.
         breakpoint = target.BreakpointCreateByName('c', 'a.out')
         #print "breakpoint:", breakpoint
-        self.assertTrue(breakpoint.IsValid() and
+        self.assertTrue(breakpoint and
                         breakpoint.GetNumLocations() == 1,
                         VALID_BREAKPOINT)
 
@@ -50,7 +50,7 @@ class SymbolContextAPITestCase(TestBase):
         self.process = target.LaunchSimple(None, None, os.getcwd())
 
         self.process = target.GetProcess()
-        self.assertTrue(self.process.IsValid(), PROCESS_IS_VALID)
+        self.assertTrue(self.process, PROCESS_IS_VALID)
 
         # Frame #0 should be on self.line.
         from lldbutil import get_stopped_thread
@@ -61,7 +61,7 @@ class SymbolContextAPITestCase(TestBase):
 
         # Now get the SBSymbolContext from this frame.  We want everything. :-)
         context = frame0.GetSymbolContext(lldb.eSymbolContextEverything)
-        self.assertTrue(context.IsValid())
+        self.assertTrue(context)
 
         # Get the description of this module.
         module = context.GetModule()
@@ -74,11 +74,11 @@ class SymbolContextAPITestCase(TestBase):
             substrs = [os.path.join(self.mydir, 'main.c')])
 
         function = context.GetFunction()
-        self.assertTrue(function.IsValid())
+        self.assertTrue(function)
         #print "function:", function
 
         block = context.GetBlock()
-        self.assertTrue(block.IsValid())
+        self.assertTrue(block)
         #print "block:", block
 
         lineEntry = context.GetLineEntry()
diff --git a/lldb/test/python_api/target/TestTargetAPI.py b/lldb/test/python_api/target/TestTargetAPI.py
index e72d2e70daa..0de456396c7 100644
--- a/lldb/test/python_api/target/TestTargetAPI.py
+++ b/lldb/test/python_api/target/TestTargetAPI.py
@@ -64,7 +64,7 @@ class TargetAPITestCase(TestBase):
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)
-        self.assertTrue(target.IsValid(), VALID_TARGET)
+        self.assertTrue(target, VALID_TARGET)
 
         from lldbutil import get_description
 
@@ -91,7 +91,7 @@ class TargetAPITestCase(TestBase):
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)
-        self.assertTrue(target.IsValid(), VALID_TARGET)
+        self.assertTrue(target, VALID_TARGET)
 
         # Add an extra twist of stopping the inferior in a breakpoint, and then continue till it's done.
         # We should still see the entire stdout redirected once the process is finished.
@@ -131,17 +131,17 @@ class TargetAPITestCase(TestBase):
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)
-        self.assertTrue(target.IsValid(), VALID_TARGET)
+        self.assertTrue(target, VALID_TARGET)
 
         # Now create the two breakpoints inside function 'a'.
         breakpoint1 = target.BreakpointCreateByLocation('main.c', self.line1)
         breakpoint2 = target.BreakpointCreateByLocation('main.c', self.line2)
         #print "breakpoint1:", breakpoint1
         #print "breakpoint2:", breakpoint2
-        self.assertTrue(breakpoint1.IsValid() and
+        self.assertTrue(breakpoint1 and
                         breakpoint1.GetNumLocations() == 1,
                         VALID_BREAKPOINT)
-        self.assertTrue(breakpoint2.IsValid() and
+        self.assertTrue(breakpoint2 and
                         breakpoint2.GetNumLocations() == 1,
                         VALID_BREAKPOINT)
 
@@ -149,7 +149,7 @@ class TargetAPITestCase(TestBase):
         self.process = target.LaunchSimple(None, None, os.getcwd())
 
         self.process = target.GetProcess()
-        self.assertTrue(self.process.IsValid(), PROCESS_IS_VALID)
+        self.assertTrue(self.process, PROCESS_IS_VALID)
 
         # Frame #0 should be on self.line1.
         self.assertTrue(self.process.GetState() == lldb.eStateStopped)
@@ -181,14 +181,14 @@ class TargetAPITestCase(TestBase):
         context1 = target.ResolveSymbolContextForAddress(address1, lldb.eSymbolContextEverything)
         context2 = target.ResolveSymbolContextForAddress(address2, lldb.eSymbolContextEverything)
 
-        self.assertTrue(context1.IsValid() and context2.IsValid())
+        self.assertTrue(context1 and context2)
         #print "context1:", context1
         #print "context2:", context2
 
         # Verify that the context point to the same function 'a'.
         symbol1 = context1.GetSymbol()
         symbol2 = context2.GetSymbol()
-        self.assertTrue(symbol1.IsValid() and symbol2.IsValid())
+        self.assertTrue(symbol1 and symbol2)
         #print "symbol1:", symbol1
         #print "symbol2:", symbol2
 
diff --git a/lldb/test/python_api/thread/TestThreadAPI.py b/lldb/test/python_api/thread/TestThreadAPI.py
index 50bab95c787..aee34f04ea4 100644
--- a/lldb/test/python_api/thread/TestThreadAPI.py
+++ b/lldb/test/python_api/thread/TestThreadAPI.py
@@ -109,10 +109,10 @@ class ThreadAPITestCase(TestBase):
         exe = os.path.join(os.getcwd(), "a.out")
 
         target = self.dbg.CreateTarget(exe)
-        self.assertTrue(target.IsValid(), VALID_TARGET)
+        self.assertTrue(target, VALID_TARGET)
 
         breakpoint = target.BreakpointCreateByLocation("main.cpp", self.line)
-        self.assertTrue(breakpoint.IsValid(), VALID_BREAKPOINT)
+        self.assertTrue(breakpoint, VALID_BREAKPOINT)
         self.runCmd("breakpoint list")
 
         # Launch the process, and do not stop at the entry point.
@@ -131,10 +131,10 @@ class ThreadAPITestCase(TestBase):
         exe = os.path.join(os.getcwd(), "a.out")
 
         target = self.dbg.CreateTarget(exe)
-        self.assertTrue(target.IsValid(), VALID_TARGET)
+        self.assertTrue(target, VALID_TARGET)
 
         breakpoint = target.BreakpointCreateByLocation("main.cpp", self.line)
-        self.assertTrue(breakpoint.IsValid(), VALID_BREAKPOINT)
+        self.assertTrue(breakpoint, VALID_BREAKPOINT)
         #self.runCmd("breakpoint list")
 
         # Launch the process, and do not stop at the entry point.
@@ -156,10 +156,10 @@ class ThreadAPITestCase(TestBase):
         exe = os.path.join(os.getcwd(), "a.out")
 
         target = self.dbg.CreateTarget(exe)
-        self.assertTrue(target.IsValid(), VALID_TARGET)
+        self.assertTrue(target, VALID_TARGET)
 
         breakpoint = target.BreakpointCreateByName('malloc')
-        self.assertTrue(breakpoint.IsValid(), VALID_BREAKPOINT)
+        self.assertTrue(breakpoint, VALID_BREAKPOINT)
         self.runCmd("breakpoint list")
 
         # Launch the process, and do not stop at the entry point.
@@ -189,16 +189,16 @@ class ThreadAPITestCase(TestBase):
         exe = os.path.join(os.getcwd(), "a.out")
 
         target = self.dbg.CreateTarget(exe)
-        self.assertTrue(target.IsValid(), VALID_TARGET)
+        self.assertTrue(target, VALID_TARGET)
 
         breakpoint = target.BreakpointCreateByLocation('main2.cpp', self.line2)
-        self.assertTrue(breakpoint.IsValid(), VALID_BREAKPOINT)
+        self.assertTrue(breakpoint, VALID_BREAKPOINT)
         self.runCmd("breakpoint list")
 
         # Launch the process, and do not stop at the entry point.
         self.process = target.LaunchSimple(None, None, os.getcwd())
 
-        self.assertTrue(self.process.IsValid(), PROCESS_IS_VALID)
+        self.assertTrue(self.process, PROCESS_IS_VALID)
 
         # Frame #0 should be on self.line2.
         self.assertTrue(self.process.GetState() == lldb.eStateStopped)
@@ -230,16 +230,16 @@ class ThreadAPITestCase(TestBase):
         exe = os.path.join(os.getcwd(), "a.out")
 
         target = self.dbg.CreateTarget(exe)
-        self.assertTrue(target.IsValid(), VALID_TARGET)
+        self.assertTrue(target, VALID_TARGET)
 
         breakpoint = target.BreakpointCreateByLocation('main2.cpp', self.line2)
-        self.assertTrue(breakpoint.IsValid(), VALID_BREAKPOINT)
+        self.assertTrue(breakpoint, VALID_BREAKPOINT)
         self.runCmd("breakpoint list")
 
         # Launch the process, and do not stop at the entry point.
         self.process = target.LaunchSimple(None, None, os.getcwd())
 
-        self.assertTrue(self.process.IsValid(), PROCESS_IS_VALID)
+        self.assertTrue(self.process, PROCESS_IS_VALID)
 
         # Frame #0 should be on self.line2.
         self.assertTrue(self.process.GetState() == lldb.eStateStopped)
diff --git a/lldb/test/source-manager/TestSourceManager.py b/lldb/test/source-manager/TestSourceManager.py
index c32a8ec92f2..4d20c95a23a 100644
--- a/lldb/test/source-manager/TestSourceManager.py
+++ b/lldb/test/source-manager/TestSourceManager.py
@@ -40,7 +40,7 @@ class SourceManagerTestCase(TestBase):
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         target = self.dbg.CreateTarget(exe)
-        self.assertTrue(target.IsValid(), VALID_TARGET)
+        self.assertTrue(target, VALID_TARGET)
 
         # Launch the process, and do not stop at the entry point.
         error = lldb.SBError()