vendor/lldb/lldb-trunk-r290819

1 files changed, 285 insertions, 101 deletions

diff --git a/packages/Python/lldbsuite/test/python_api/sbdata/TestSBData.py b/packages/Python/lldbsuite/test/python_api/sbdata/TestSBData.py
index d8e9515973f7..e853d6567e73 100644
--- a/packages/Python/lldbsuite/test/python_api/sbdata/TestSBData.py
+++ b/packages/Python/lldbsuite/test/python_api/sbdata/TestSBData.py
@@ -3,7 +3,6 @@
 from __future__ import print_function
 
 
-
 from math import fabs
 import os
 import lldb
@@ -11,6 +10,7 @@ from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
+
 class SBDataAPICase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
@@ -26,21 +26,23 @@ class SBDataAPICase(TestBase):
         """Test the SBData APIs."""
         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)
-        
+
+        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'])
-        
+                    substrs=['stopped',
+                             'stop reason = breakpoint'])
+
         target = self.dbg.GetSelectedTarget()
-        
+
         process = target.GetProcess()
 
-        thread = lldbutil.get_stopped_thread(process, lldb.eStopReasonBreakpoint)
+        thread = lldbutil.get_stopped_thread(
+            process, lldb.eStopReasonBreakpoint)
         self.assertIsNotNone(thread)
 
         frame = thread.GetSelectedFrame()
@@ -67,8 +69,17 @@ class SBDataAPICase(TestBase):
         high = data.GetSignedInt16(error, offset)
         self.assertTrue(error.Success())
         offset += 2
-        self.assertTrue ((low == 9 and high == 0) or (low == 0 and high == 9), 'foo[0].b == 9')
-        self.assertTrue( fabs(data.GetFloat(error, offset) - 3.14) < 1, 'foo[0].c == 3.14')
+        self.assertTrue(
+            (low == 9 and high == 0) or (
+                low == 0 and high == 9),
+            'foo[0].b == 9')
+        self.assertTrue(
+            fabs(
+                data.GetFloat(
+                    error,
+                    offset) -
+                3.14) < 1,
+            'foo[0].c == 3.14')
         self.assertTrue(error.Success())
         offset += 4
         self.assert_data(data.GetUnsignedInt32, offset, 8)
@@ -90,18 +101,22 @@ class SBDataAPICase(TestBase):
         offset += 4
         self.assert_data(data.GetSignedInt32, offset, 7)
         offset += 8
-        self.assertTrue(data.GetUnsignedInt32(error, offset) == 0, 'do not read beyond end')
+        self.assertTrue(
+            data.GetUnsignedInt32(
+                error,
+                offset) == 0,
+            'do not read beyond end')
         self.assertTrue(not error.Success())
-        error.Clear() # clear the error for the next test
+        error.Clear()  # clear the error for the next test
 
         star_foobar = foobar.Dereference()
         self.assertTrue(star_foobar.IsValid())
-        
+
         data = star_foobar.GetData()
 
         if self.TraceOn():
             print(data)
-        
+
         offset = 0
         self.assert_data(data.GetUnsignedInt32, offset, 1)
         offset += 4
@@ -113,13 +128,16 @@ class SBDataAPICase(TestBase):
         # http://llvm.org/bugs/show_bug.cgi?id=11579
         # lldb::SBValue::CreateValueFromAddress does not verify SBType::GetPointerType succeeds
         # This should not crash LLDB.
-        nothing = foobar.CreateValueFromAddress("nothing", foobar_addr, star_foobar.GetType().GetBasicType(lldb.eBasicTypeInvalid))
+        nothing = foobar.CreateValueFromAddress(
+            "nothing", foobar_addr, star_foobar.GetType().GetBasicType(
+                lldb.eBasicTypeInvalid))
 
-        new_foobar = foobar.CreateValueFromAddress("f00", foobar_addr, star_foobar.GetType())
+        new_foobar = foobar.CreateValueFromAddress(
+            "f00", foobar_addr, star_foobar.GetType())
         self.assertTrue(new_foobar.IsValid())
         if self.TraceOn():
             print(new_foobar)
-        
+
         data = new_foobar.GetData()
 
         if self.TraceOn():
@@ -127,7 +145,8 @@ class SBDataAPICase(TestBase):
 
         self.assertTrue(data.uint32[0] == 8, 'then foo[1].a == 8')
         self.assertTrue(data.uint32[1] == 7, 'then foo[1].b == 7')
