diff --git a/lldb/bindings/interface/SBStructuredDataExtensions.i b/lldb/bindings/interface/SBStructuredDataExtensions.i index 9def366a4cf11..ca3d0966f9fc1 100644 --- a/lldb/bindings/interface/SBStructuredDataExtensions.i +++ b/lldb/bindings/interface/SBStructuredDataExtensions.i @@ -3,121 +3,16 @@ STRING_EXTENSION_OUTSIDE(SBStructuredData) %extend lldb::SBStructuredData { #ifdef SWIGPYTHON %pythoncode%{ + def __int__(self): + return self.GetSignedInteger() + def __len__(self): '''Return the number of element in a lldb.SBStructuredData object.''' return self.GetSize() def __iter__(self): '''Iterate over all the elements in a lldb.SBStructuredData object.''' - data_type = self.GetType() - if data_type == eStructuredDataTypeArray: - for i in range(self.GetSize()): - yield self.GetItemAtIndex(i).dynamic - return - elif data_type == eStructuredDataTypeDictionary: - keys = SBStringList() - self.GetKeys(keys) - return iter(keys) - else: - raise TypeError(f"cannot iterate {self.type_name(data_type)} type") - - def __getitem__(self, key): - data_type = self.GetType() - if data_type == eStructuredDataTypeArray: - if not isinstance(key, int): - raise TypeError("subscript index must be an integer") - count = len(self) - if -count <= key < count: - key %= count - return self.GetItemAtIndex(key).dynamic - raise IndexError("index out of range") - elif data_type == eStructuredDataTypeDictionary: - if not isinstance(key, str): - raise TypeError("subscript key must be a string") - return self.GetValueForKey(key).dynamic - else: - raise TypeError(f"cannot subscript {self.type_name(data_type)} type") - - def __bool__(self): - data_type = self.GetType() - if data_type == eStructuredDataTypeInvalid: - return False - elif data_type in ( - eStructuredDataTypeArray, - eStructuredDataTypeDictionary, - ): - return self.GetSize() != 0 - elif data_type != eStructuredDataTypeGeneric: - return bool(self.dynamic) - else: - raise TypeError("cannot convert generic to bool") - - def __int__(self): - data_type = self.GetType() - if data_type in ( - eStructuredDataTypeInteger, - eStructuredDataTypeSignedInteger, - ): - return int(self.dynamic) - else: - raise TypeError(f"cannot convert {self.type_name(data_type)} to int") - - def __float__(self): - data_type = self.GetType() - if data_type in ( - eStructuredDataTypeFloat, - eStructuredDataTypeInteger, - eStructuredDataTypeSignedInteger, - ): - return float(self.dynamic) - else: - raise TypeError(f"cannot convert {self.type_name(data_type)} to float") - - @property - def dynamic(self): - data_type = self.GetType() - if data_type == eStructuredDataTypeNull: - return None - elif data_type == eStructuredDataTypeBoolean: - return self.GetBooleanValue() - elif data_type == eStructuredDataTypeInteger: - return self.GetUnsignedIntegerValue() - elif data_type == eStructuredDataTypeSignedInteger: - return self.GetSignedIntegerValue() - elif data_type == eStructuredDataTypeFloat: - return self.GetFloatValue() - elif data_type == eStructuredDataTypeString: - size = len(self) or 1023 - return self.GetStringValue(size + 1) - elif data_type == eStructuredDataTypeGeneric: - return self.GetGenericValue() - else: - return self - - @staticmethod - def type_name(t): - if t == eStructuredDataTypeNull: - return "null" - elif t == eStructuredDataTypeBoolean: - return "boolean" - elif t == eStructuredDataTypeInteger: - return "integer" - elif t == eStructuredDataTypeSignedInteger: - return "integer" - elif t == eStructuredDataTypeFloat: - return "float" - elif t == eStructuredDataTypeString: - return "string" - elif t == eStructuredDataTypeArray: - return "array" - elif t == eStructuredDataTypeDictionary: - return "dictionary" - elif t == eStructuredDataTypeGeneric: - return "generic" - elif t == eStructuredDataTypeInvalid: - return "invalid" - else: - raise TypeError(f"unknown structured data type: {t}") + return lldb_iter(self, 'GetSize', 'GetItemAtIndex') %} #endif } diff --git a/lldb/test/API/python_api/sbstructureddata/TestStructuredDataAPI.py b/lldb/test/API/python_api/sbstructureddata/TestStructuredDataAPI.py index 275ac03a5a86d..99f88d3da794a 100644 --- a/lldb/test/API/python_api/sbstructureddata/TestStructuredDataAPI.py +++ b/lldb/test/API/python_api/sbstructureddata/TestStructuredDataAPI.py @@ -48,11 +48,10 @@ def structured_data_api_test(self): s.Clear() error = example.GetDescription(s) self.assertSuccess(error, "GetDescription works") - # Ensure str() doesn't raise an exception. - self.assertTrue(str(example)) if not "key_float" in s.GetData(): self.fail("FAILED: could not find key_float in description output") + dict_struct = lldb.SBStructuredData() dict_struct = example.GetValueForKey("key_dict") # Tests for dictionary data type @@ -114,26 +113,21 @@ class MyRandomClass: self.assertSuccess(example.SetFromJSON("1")) self.assertEqual(example.GetType(), lldb.eStructuredDataTypeInteger) self.assertEqual(example.GetIntegerValue(), 1) - self.assertEqual(int(example), 1) self.assertSuccess(example.SetFromJSON("4.19")) self.assertEqual(example.GetType(), lldb.eStructuredDataTypeFloat) self.assertEqual(example.GetFloatValue(), 4.19) - self.assertEqual(float(example), 4.19) self.assertSuccess(example.SetFromJSON('"Bonjour, 123!"')) self.assertEqual(example.GetType(), lldb.eStructuredDataTypeString) self.assertEqual(example.GetStringValue(42), "Bonjour, 123!") - self.assertEqual(str(example), "Bonjour, 123!") self.assertSuccess(example.SetFromJSON("true")) self.assertEqual(example.GetType(), lldb.eStructuredDataTypeBoolean) self.assertTrue(example.GetBooleanValue()) - self.assertTrue(example) self.assertSuccess(example.SetFromJSON("null")) self.assertEqual(example.GetType(), lldb.eStructuredDataTypeNull) - self.assertFalse(example) example = lldb.SBStructuredData() example.SetUnsignedIntegerValue(1) @@ -193,35 +187,38 @@ class MyRandomClass: self.assertEqual(sb_data, example_arr) def invalid_struct_test(self, example): + invalid_struct = lldb.SBStructuredData() invalid_struct = example.GetValueForKey("invalid_key") if invalid_struct.IsValid(): self.fail("An invalid object should have been returned") # Check Type API - if invalid_struct.GetType() != lldb.eStructuredDataTypeInvalid: + if not invalid_struct.GetType() == lldb.eStructuredDataTypeInvalid: self.fail("Wrong type returned: " + str(invalid_struct.GetType())) def dictionary_struct_test(self, example): # Check API returning a valid SBStructuredData of 'dictionary' type + dict_struct = lldb.SBStructuredData() dict_struct = example.GetValueForKey("key_dict") if not dict_struct.IsValid(): self.fail("A valid object should have been returned") # Check Type API - if dict_struct.GetType() != lldb.eStructuredDataTypeDictionary: + if not dict_struct.GetType() == lldb.eStructuredDataTypeDictionary: self.fail("Wrong type returned: " + str(dict_struct.GetType())) # Check Size API for 'dictionary' type - if dict_struct.GetSize() != 6: + if not dict_struct.GetSize() == 6: self.fail("Wrong no of elements returned: " + str(dict_struct.GetSize())) def string_struct_test(self, dict_struct): + string_struct = lldb.SBStructuredData() string_struct = dict_struct.GetValueForKey("key_string") if not string_struct.IsValid(): self.fail("A valid object should have been returned") # Check Type API - if string_struct.GetType() != lldb.eStructuredDataTypeString: + if not string_struct.GetType() == lldb.eStructuredDataTypeString: self.fail("Wrong type returned: " + str(string_struct.GetType())) # Check API returning 'string' value @@ -241,17 +238,18 @@ def uint_struct_test(self, dict_struct): # Check a valid SBStructuredData containing an unsigned integer. # We intentionally make this larger than what an int64_t can hold but # still small enough to fit a uint64_t + uint_struct = lldb.SBStructuredData() uint_struct = dict_struct.GetValueForKey("key_uint") if not uint_struct.IsValid(): self.fail("A valid object should have been returned") # Check Type API - if uint_struct.GetType() != lldb.eStructuredDataTypeInteger: + if not uint_struct.GetType() == lldb.eStructuredDataTypeInteger: self.fail("Wrong type returned: " + str(uint_struct.GetType())) # Check API returning unsigned integer value output = uint_struct.GetUnsignedIntegerValue() - if output != 0xFFFFFFFF00000000: + if not output == 0xFFFFFFFF00000000: self.fail("wrong output: " + str(output)) # Calling wrong API on a SBStructuredData @@ -264,17 +262,18 @@ def sint_struct_test(self, dict_struct): # Check a valid SBStructuredData containing an signed integer. # We intentionally make this smaller than what an uint64_t can hold but # still small enough to fit a int64_t + sint_struct = lldb.SBStructuredData() sint_struct = dict_struct.GetValueForKey("key_sint") if not sint_struct.IsValid(): self.fail("A valid object should have been returned") # Check Type API - if sint_struct.GetType() != lldb.eStructuredDataTypeSignedInteger: + if not sint_struct.GetType() == lldb.eStructuredDataTypeSignedInteger: self.fail("Wrong type returned: " + str(sint_struct.GetType())) # Check API returning signed integer value output = sint_struct.GetSignedIntegerValue() - if output != -42: + if not output == -42: self.fail("wrong output: " + str(output)) # Calling wrong API on a SBStructuredData @@ -284,26 +283,28 @@ def sint_struct_test(self, dict_struct): self.fail("Valid string " + output + " returned for an integer object") def double_struct_test(self, dict_struct): + floating_point_struct = lldb.SBStructuredData() floating_point_struct = dict_struct.GetValueForKey("key_float") if not floating_point_struct.IsValid(): self.fail("A valid object should have been returned") # Check Type API - if floating_point_struct.GetType() != lldb.eStructuredDataTypeFloat: + if not floating_point_struct.GetType() == lldb.eStructuredDataTypeFloat: self.fail("Wrong type returned: " + str(floating_point_struct.GetType())) # Check API returning 'double' value output = floating_point_struct.GetFloatValue() - if output != 2.99: + if not output == 2.99: self.fail("wrong output: " + str(output)) def bool_struct_test(self, dict_struct): + bool_struct = lldb.SBStructuredData() bool_struct = dict_struct.GetValueForKey("key_bool") if not bool_struct.IsValid(): self.fail("A valid object should have been returned") # Check Type API - if bool_struct.GetType() != lldb.eStructuredDataTypeBoolean: + if not bool_struct.GetType() == lldb.eStructuredDataTypeBoolean: self.fail("Wrong type returned: " + str(bool_struct.GetType())) # Check API returning 'bool' value @@ -313,16 +314,17 @@ def bool_struct_test(self, dict_struct): def array_struct_test(self, dict_struct): # Check API returning a valid SBStructuredData of 'array' type + array_struct = lldb.SBStructuredData() array_struct = dict_struct.GetValueForKey("key_array") if not array_struct.IsValid(): self.fail("A valid object should have been returned") # Check Type API - if array_struct.GetType() != lldb.eStructuredDataTypeArray: + if not array_struct.GetType() == lldb.eStructuredDataTypeArray: self.fail("Wrong type returned: " + str(array_struct.GetType())) # Check Size API for 'array' type - if array_struct.GetSize() != 2: + if not array_struct.GetSize() == 2: self.fail("Wrong no of elements returned: " + str(array_struct.GetSize())) # Check API returning a valid SBStructuredData for different 'array' @@ -330,91 +332,17 @@ def array_struct_test(self, dict_struct): string_struct = array_struct.GetItemAtIndex(0) if not string_struct.IsValid(): self.fail("A valid object should have been returned") - if string_struct.GetType() != lldb.eStructuredDataTypeString: + if not string_struct.GetType() == lldb.eStructuredDataTypeString: self.fail("Wrong type returned: " + str(string_struct.GetType())) output = string_struct.GetStringValue(5) - if output != "23": + if not output == "23": self.fail("wrong output: " + str(output)) string_struct = array_struct.GetItemAtIndex(1) if not string_struct.IsValid(): self.fail("A valid object should have been returned") - if string_struct.GetType() != lldb.eStructuredDataTypeString: + if not string_struct.GetType() == lldb.eStructuredDataTypeString: self.fail("Wrong type returned: " + str(string_struct.GetType())) output = string_struct.GetStringValue(5) - if output != "arr": + if not output == "arr": self.fail("wrong output: " + str(output)) - - def test_round_trip_scalars(self): - for original in (0, 11, -1, 0.0, 4.5, -0.25, True, False): - constructor = type(original) - data = lldb.SBStructuredData() - data.SetFromJSON(json.dumps(original)) - round_tripped = constructor(data) - self.assertEqual(round_tripped, original) - - def test_dynamic(self): - for original in (0, 11, -1, 0.0, 4.5, -0.25, "", "dirk", True, False): - data = lldb.SBStructuredData() - data.SetFromJSON(json.dumps(original)) - self.assertEqual(data.dynamic, original) - - def test_round_trip_int(self): - for original in (0, 11, -1): - data = lldb.SBStructuredData() - data.SetFromJSON(json.dumps(original)) - self.assertEqual(int(data), int(original)) - - def test_round_trip_float(self): - for original in (0, 11, -1, 0.0, 4.5, -0.25): - data = lldb.SBStructuredData() - data.SetFromJSON(json.dumps(original)) - self.assertEqual(float(data), float(original)) - - def test_round_trip_bool(self): - for original in (0, 11, -1, 0.0, 4.5, -0.25, "0.0", "4.5", "-0.25"): - data = lldb.SBStructuredData() - data.SetFromJSON(json.dumps(original)) - self.assertEqual(bool(data), bool(original)) - - for original in ([], {}, [1], {1: 1}): - data = lldb.SBStructuredData() - data.SetFromJSON(json.dumps(original)) - self.assertEqual(bool(data), bool(original)) - - def test_assert_false(self): - self.assertFalse(lldb.SBStructuredData()) - for original in ("0", "0.0", '""', "[]", "{}"): - data = lldb.SBStructuredData() - data.SetFromJSON(original) - self.assertFalse(data) - - def test_iterate_array(self): - array = [0, 1, 2] - data = lldb.SBStructuredData() - data.SetFromJSON(json.dumps(array)) - for value in data: - self.assertEqual(value, array.pop(0)) - - def test_iterate_dictionary(self): - dictionary = {"0": 0, "1": 1, "2": 2} - keys = set(dictionary.keys()) - data = lldb.SBStructuredData() - data.SetFromJSON(json.dumps(dictionary)) - for key in data: - self.assertIn(key, keys) - keys.remove(key) - - def test_getitem_array(self): - array = [1, 2, 3] - data = lldb.SBStructuredData() - data.SetFromJSON(json.dumps(array)) - for i in range(len(array)): - self.assertEqual(data[i], array[i]) - - def test_getitem_dictionary(self): - dictionary = {"one": 1, "two": 2, "three": 3} - data = lldb.SBStructuredData() - data.SetFromJSON(json.dumps(dictionary)) - for key in dictionary: - self.assertEqual(data[key], dictionary[key])