"""
Test some SBStructuredData API.
"""
import lldb
from lldbsuite.test.decorators import *
from lldbsuite.test.lldbtest import *
from lldbsuite.test import lldbutil
import json
class TestStructuredDataAPI(TestBase):
NO_DEBUG_INFO_TESTCASE = True
def test(self):
self.structured_data_api_test()
def structured_data_api_test(self):
error = lldb.SBError()
s = lldb.SBStream()
dict_str = json.dumps(
{
"key_dict": {
"key_string": "STRING",
"key_uint": 0xFFFFFFFF00000000,
"key_sint": -42,
"key_float": 2.99,
"key_bool": True,
"key_array": ["23", "arr"],
}
}
)
s.Print(dict_str)
example = lldb.SBStructuredData()
# Check SetFromJSON API for dictionaries, integers, floating point
# values, strings and arrays
error = example.SetFromJSON(s)
if not error.Success():
self.fail("FAILED: " + error.GetCString())
# Tests for invalid data type
self.invalid_struct_test(example)
# Test that GetDescription works:
s.Clear()
error = example.GetDescription(s)
self.assertSuccess(error, "GetDescription works")
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
self.dictionary_struct_test(example)
# Tests for string data type
self.string_struct_test(dict_struct)
# Tests for integer data type
self.uint_struct_test(dict_struct)
# Tests for integer data type
self.sint_struct_test(dict_struct)
# Tests for floating point data type
self.double_struct_test(dict_struct)
# Tests for boolean data type
self.bool_struct_test(dict_struct)
# Tests for array data type
self.array_struct_test(dict_struct)
s.Clear()
self.assertSuccess(example.GetAsJSON(s))
py_obj = json.loads(s.GetData())
self.assertTrue(py_obj)
self.assertIn("key_dict", py_obj)
py_dict = py_obj["key_dict"]
self.assertEqual(py_dict["key_string"], "STRING")
self.assertEqual(py_dict["key_uint"], 0xFFFFFFFF00000000)
self.assertEqual(py_dict["key_sint"], -42)
self.assertEqual(py_dict["key_float"], 2.99)
self.assertEqual(py_dict["key_bool"], True)
self.assertEqual(py_dict["key_array"], ["23", "arr"])
class MyRandomClass:
payload = "foo"
py_dict["key_generic"] = MyRandomClass()
stp = lldb.SBScriptObject(py_dict, lldb.eScriptLanguagePython)
self.assertEqual(stp.ptr, py_dict)
sd = lldb.SBStructuredData(stp, self.dbg)
self.assertTrue(sd.IsValid())
self.assertEqual(sd.GetSize(), len(py_dict))
generic_sd = sd.GetValueForKey("key_generic")
self.assertTrue(generic_sd.IsValid())
self.assertEqual(generic_sd.GetType(), lldb.eStructuredDataTypeGeneric)
my_random_class = generic_sd.GetGenericValue()
self.assertTrue(my_random_class)
self.assertEqual(my_random_class.payload, MyRandomClass.payload)
example = lldb.SBStructuredData()
self.assertSuccess(example.SetFromJSON("1"))
self.assertEqual(example.GetType(), lldb.eStructuredDataTypeInteger)
self.assertEqual(example.GetIntegerValue(), 1)
self.assertSuccess(example.SetFromJSON("4.19"))
self.assertEqual(example.GetType(), lldb.eStructuredDataTypeFloat)
self.assertEqual(example.GetFloatValue(), 4.19)
self.assertSuccess(example.SetFromJSON('"Bonjour, 123!"'))
self.assertEqual(example.GetType(), lldb.eStructuredDataTypeString)
self.assertEqual(example.GetStringValue(42), "Bonjour, 123!")
self.assertSuccess(example.SetFromJSON("true"))
self.assertEqual(example.GetType(), lldb.eStructuredDataTypeBoolean)
self.assertTrue(example.GetBooleanValue())
self.assertSuccess(example.SetFromJSON("null"))
self.assertEqual(example.GetType(), lldb.eStructuredDataTypeNull)
example_arr = [1, 2.3, "4", {"5": False}]
arr_str = json.dumps(example_arr)
s.Clear()
s.Print(arr_str)
self.assertSuccess(example.SetFromJSON(s))
s.Clear()
self.assertSuccess(example.GetAsJSON(s))
sb_data = json.loads(s.GetData())
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 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 not dict_struct.GetType() == lldb.eStructuredDataTypeDictionary:
self.fail("Wrong type returned: " + str(dict_struct.GetType()))
# Check Size API for 'dictionary' type
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 not string_struct.GetType() == lldb.eStructuredDataTypeString:
self.fail("Wrong type returned: " + str(string_struct.GetType()))
# Check API returning 'string' value
output = string_struct.GetStringValue(25)
if not "STRING" in output:
self.fail("wrong output: " + output)
# Calling wrong API on a SBStructuredData
# (e.g. getting an integer from a string type structure)
output = string_struct.GetIntegerValue()
if output:
self.fail(
"Valid integer value " + str(output) + " returned for a string object"
)
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 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 not output == 0xFFFFFFFF00000000:
self.fail("wrong output: " + str(output))
# Calling wrong API on a SBStructuredData
# (e.g. getting a string value from an integer type structure)
output = uint_struct.GetStringValue(25)
if output:
self.fail("Valid string " + output + " returned for an integer object")
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 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 not output == -42:
self.fail("wrong output: " + str(output))
# Calling wrong API on a SBStructuredData
# (e.g. getting a string value from an integer type structure)
output = sint_struct.GetStringValue(69)
if output:
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 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 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 not bool_struct.GetType() == lldb.eStructuredDataTypeBoolean:
self.fail("Wrong type returned: " + str(bool_struct.GetType()))
# Check API returning 'bool' value
output = bool_struct.GetBooleanValue()
if not output:
self.fail("wrong output: " + str(output))
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 not array_struct.GetType() == lldb.eStructuredDataTypeArray:
self.fail("Wrong type returned: " + str(array_struct.GetType()))
# Check Size API for 'array' type
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'
# indices
string_struct = array_struct.GetItemAtIndex(0)
if not string_struct.IsValid():
self.fail("A valid object should have been returned")
if not string_struct.GetType() == lldb.eStructuredDataTypeString:
self.fail("Wrong type returned: " + str(string_struct.GetType()))
output = string_struct.GetStringValue(5)
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 not string_struct.GetType() == lldb.eStructuredDataTypeString:
self.fail("Wrong type returned: " + str(string_struct.GetType()))
output = string_struct.GetStringValue(5)
if not output == "arr":
self.fail("wrong output: " + str(output))
Codebase Browser
llvm