-        self.assertTrue(fabs(data.float[2] - 3.14) < 1, 'foo[1].c == 3.14') # exploiting that sizeof(uint32) == sizeof(float)
+        # exploiting that sizeof(uint32) == sizeof(float)
+        self.assertTrue(fabs(data.float[2] - 3.14) < 1, 'foo[1].c == 3.14')
 
         self.runCmd("n")
 
@@ -136,7 +155,13 @@ class SBDataAPICase(TestBase):
         offset += 4
         self.assert_data(data.GetUnsignedInt32, offset, 7)
         offset += 4
-        self.assertTrue(fabs(data.GetFloat(error, offset) - 3.14) < 1, 'foo[1].c == 3.14')
+        self.assertTrue(
+            fabs(
+                data.GetFloat(
+                    error,
+                    offset) -
+                3.14) < 1,
+            'foo[1].c == 3.14')
         self.assertTrue(error.Success())
 
         data = new_foobar.GetData()
@@ -149,7 +174,13 @@ class SBDataAPICase(TestBase):
         offset += 4
         self.assert_data(data.GetUnsignedInt32, offset, 7)
         offset += 4
-        self.assertTrue(fabs(data.GetFloat(error, offset) - 6.28) < 1, 'foo[1].c == 6.28')
+        self.assertTrue(
+            fabs(
+                data.GetFloat(
+                    error,
+                    offset) -
+                6.28) < 1,
+            'foo[1].c == 6.28')
         self.assertTrue(error.Success())
 
         self.runCmd("n")
@@ -169,35 +200,61 @@ class SBDataAPICase(TestBase):
         offset += 4
         self.assert_data(data.GetUnsignedInt32, offset, 2)
         offset += 4
-        self.assertTrue(fabs(data.GetFloat(error, offset) - 3) < 1, 'barfoo[0].c == 3')
+        self.assertTrue(
+            fabs(
+                data.GetFloat(
+                    error,
+                    offset) -
+                3) < 1,
+            'barfoo[0].c == 3')
         self.assertTrue(error.Success())
         offset += 4
         self.assert_data(data.GetUnsignedInt32, offset, 4)
         offset += 4
         self.assert_data(data.GetUnsignedInt32, offset, 5)
         offset += 4
-        self.assertTrue(fabs(data.GetFloat(error, offset) - 6) < 1, 'barfoo[1].c == 6')
+        self.assertTrue(
+            fabs(
+                data.GetFloat(
+                    error,
+                    offset) -
+                6) < 1,
+            'barfoo[1].c == 6')
         self.assertTrue(error.Success())
 
-        new_object = barfoo.CreateValueFromData("new_object",data,barfoo.GetType().GetBasicType(lldb.eBasicTypeInt))
+        new_object = barfoo.CreateValueFromData(
+            "new_object", data, barfoo.GetType().GetBasicType(
+                lldb.eBasicTypeInt))
 
         if self.TraceOn():
             print(new_object)
-        
+
         self.assertTrue(new_object.GetValue() == "1", 'new_object == 1')
 
         if data.GetByteOrder() == lldb.eByteOrderBig:
-            data.SetData(error, '\0\0\0A', data.GetByteOrder(), data.GetAddressByteSize())
+            data.SetData(
+                error,
+                '\0\0\0A',
+                data.GetByteOrder(),
+                data.GetAddressByteSize())
         else:
-            data.SetData(error, 'A\0\0\0', data.GetByteOrder(), data.GetAddressByteSize())
+            data.SetData(
+                error,
+                'A\0\0\0',
+                data.GetByteOrder(),
+                data.GetAddressByteSize())
         self.assertTrue(error.Success())
-        
+
         data2 = lldb.SBData()
-        data2.SetData(error, 'BCD', data.GetByteOrder(), data.GetAddressByteSize())
+        data2.SetData(
+            error,
+            'BCD',
+            data.GetByteOrder(),
+            data.GetAddressByteSize())
         self.assertTrue(error.Success())
 
         data.Append(data2)
-        
+
         if self.TraceOn():
             print(data)
 
@@ -213,74 +270,160 @@ class SBDataAPICase(TestBase):
         offset += 1
 
         # check the new API calls introduced per LLVM llvm.org/prenhancement request
-        # 11619 (Allow creating SBData values from arrays or primitives in Python)
+        # 11619 (Allow creating SBData values from arrays or primitives in
+        # Python)
 
         hello_str = "hello!"
-        data2 = lldb.SBData.CreateDataFromCString(process.GetByteOrder(),process.GetAddressByteSize(),hello_str)
+        data2 = lldb.SBData.CreateDataFromCString(
+            process.GetByteOrder(), process.GetAddressByteSize(), hello_str)
         self.assertTrue(len(data2.uint8) == len(hello_str))
         self.assertTrue(data2.uint8[0] == 104, 'h == 104')
         self.assertTrue(data2.uint8[1] == 101, 'e == 101')
         self.assertTrue(data2.uint8[2] == 108, 'l == 108')
-        self.assert_data(data2.GetUnsignedInt8, 3, 108) # l
+        self.assert_data(data2.GetUnsignedInt8, 3, 108)  # l
         self.assertTrue(data2.uint8[4] == 111, 'o == 111')
-        self.assert_data(data2.GetUnsignedInt8, 5, 33) # !
+        self.assert_data(data2.GetUnsignedInt8, 5, 33)  # !
 
-        uint_lists = [ [1,2,3,4,5], [int(i) for i in [1, 2, 3, 4, 5]] ]
-        int_lists = [ [2, -2], [int(i) for i in [2, -2]] ]
+        uint_lists = [[1, 2, 3, 4, 5], [int(i) for i in [1, 2, 3, 4, 5]]]
+        int_lists = [[2, -2], [int(i) for i in [2, -2]]]
 
         for l in uint_lists:
-            data2 = lldb.SBData.CreateDataFromUInt64Array(process.GetByteOrder(), process.GetAddressByteSize(), l)
+            data2 = lldb.SBData.CreateDataFromUInt64Array(
+                process.GetByteOrder(), process.GetAddressByteSize(), l)
             self.assert_data(data2.GetUnsignedInt64, 0, 1)
             self.assert_data(data2.GetUnsignedInt64, 8, 2)
             self.assert_data(data2.GetUnsignedInt64, 16, 3)
             self.assert_data(data2.GetUnsignedInt64, 24, 4)
             self.assert_data(data2.GetUnsignedInt64, 32, 5)
-        
-            self.assertTrue(data2.uint64s == [1,2,3,4,5], 'read_data_helper failure: data2 == [1,2,3,4,5]')
+
+            self.assertTrue(
+                data2.uint64s == [
+                    1,
+                    2,
+                    3,
+                    4,
+                    5],
+                'read_data_helper failure: data2 == [1,2,3,4,5]')
 
         for l in int_lists:
-            data2 = lldb.SBData.CreateDataFromSInt32Array(process.GetByteOrder(), process.GetAddressByteSize(), l)
-            self.assertTrue(data2.sint32[0:2] == [2,-2], 'signed32 data2 = [2,-2]')
-        
-        data2.Append(lldb.SBData.CreateDataFromSInt64Array(process.GetByteOrder(), process.GetAddressByteSize(), int_lists[0]))
+            data2 = lldb.SBData.CreateDataFromSInt32Array(
+                process.GetByteOrder(), process.GetAddressByteSize(), l)
+            self.assertTrue(
+                data2.sint32[
+                    0:2] == [
+                    2, -2], 'signed32 data2 = [2,-2]')
+
+        data2.Append(
+            lldb.SBData.CreateDataFromSInt64Array(
+                process.GetByteOrder(),
+                process.GetAddressByteSize(),
+                int_lists[0]))
         self.assert_data(data2.GetSignedInt32, 0, 2)
         self.assert_data(data2.GetSignedInt32, 4, -2)
-        self.assertTrue(data2.sint64[1:3] == [2,-2], 'signed64 data2 = [2,-2]')
+        self.assertTrue(
+            data2.sint64[
+                1:3] == [
+                2, -2], 'signed64 data2 = [2,-2]')
 
         for l in int_lists:
-            data2 = lldb.SBData.CreateDataFromSInt64Array(process.GetByteOrder(), process.GetAddressByteSize(), l)
+            data2 = lldb.SBData.CreateDataFromSInt64Array(
+                process.GetByteOrder(), process.GetAddressByteSize(), l)
             self.assert_data(data2.GetSignedInt64, 0, 2)
             self.assert_data(data2.GetSignedInt64, 8, -2)
-            self.assertTrue(data2.sint64[0:2] == [2,-2], 'signed64 data2 = [2,-2]')
+            self.assertTrue(
+                data2.sint64[
+                    0:2] == [
+                    2, -2], 'signed64 data2 = [2,-2]')
 
         for l in uint_lists:
-            data2 = lldb.SBData.CreateDataFromUInt32Array(process.GetByteOrder(), process.GetAddressByteSize(), l)
-            self.assert_data(data2.GetUnsignedInt32,0, 1)
-            self.assert_data(data2.GetUnsignedInt32,4, 2)
-            self.assert_data(data2.GetUnsignedInt32,8, 3)
-            self.assert_data(data2.GetUnsignedInt32,12, 4)
-            self.assert_data(data2.GetUnsignedInt32,16, 5)
+            data2 = lldb.SBData.CreateDataFromUInt32Array(
+                process.GetByteOrder(), process.GetAddressByteSize(), l)
+            self.assert_data(data2.GetUnsignedInt32, 0, 1)
+            self.assert_data(data2.GetUnsignedInt32, 4, 2)
+            self.assert_data(data2.GetUnsignedInt32, 8, 3)
+            self.assert_data(data2.GetUnsignedInt32, 12, 4)
+            self.assert_data(data2.GetUnsignedInt32, 16, 5)
 
         bool_list = [True, True, False, False, True, False]
 
-        data2 = lldb.SBData.CreateDataFromSInt32Array(process.GetByteOrder(), process.GetAddressByteSize(), bool_list)
-        self.assertTrue(data2.sint32[0:6] == [1, 1, 0, 0, 1, 0], 'signed32 data2 = [1, 1, 0, 0, 1, 0]')
-
-        data2 = lldb.SBData.CreateDataFromUInt32Array(process.GetByteOrder(), process.GetAddressByteSize(), bool_list)
-        self.assertTrue(data2.uint32[0:6] == [1, 1, 0, 0, 1, 0], 'unsigned32 data2 = [1, 1, 0, 0, 1, 0]')
-
-        data2 = lldb.SBData.CreateDataFromSInt64Array(process.GetByteOrder(), process.GetAddressByteSize(), bool_list)
-        self.assertTrue(data2.sint64[0:6] == [1, 1, 0, 0, 1, 0], 'signed64 data2 = [1, 1, 0, 0, 1, 0]')
-
-        data2 = lldb.SBData.CreateDataFromUInt64Array(process.GetByteOrder(), process.GetAddressByteSize(), bool_list)
-        self.assertTrue(data2.uint64[0:6] == [1, 1, 0, 0, 1, 0], 'signed64 data2 = [1, 1, 0, 0, 1, 0]')
-        
-        data2 = lldb.SBData.CreateDataFromDoubleArray(process.GetByteOrder(),process.GetAddressByteSize(),[3.14,6.28,2.71])
-        self.assertTrue( fabs(data2.GetDouble(error,0) - 3.14) < 0.5, 'double data2[0] = 3.14')
+        data2 = lldb.SBData.CreateDataFromSInt32Array(
+            process.GetByteOrder(), process.GetAddressByteSize(), bool_list)
+        self.assertTrue(
+            data2.sint32[
+                0:6] == [
+                1,
+                1,
+                0,
+                0,
+                1,
+                0],
+            'signed32 data2 = [1, 1, 0, 0, 1, 0]')
+
+        data2 = lldb.SBData.CreateDataFromUInt32Array(
+            process.GetByteOrder(), process.GetAddressByteSize(), bool_list)
+        self.assertTrue(
+            data2.uint32[
+                0:6] == [
+                1,
+                1,
+                0,
+                0,
+                1,
+                0],
+            'unsigned32 data2 = [1, 1, 0, 0, 1, 0]')
+
+        data2 = lldb.SBData.CreateDataFromSInt64Array(
+            process.GetByteOrder(), process.GetAddressByteSize(), bool_list)
+        self.assertTrue(
+            data2.sint64[
+                0:6] == [
+                1,
+                1,
+                0,
+                0,
+                1,
+                0],
+            'signed64 data2 = [1, 1, 0, 0, 1, 0]')
+
+        data2 = lldb.SBData.CreateDataFromUInt64Array(
+            process.GetByteOrder(), process.GetAddressByteSize(), bool_list)
+        self.assertTrue(
+            data2.uint64[
+                0:6] == [
+                1,
+                1,
+                0,
+                0,
+                1,
+                0],
+            'signed64 data2 = [1, 1, 0, 0, 1, 0]')
+
+        data2 = lldb.SBData.CreateDataFromDoubleArray(
+            process.GetByteOrder(), process.GetAddressByteSize(), [
+                3.14, 6.28, 2.71])
+        self.assertTrue(
+            fabs(
+                data2.GetDouble(
+                    error,
+                    0) -
+                3.14) < 0.5,
+            'double data2[0] = 3.14')
         self.assertTrue(error.Success())
-        self.assertTrue( fabs(data2.GetDouble(error,8) - 6.28) < 0.5, 'double data2[1] = 6.28')
+        self.assertTrue(
+            fabs(
+                data2.GetDouble(
+                    error,
+                    8) -
+                6.28) < 0.5,
+            'double data2[1] = 6.28')
         self.assertTrue(error.Success())
-        self.assertTrue( fabs(data2.GetDouble(error,16) - 2.71) < 0.5, 'double data2[2] = 2.71')
+        self.assertTrue(
+            fabs(
+                data2.GetDouble(
+                    error,
+                    16) -
+                2.71) < 0.5,
+            'double data2[2] = 2.71')
         self.assertTrue(error.Success())
 
         data2 = lldb.SBData()
@@ -294,50 +437,90 @@ class SBDataAPICase(TestBase):
         self.assert_data(data2.GetUnsignedInt8, 4, 111)
         self.assert_data(data2.GetUnsignedInt8, 5, 33)
 
-        data2.SetDataFromUInt64Array([1,2,3,4,5])
+        data2.SetDataFromUInt64Array([1, 2, 3, 4, 5])
         self.assert_data(data2.GetUnsignedInt64, 0, 1)
-        self.assert_data(data2.GetUnsignedInt64, 8,  2)
+        self.assert_data(data2.GetUnsignedInt64, 8, 2)
         self.assert_data(data2.GetUnsignedInt64, 16, 3)
         self.assert_data(data2.GetUnsignedInt64, 24, 4)
         self.assert_data(data2.GetUnsignedInt64, 32, 5)
 
-        self.assertTrue(data2.uint64[0] == 1, 'read_data_helper failure: set data2[0] = 1')
-        self.assertTrue(data2.uint64[1] == 2, 'read_data_helper failure: set data2[1] = 2')
-        self.assertTrue(data2.uint64[2] == 3, 'read_data_helper failure: set data2[2] = 3')
-        self.assertTrue(data2.uint64[3] == 4, 'read_data_helper failure: set data2[3] = 4')
-        self.assertTrue(data2.uint64[4] == 5, 'read_data_helper failure: set data2[4] = 5')
-
-        self.assertTrue(data2.uint64[0:2] == [1,2], 'read_data_helper failure: set data2[0:2] = [1,2]')
+        self.assertTrue(
+            data2.uint64[0] == 1,
+            'read_data_helper failure: set data2[0] = 1')
+        self.assertTrue(
+            data2.uint64[1] == 2,
+            'read_data_helper failure: set data2[1] = 2')
+        self.assertTrue(
+            data2.uint64[2] == 3,
+            'read_data_helper failure: set data2[2] = 3')
+        self.assertTrue(
+            data2.uint64[3] == 4,
+            'read_data_helper failure: set data2[3] = 4')
+        self.assertTrue(
+            data2.uint64[4] == 5,
+            'read_data_helper failure: set data2[4] = 5')
+
+        self.assertTrue(
+            data2.uint64[
+                0:2] == [
+                1,
+                2],
+            'read_data_helper failure: set data2[0:2] = [1,2]')
 
         data2.SetDataFromSInt32Array([2, -2])
         self.assert_data(data2.GetSignedInt32, 0, 2)
         self.assert_data(data2.GetSignedInt32, 4, -2)
-        
+
         data2.SetDataFromSInt64Array([2, -2])
         self.assert_data(data2.GetSignedInt64, 0, 2)
         self.assert_data(data2.GetSignedInt64, 8, -2)
-        
-        data2.SetDataFromUInt32Array([1,2,3,4,5])
+
+        data2.SetDataFromUInt32Array([1, 2, 3, 4, 5])
         self.assert_data(data2.GetUnsignedInt32, 0, 1)
         self.assert_data(data2.GetUnsignedInt32, 4, 2)
         self.assert_data(data2.GetUnsignedInt32, 8, 3)
         self.assert_data(data2.GetUnsignedInt32, 12, 4)
         self.assert_data(data2.GetUnsignedInt32, 16, 5)
-        
-        self.assertTrue(data2.uint32[0] == 1, 'read_data_helper failure: set 32-bit data2[0] = 1')
-        self.assertTrue(data2.uint32[1] == 2, 'read_data_helper failure: set 32-bit data2[1] = 2')
-        self.assertTrue(data2.uint32[2] == 3, 'read_data_helper failure: set 32-bit data2[2] = 3')
-        self.assertTrue(data2.uint32[3] == 4, 'read_data_helper failure: set 32-bit data2[3] = 4')
-        self.assertTrue(data2.uint32[4] == 5, 'read_data_helper failure: set 32-bit data2[4] = 5')
-
-        data2.SetDataFromDoubleArray([3.14,6.28,2.71])
-        self.assertTrue( fabs(data2.GetDouble(error,0) - 3.14) < 0.5, 'set double data2[0] = 3.14')
-        self.assertTrue( fabs(data2.GetDouble(error,8) - 6.28) < 0.5, 'set double data2[1] = 6.28')
-        self.assertTrue( fabs(data2.GetDouble(error,16) - 2.71) < 0.5, 'set double data2[2] = 2.71')
-
-        self.assertTrue( fabs(data2.double[0] - 3.14) < 0.5, 'read_data_helper failure: set double data2[0] = 3.14')
-        self.assertTrue( fabs(data2.double[1] - 6.28) < 0.5, 'read_data_helper failure: set double data2[1] = 6.28')
-        self.assertTrue( fabs(data2.double[2] - 2.71) < 0.5, 'read_data_helper failure: set double data2[2] = 2.71')
+
+        self.assertTrue(
+            data2.uint32[0] == 1,
+            'read_data_helper failure: set 32-bit data2[0] = 1')
+        self.assertTrue(
+            data2.uint32[1] == 2,
+            'read_data_helper failure: set 32-bit data2[1] = 2')
+        self.assertTrue(
+            data2.uint32[2] == 3,
+            'read_data_helper failure: set 32-bit data2[2] = 3')
+        self.assertTrue(
+            data2.uint32[3] == 4,
+            'read_data_helper failure: set 32-bit data2[3] = 4')
+        self.assertTrue(
+            data2.uint32[4] == 5,
+            'read_data_helper failure: set 32-bit data2[4] = 5')
+
+        data2.SetDataFromDoubleArray([3.14, 6.28, 2.71])
+        self.assertTrue(fabs(data2.GetDouble(error, 0) - 3.14)
+                        < 0.5, 'set double data2[0] = 3.14')
+        self.assertTrue(fabs(data2.GetDouble(error, 8) - 6.28)
+                        < 0.5, 'set double data2[1] = 6.28')
+        self.assertTrue(fabs(data2.GetDouble(error, 16) - 2.71)
+                        < 0.5, 'set double data2[2] = 2.71')
+
+        self.assertTrue(
+            fabs(
+                data2.double[0] -
+                3.14) < 0.5,
+            'read_data_helper failure: set double data2[0] = 3.14')
+        self.assertTrue(
+            fabs(
+                data2.double[1] -
+                6.28) < 0.5,
+            'read_data_helper failure: set double data2[1] = 6.28')
+        self.assertTrue(
+            fabs(
+                data2.double[2] -
+                2.71) < 0.5,
+            'read_data_helper failure: set double data2[2] = 2.71')
 
     def assert_data(self, func, arg, expected):
         """ Asserts func(SBError error, arg) == expected. """
@@ -346,8 +529,9 @@ class SBDataAPICase(TestBase):
         if not error.Success():
             stream = lldb.SBStream()
             error.GetDescription(stream)
-            self.assertTrue(error.Success(),
-                            "%s(error, %s) did not succeed: %s" % (func.__name__,
-                                                                   arg,
-                                                                   stream.GetData()))
-        self.assertTrue(expected == result, "%s(error, %s) == %s != %s" % (func.__name__, arg, result, expected))
+            self.assertTrue(
+                error.Success(), "%s(error, %s) did not succeed: %s" %
+                (func.__name__, arg, stream.GetData()))
+        self.assertTrue(
+            expected == result, "%s(error, %s) == %s != %s" %
+            (func.__name__, arg, result, expected))