Added new API to SBStructuredData class

[abhishek.aggarwal]

Summary

• Added API to access data types
  • integer, double, array, string, boolean and dictionary data types
  • Earlier user had to parse through the string output to get these values
• Added Test cases for API testing
• Added new StructuredDataType enum in public include file
  • Replaced locally-defined enum in StructuredData.h with this new one
  • Modified other internal files using this locally-defined enum

Signed-off-by: Abhishek Aggarwal <[e-mail]>

[clayborg]

Very close and overall very nice, just a few implementation details to take care of.

include/lldb/API/SBStructuredData.h

20–28

This should go into lldb-enumerations.h and the lldb_private::StructuredData should switch over to using that enum as well. Then we won't duplicated the enum here and in StructuredData.h. The enum type name will need to become longer and the enums will need to include the prefix be longer:

enum StructureDataType {
  eStructureDataTypeInvalid,
  eStructureDataTypeArray,
  ...

43

lldb::StructureDataType to match the new enum in lldb-enumerations.h

50

What is the user going to really do when getting the size from a dictionary? I would vote to just make this for arrays and provide a IsEmpty() method if you want to check if the dictionary or array is empty? I am open for reasons why we should be able to get the size of the dictionary if there is a need, I am just thinking out loud here.

83

We should make this be able to take NULL for dst and/or zero for dst_len and have it return the size that would be needed to store the value. Basically document:

• the return value is always the byte size needed for the string value
• if the buffer supplied is insufficient, then dst_len -1 bytes will be filled in and the string will be NULL terminated prematurely
• the if the buffer supplied is invalid (dst == NULL, or dst_len == 0), then no data will be filled in

102–103

Remove this.

include/lldb/Core/StructuredDataImpl.h

117–121

Do we need to get the size for a dictionary? See above inlined comment.

131–138

Might be easier to use the StructuredData::GetAsDictionary():

if (m_data_sp) {
  auto dict = m_data_sp->GetAsDictionary();
  if (dict)
    return dict->GetValueForKey(llvm::StringRef(key))
}
return StructuredData::ObjectSP();

142–147

Use GetAsArray() like above dictionary requested changes.

scripts/interface/SBStructuredData.i

21–29

Remove and use from lldb-enumerations.h

source/API/SBStructuredData.cpp

34–35

Remove this.

112

Just default construct one:

SBStructuredData result;
result.m_impl_up->SetObjectSP(m_impl_up->GetValueForKey(key));
return result;

121–123

Default construct and use the object:

SBStructuredData result;
result.m_impl_up->SetObjectSP(m_impl_up-> GetItemAtIndex(idx));
return result;

[abhishek.aggarwal]

Updating D33434: Added new API to SBStructuredData class

• Made changes according to feedback

[abhishek.aggarwal]

My comments are inlined. Please let me know if something still needs to be changed.

include/lldb/API/SBStructuredData.h

50

I thought of the use case that a user might expect lldb to fill specific number of entries in a dictionary. This might serve as a failure check for the user right in the begining of his code without accessing each (key:value) pair inside it to conclude that enough number of entries are not filled inside the dictionary. I am leaving it as it is for now. However, if you disagree then I will change it according to your proposal.

[clayborg]

No need for the "StructuredDataType::" or "lldb::StructuredDataType::" prefixes. Since we aren't using an enum class (it was before) and since all enumerators start with "eStructuredDataType", it is now clear where this enum comes from without prefixing with the enum type name and/or namespace. I know you were replicating what was there before. There are two ways to fix this:
1 - define the lldb::StructuredDataType and "enum class StructuredDataType" and then shorten the names by removing eStructuredDataType from each enumerator
2 - leave lldb::StructuredDataType defined as enum StructuredDataType" and leave the names long and they can be used on their own.

I vote for #2 since that is what most other enums do in lldb-enumerations and also for python compatibility. Swig auto creates all enumerations and not sure if it does things correctly for "enum class", so best to go with option #2

So fix the std::string copy and drop all "lldb::StructuredDataType::" or "StructuredDataType::" from the names in the code and this will be good to go.

include/lldb/API/SBStructuredData.h

50

No worries, If there is a viable use case, and unit testing is, then we can have this.

include/lldb/Core/StructuredDataImpl.h

142

This comes as a llvm::StringRef. No need to copy the string, just use llvm::StringRef so we don't make a heap copy of the string just to copy it.

[labath]

packages/Python/lldbsuite/test/python_api/sbstructureddata/TestStructuredDataAPI.py

43

Why do you need a process for this test? It sounds like all you're doing is playing around with SBStructuredData. You can remove everything from here including the self.build() call and the inferior source.

Then you can annotate this test with NO_DEBUG_INFO_TESTCASE = True, as it definitely does not depend on debug info.

[abhishek.aggarwal]

Thanks for your suggestions. I have made changes according to feedback and submitting it here.

[abhishek.aggarwal]

Updating D33434: Added new API to SBStructuredData class

• Removed inferior from test case (not required)
• fixed enum scope

include/lldb/API/SBStructuredData.h

 
 #include "lldb/API/SBDefines.h"
 #include "lldb/API/SBModule.h"
 
 namespace lldb {
 
 class SBStructuredData {
 public:
   SBStructuredData();
 
   SBStructuredData(const lldb::SBStructuredData &rhs);
 
   SBStructuredData(const lldb::EventSP &event_sp);
 
   ~SBStructuredData();
 
   lldb::SBStructuredData &operator=(const lldb::SBStructuredData &rhs);
 
   bool IsValid() const;
 
   lldb::SBError SetFromJSON(lldb::SBStream &stream);
 
   void Clear();
 
   lldb::SBError GetAsJSON(lldb::SBStream &stream) const;
 
   lldb::SBError GetDescription(lldb::SBStream &stream) const;
 
+  //------------------------------------------------------------------
+  /// Return the type of data in this data structure
+  //------------------------------------------------------------------
+  lldb::StructuredDataType GetType() const;
+
+  //------------------------------------------------------------------
+  /// Return the size (i.e. number of elements) in this data structure
+  /// if it is an array or dictionary type. For other types, 0 will be
+  //  returned.
+  //------------------------------------------------------------------
+  size_t GetSize() const;
+
+  //------------------------------------------------------------------
+  /// Return the value corresponding to a key if this data structure
+  /// is a dictionary type.
+  //------------------------------------------------------------------
+  lldb::SBStructuredData GetValueForKey(const char *key) const;
+
+  //------------------------------------------------------------------
+  /// Return the value corresponding to an index if this data structure
+  /// is array.
+  //------------------------------------------------------------------
+  lldb::SBStructuredData GetItemAtIndex(size_t idx) const;
+
+  //------------------------------------------------------------------
+  /// Return the integer value if this data structure is an integer type.
+  //------------------------------------------------------------------
+  uint64_t GetIntegerValue(uint64_t fail_value = 0) const;
+
+  //------------------------------------------------------------------
+  /// Return the floating point value if this data structure is a floating
+  /// type.
+  //------------------------------------------------------------------
+  double GetFloatValue(double fail_value = 0.0) const;
+
+  //------------------------------------------------------------------
+  /// Return the boolean value if this data structure is a boolean type.
+  //------------------------------------------------------------------
+  bool GetBooleanValue(bool fail_value = false) const;
+
+  //------------------------------------------------------------------
+  /// Provides the string value if this data structure is a string type.
+  ///
+  /// @param[out] dst
+  ///     pointer where the string value will be written. In case it is null,
+  ///     nothing will be written at @dst.
+  ///
+  /// @param[in] dst_len
+  ///     max number of characters that can be written at @dst. In case it is
+  ///     zero, nothing will be written at @dst. If this length is not enough
+  ///     to write the complete string value, (dst_len-1) bytes of the string
+  ///     value will be written at @dst followed by a null character.
+  ///
+  /// @return
+  ///     Returns the byte size needed to completely write the string value at
+  ///     @dst in all cases.
+  //------------------------------------------------------------------
+  size_t GetStringValue(char *dst, size_t dst_len) const;
+
 protected:
   friend class SBTraceOptions;
 
   StructuredDataImplUP m_impl_up;
 };
-}
+} // namespace lldb
 
 #endif /* SBStructuredData_h */

include/lldb/Core/StructuredData.h

 //===-- StructuredData.h ----------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_StructuredData_h_
 #define liblldb_StructuredData_h_
 
 #include "llvm/ADT/StringRef.h"
 
 #include "lldb/Utility/ConstString.h"
-#include "lldb/Utility/FileSpec.h" // for FileSpec
+#include "lldb/Utility/FileSpec.h"  // for FileSpec
+#include "lldb/lldb-enumerations.h" // for StructuredDataType
 
 #include <functional>
 #include <map>
 #include <memory>
 #include <string>
 #include <type_traits> // for move
 #include <utility>
 #include <vector>
public:
   typedef std::shared_ptr<Array> ArraySP;
   typedef std::shared_ptr<Integer> IntegerSP;
   typedef std::shared_ptr<Float> FloatSP;
   typedef std::shared_ptr<Boolean> BooleanSP;
   typedef std::shared_ptr<String> StringSP;
   typedef std::shared_ptr<Dictionary> DictionarySP;
   typedef std::shared_ptr<Generic> GenericSP;
 
-  enum class Type {
-    eTypeInvalid = -1,
-    eTypeNull = 0,
-    eTypeGeneric,
-    eTypeArray,
-    eTypeInteger,
-    eTypeFloat,
-    eTypeBoolean,
-    eTypeString,
-    eTypeDictionary
-  };
-
   class Object : public std::enable_shared_from_this<Object> {
   public:
-    Object(Type t = Type::eTypeInvalid) : m_type(t) {}
+    Object(lldb::StructuredDataType t =
+               lldb::StructuredDataType::eStructuredDataTypeInvalid)
+        : m_type(t) {}
 
     virtual ~Object() = default;
 
     virtual bool IsValid() const { return true; }
 
-    virtual void Clear() { m_type = Type::eTypeInvalid; }
+    virtual void Clear() {
+      m_type = lldb::StructuredDataType::eStructuredDataTypeInvalid;
+    }
 
-    Type GetType() const { return m_type; }
+    lldb::StructuredDataType GetType() const { return m_type; }
 
-    void SetType(Type t) { m_type = t; }
+    void SetType(lldb::StructuredDataType t) { m_type = t; }
 
     Array *GetAsArray() {
-      return ((m_type == Type::eTypeArray) ? static_cast<Array *>(this)
-                                           : nullptr);
+      return ((m_type == lldb::StructuredDataType::eStructuredDataTypeArray)
+                  ? static_cast<Array *>(this)
     }
 
     Dictionary *GetAsDictionary() {
-      return ((m_type == Type::eTypeDictionary)
-                  ? static_cast<Dictionary *>(this)
-                  : nullptr);
+      return (
+          (m_type == lldb::StructuredDataType::eStructuredDataTypeDictionary)
     }
 
     Integer *GetAsInteger() {
-      return ((m_type == Type::eTypeInteger) ? static_cast<Integer *>(this)
-                                             : nullptr);
+      return ((m_type == lldb::StructuredDataType::eStructuredDataTypeInteger)
+                  ? static_cast<Integer *>(this)
     }
 
     uint64_t GetIntegerValue(uint64_t fail_value = 0) {
       Integer *integer = GetAsInteger();
       return ((integer != nullptr) ? integer->GetValue() : fail_value);
     }
 
     Float *GetAsFloat() {
-      return ((m_type == Type::eTypeFloat) ? static_cast<Float *>(this)
-                                           : nullptr);
+      return ((m_type == lldb::StructuredDataType::eStructuredDataTypeFloat)
+                  ? static_cast<Float *>(this)
     }
 
     double GetFloatValue(double fail_value = 0.0) {
       Float *f = GetAsFloat();
       return ((f != nullptr) ? f->GetValue() : fail_value);
     }
 
     Boolean *GetAsBoolean() {
-      return ((m_type == Type::eTypeBoolean) ? static_cast<Boolean *>(this)
-                                             : nullptr);
+      return ((m_type == lldb::StructuredDataType::eStructuredDataTypeBoolean)
+                  ? static_cast<Boolean *>(this)
     }
 
     bool GetBooleanValue(bool fail_value = false) {
       Boolean *b = GetAsBoolean();
       return ((b != nullptr) ? b->GetValue() : fail_value);
     }
 
     String *GetAsString() {
-      return ((m_type == Type::eTypeString) ? static_cast<String *>(this)
-                                            : nullptr);
+      return ((m_type == lldb::StructuredDataType::eStructuredDataTypeString)
+                  ? static_cast<String *>(this)
     }
 
     llvm::StringRef GetStringValue(const char *fail_value = nullptr) {
       String *s = GetAsString();
       if (s)
         return s->GetValue();
 
       return fail_value;
     }
 
     Generic *GetAsGeneric() {
-      return ((m_type == Type::eTypeGeneric) ? static_cast<Generic *>(this)
-                                             : nullptr);
+      return ((m_type == lldb::StructuredDataType::eStructuredDataTypeGeneric)
+                  ? static_cast<Generic *>(this)
     }
 
     ObjectSP GetObjectForDotSeparatedPath(llvm::StringRef path);
 
     void DumpToStdout(bool pretty_print = true) const;
 
     virtual void Dump(Stream &s, bool pretty_print = true) const = 0;
 
   private:
-    Type m_type;
+    lldb::StructuredDataType m_type;
   };
 
   class Array : public Object {
   public:
-    Array() : Object(Type::eTypeArray) {}
+    Array() : Object(lldb::StructuredDataType::eStructuredDataTypeArray) {}
 
     ~Array() override = default;
 
     bool
     ForEach(std::function<bool(Object *object)> const &foreach_callback) const {
       for (const auto &object_sp : m_items) {
         if (foreach_callback(object_sp.get()) == false)
           return false;
public:
 
   protected:
     typedef std::vector<ObjectSP> collection;
     collection m_items;
   };
 
   class Integer : public Object {
   public:
-    Integer(uint64_t i = 0) : Object(Type::eTypeInteger), m_value(i) {}
+    Integer(uint64_t i = 0)
+        : Object(lldb::StructuredDataType::eStructuredDataTypeInteger),
+          m_value(i) {}
 
     ~Integer() override = default;
 
     void SetValue(uint64_t value) { m_value = value; }
 
     uint64_t GetValue() { return m_value; }
 
     void Dump(Stream &s, bool pretty_print = true) const override;
 
   protected:
     uint64_t m_value;
   };
 
   class Float : public Object {
   public:
-    Float(double d = 0.0) : Object(Type::eTypeFloat), m_value(d) {}
+    Float(double d = 0.0)
+        : Object(lldb::StructuredDataType::eStructuredDataTypeFloat),
+          m_value(d) {}
 
     ~Float() override = default;
 
     void SetValue(double value) { m_value = value; }
 
     double GetValue() { return m_value; }
 
     void Dump(Stream &s, bool pretty_print = true) const override;
 
   protected:
     double m_value;
   };
 
   class Boolean : public Object {
   public:
-    Boolean(bool b = false) : Object(Type::eTypeBoolean), m_value(b) {}
+    Boolean(bool b = false)
+        : Object(lldb::StructuredDataType::eStructuredDataTypeBoolean),
+          m_value(b) {}
 
     ~Boolean() override = default;
 
     void SetValue(bool value) { m_value = value; }
 
     bool GetValue() { return m_value; }
 
     void Dump(Stream &s, bool pretty_print = true) const override;
 
   protected:
     bool m_value;
   };
 
   class String : public Object {
   public:
-    String() : Object(Type::eTypeString) {}
+    String() : Object(lldb::StructuredDataType::eStructuredDataTypeString) {}
     explicit String(llvm::StringRef S)
-        : Object(Type::eTypeString), m_value(S) {}
+        : Object(lldb::StructuredDataType::eStructuredDataTypeString),
+          m_value(S) {}
 
     void SetValue(llvm::StringRef S) { m_value = S; }
 
     llvm::StringRef GetValue() { return m_value; }
 
     void Dump(Stream &s, bool pretty_print = true) const override;
 
   protected:
     std::string m_value;
   };
 
   class Dictionary : public Object {
   public:
-    Dictionary() : Object(Type::eTypeDictionary), m_dict() {}
+    Dictionary()
+        : Object(lldb::StructuredDataType::eStructuredDataTypeDictionary),
+          m_dict() {}
 
     ~Dictionary() override = default;
 
     size_t GetSize() const { return m_dict.size(); }
 
     void ForEach(std::function<bool(ConstString key, Object *object)> const
                      &callback) const {
       for (const auto &pair : m_dict) {
public:
 
   protected:
     typedef std::map<ConstString, ObjectSP> collection;
     collection m_dict;
   };
 
   class Null : public Object {
   public:
-    Null() : Object(Type::eTypeNull) {}
+    Null() : Object(lldb::StructuredDataType::eStructuredDataTypeNull) {}
 
     ~Null() override = default;
 
     bool IsValid() const override { return false; }
 
     void Dump(Stream &s, bool pretty_print = true) const override;
   };
 
   class Generic : public Object {
   public:
     explicit Generic(void *object = nullptr)
-        : Object(Type::eTypeGeneric), m_object(object) {}
+        : Object(lldb::StructuredDataType::eStructuredDataTypeGeneric),
+          m_object(object) {}
 
     void SetValue(void *value) { m_object = value; }
 
     void *GetValue() const { return m_object; }
 
     bool IsValid() const override { return m_object != nullptr; }
 
     void Dump(Stream &s, bool pretty_print = true) const override;

include/lldb/Core/StructuredDataImpl.h

 #ifndef liblldb_StructuredDataImpl_h_
 #define liblldb_StructuredDataImpl_h_
 
 #include "lldb/Core/Event.h"
 #include "lldb/Core/StructuredData.h"
 #include "lldb/Target/StructuredDataPlugin.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/Stream.h"
+#include "lldb/lldb-enumerations.h"
 #include "lldb/lldb-forward.h"
+#include "llvm/ADT/StringRef.h"
 
 #pragma mark--
 #pragma mark StructuredDataImpl
 
 namespace lldb_private {
 
 class StructuredDataImpl {
 public:
if (!plugin_sp) {
                            "plugin doesn't exist.");
       return error;
     }
 
     // Get the data's description.
     return plugin_sp->GetDescription(m_data_sp, stream);
   }
 
-  StructuredData::ObjectSP GetObjectSP() {
-    return m_data_sp;
+  StructuredData::ObjectSP GetObjectSP() { return m_data_sp; }
+
+  void SetObjectSP(const StructuredData::ObjectSP &obj) { m_data_sp = obj; }
+
+  lldb::StructuredDataType GetType() const {
+    return (m_data_sp ? m_data_sp->GetType()
+                      : lldb::StructuredDataType::eStructuredDataTypeInvalid);
   }
 
-  void SetObjectSP(const StructuredData::ObjectSP &obj) {
-    m_data_sp = obj;
+  size_t GetSize() const {
+    if (!m_data_sp)
+      return 0;
+
+    if (m_data_sp->GetType() ==
+        lldb::StructuredDataType::eStructuredDataTypeDictionary) {
+      auto dict = m_data_sp->GetAsDictionary();
+      return (dict->GetSize());
+    } else if (m_data_sp->GetType() ==
+               lldb::StructuredDataType::eStructuredDataTypeArray) {
+      auto array = m_data_sp->GetAsArray();
+      return (array->GetSize());
+    } else
+      return 0;
   }
 
-private:
+  StructuredData::ObjectSP GetValueForKey(const char *key) const {
+    if (m_data_sp) {
+      auto dict = m_data_sp->GetAsDictionary();
+      if (dict)
+        return dict->GetValueForKey(llvm::StringRef(key));
+    }
+    return StructuredData::ObjectSP();
+  }
+
+  StructuredData::ObjectSP GetItemAtIndex(size_t idx) const {
+    if (m_data_sp) {
+      auto array = m_data_sp->GetAsArray();
+      if (array)
+        return array->GetItemAtIndex(idx);
+    }
+    return StructuredData::ObjectSP();
+  }
+
+  uint64_t GetIntegerValue(uint64_t fail_value = 0) const {
+    return (m_data_sp ? m_data_sp->GetIntegerValue(fail_value) : fail_value);
+  }
 
+  double GetFloatValue(double fail_value = 0.0) const {
+    return (m_data_sp ? m_data_sp->GetFloatValue(fail_value) : fail_value);
+  }
+
+  bool GetBooleanValue(bool fail_value = false) const {
+    return (m_data_sp ? m_data_sp->GetBooleanValue(fail_value) : fail_value);
+  }
+
+  size_t GetStringValue(char *dst, size_t dst_len) const {
+    if (!m_data_sp)
+      return 0;
+
+    std::string result = m_data_sp->GetStringValue();
+    if (result.empty())
+      return 0;
+
+    if (!dst || !dst_len) {
+      char s[1];
+      return (::snprintf(s, 1, "%s", result.c_str()));
+    }
+    return (::snprintf(dst, dst_len, "%s", result.c_str()));
+  }
+
+private:
   lldb::StructuredDataPluginWP m_plugin_wp;
   StructuredData::ObjectSP m_data_sp;
 };
-}
+} // namespace lldb_private
 #endif

include/lldb/lldb-enumerations.h

 
 enum TraceType {
   eTraceTypeNone = 0,
 
   // Hardware Trace generated by the processor.
   eTraceTypeProcessorTrace
 };
 
+enum StructuredDataType {
+  eStructuredDataTypeInvalid = -1,
+  eStructuredDataTypeNull = 0,
+  eStructuredDataTypeGeneric,
+  eStructuredDataTypeArray,
+  eStructuredDataTypeInteger,
+  eStructuredDataTypeFloat,
+  eStructuredDataTypeBoolean,
+  eStructuredDataTypeString,
+  eStructuredDataTypeDictionary
+};
+
 FLAGS_ENUM(TypeClass){
     eTypeClassInvalid = (0u), eTypeClassArray = (1u << 0),
     eTypeClassBlockPointer = (1u << 1), eTypeClassBuiltin = (1u << 2),
     eTypeClassClass = (1u << 3), eTypeClassComplexFloat = (1u << 4),
     eTypeClassComplexInteger = (1u << 5), eTypeClassEnumeration = (1u << 6),
     eTypeClassFunction = (1u << 7), eTypeClassMemberPointer = (1u << 8),
     eTypeClassObjCObject = (1u << 9), eTypeClassObjCInterface = (1u << 10),
     eTypeClassObjCObjectPointer = (1u << 11), eTypeClassPointer = (1u << 12),

packages/Python/lldbsuite/test/python_api/sbstructureddata/Makefile

+LEVEL = ../../make
+
+C_SOURCES := main.c
+
+include $(LEVEL)/Makefile.rules

packages/Python/lldbsuite/test/python_api/sbstructureddata/TestStructuredDataAPI.py

+"""
+Test some SBStructuredData API.
+"""
+
+from __future__ import print_function
+
+import os
+import re
+import time
+
+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+
+class TestStructuredDataAPI(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    def test(self):
+        self.build()
+        self.structured_data_api_test()
+
+    def setUp(self):
+        TestBase.setUp(self)
+        self.line = line_number(
+            'main.c', '// Set break point at this line')
+
+    @add_test_categories(['pyapi'])
+    def structured_data_api_test(self):
+        exe = os.path.join(os.getcwd(), "a.out")
+
+        # Create a target by the debugger.
+        target = self.dbg.CreateTarget(exe)
+        self.assertTrue(target, VALID_TARGET)
+
+        # Create the breakpoint inside function 'main'.
+        breakpoint = target.BreakpointCreateByLocation("main.c", self.line)
+        self.assertTrue(breakpoint, VALID_BREAKPOINT)
+
+        # Now launch the process, and do not stop at entry point.
+        process = target.LaunchSimple(
+            None, None, self.get_process_working_directory())
+
+        error = lldb.SBError()
+        s = lldb.SBStream()
+        s.Print(
+            "{\"key_dict\":{\"key_string\":\"STRING\",\"key_int\":3,\"key_float\":2.99,\"key_bool\":true,\"key_array\":[\"23\",\"arr\"]}}")
+        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)
+
+        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.int_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)
+
+    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() == 5:
+            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 int_struct_test(self, dict_struct):
+        # Check a valid SBStructuredData containing an 'integer' by
+        int_struct = lldb.SBStructuredData()
+        int_struct = dict_struct.GetValueForKey("key_int")
+        if not int_struct.IsValid():
+            self.fail("A valid object should have been returned")
+
+        # Check Type API
+        if not int_struct.GetType() == lldb.eStructuredDataTypeInteger:
+            self.fail("Wrong type returned: " + str(int_struct.GetType()))
+
+        # Check API returning 'integer' value
+        output = int_struct.GetIntegerValue()
+        if not output == 3:
+            self.fail("wrong output: " + str(output))
+
+        # Calling wrong API on a SBStructuredData
+        # (e.g. getting a string value from an integer type structure)
+        output = int_struct.GetStringValue(25)
+        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))

packages/Python/lldbsuite/test/python_api/sbstructureddata/main.c

+//===-- main.c --------------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#include <stdint.h>
+
+int main (int argc, char const *argv[])
+{
+    uint32_t a = 0xE0A35F10; // Set break point at this line.
+    return 0;
+}

scripts/interface/SBStructuredData.i

%feature("docstring",
              "A class representing a StructuredData event.
 
               This class wraps the event type generated by StructuredData
               features."
              ) SBStructuredData;
     class SBStructuredData
     {
     public:
-        
         SBStructuredData();
-        
         SBStructuredData(const lldb::SBStructuredData &rhs);
 
         SBStructuredData(const lldb::EventSP &event_sp);
 
         ~SBStructuredData();
-                 
         bool
         IsValid() const;
-                 
         void
         Clear();
 
+        lldb::SBStructuredData &operator=(const lldb::SBStructuredData &rhs);
+
+        lldb::StructuredDataType GetType() const;
+
+        size_t GetSize() const;
+
+        lldb::SBStructuredData GetValueForKey(const char *key) const;
+
+        lldb::SBStructuredData GetItemAtIndex(size_t idx) const;
+
+        uint64_t GetIntegerValue(uint64_t fail_value = 0) const;
+
+        double GetFloatValue(double fail_value = 0.0) const;
+
+        bool GetBooleanValue(bool fail_value = false) const;
+
+        size_t GetStringValue(char *dst, size_t dst_len) const;
+
         lldb::SBError
         GetAsJSON(lldb::SBStream &stream) const;
 
         lldb::SBError
         GetDescription(lldb::SBStream &stream) const;
 
         lldb::SBError
         SetFromJSON(lldb::SBStream &stream);
     };
 }

source/API/SBStructuredData.cpp

 SBStructuredData::SBStructuredData() : m_impl_up(new StructuredDataImpl()) {}
 
 SBStructuredData::SBStructuredData(const lldb::SBStructuredData &rhs)
     : m_impl_up(new StructuredDataImpl(*rhs.m_impl_up.get())) {}
 
 SBStructuredData::SBStructuredData(const lldb::EventSP &event_sp)
     : m_impl_up(new StructuredDataImpl(event_sp)) {}
 
 SBStructuredData::~SBStructuredData() {}
 
 SBStructuredData &SBStructuredData::
 operator=(const lldb::SBStructuredData &rhs) {
   *m_impl_up = *rhs.m_impl_up;
   return *this;
 }
 
 lldb::SBError SBStructuredData::SetFromJSON(lldb::SBStream &stream) {
   lldb::SBError error;
   std::string json_str(stream.GetData());
 
   StructuredData::ObjectSP json_obj = StructuredData::ParseJSON(json_str);
   m_impl_up->SetObjectSP(json_obj);
 
-  if (!json_obj || json_obj->GetType() != StructuredData::Type::eTypeDictionary)
+  if (!json_obj ||
+      json_obj->GetType() != StructuredDataType::eStructuredDataTypeDictionary)
     error.SetErrorString("Invalid Syntax");
   return error;
 }
 
 bool SBStructuredData::IsValid() const { return m_impl_up->IsValid(); }
 
 void SBStructuredData::Clear() { m_impl_up->Clear(); }
 
 SBError SBStructuredData::GetAsJSON(lldb::SBStream &stream) const {
   SBError error;
   error.SetError(m_impl_up->GetAsJSON(stream.ref()));
   return error;
 }
 
 lldb::SBError SBStructuredData::GetDescription(lldb::SBStream &stream) const {
   Status error = m_impl_up->GetDescription(stream.ref());
   SBError sb_error;
   sb_error.SetError(error);
   return sb_error;
 }
+
+StructuredDataType SBStructuredData::GetType() const {
+  return (m_impl_up ? m_impl_up->GetType()
+                    : StructuredDataType::eStructuredDataTypeInvalid);
+}
+
+size_t SBStructuredData::GetSize() const {
+  return (m_impl_up ? m_impl_up->GetSize() : 0);
+}
+
+lldb::SBStructuredData SBStructuredData::GetValueForKey(const char *key) const {
+  if (!m_impl_up)
+    return SBStructuredData();
+
+  SBStructuredData result;
+  result.m_impl_up->SetObjectSP(m_impl_up->GetValueForKey(key));
+  return result;
+}
+
+lldb::SBStructuredData SBStructuredData::GetItemAtIndex(size_t idx) const {
+  if (!m_impl_up)
+    return SBStructuredData();
+
+  SBStructuredData result;
+  result.m_impl_up->SetObjectSP(m_impl_up->GetItemAtIndex(idx));
+  return result;
+}
+
+uint64_t SBStructuredData::GetIntegerValue(uint64_t fail_value) const {
+  return (m_impl_up ? m_impl_up->GetIntegerValue(fail_value) : fail_value);
+}
+
+double SBStructuredData::GetFloatValue(double fail_value) const {
+  return (m_impl_up ? m_impl_up->GetFloatValue(fail_value) : fail_value);
+}
+
+bool SBStructuredData::GetBooleanValue(bool fail_value) const {
+  return (m_impl_up ? m_impl_up->GetBooleanValue(fail_value) : fail_value);
+}
+
+size_t SBStructuredData::GetStringValue(char *dst, size_t dst_len) const {
+  return (m_impl_up ? m_impl_up->GetStringValue(dst, dst_len) : 0);
+}

source/API/SBThread.cpp

 #include "lldb/API/SBAddress.h"
 #include "lldb/API/SBDebugger.h"
 #include "lldb/API/SBEvent.h"
 #include "lldb/API/SBFrame.h"
 #include "lldb/API/SBProcess.h"
 #include "lldb/API/SBThreadCollection.h"
 #include "lldb/API/SBThreadPlan.h"
 #include "lldb/API/SBValue.h"
+#include "lldb/lldb-enumerations.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 const char *SBThread::GetBroadcasterClassName() {
   return Thread::GetStaticBroadcasterClass().AsCString();
 }
 
if (exe_ctx.HasThreadScope()) {
     Process::StopLocker stop_locker;
     if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) {
       Thread *thread = exe_ctx.GetThreadPtr();
       StructuredData::ObjectSP info_root_sp = thread->GetExtendedInfo();
       if (info_root_sp) {
         StructuredData::ObjectSP node =
             info_root_sp->GetObjectForDotSeparatedPath(path);
         if (node) {
-          if (node->GetType() == StructuredData::Type::eTypeString) {
+          if (node->GetType() ==
+              StructuredDataType::eStructuredDataTypeString) {
             strm.Printf("%s", node->GetAsString()->GetValue().str().c_str());
             success = true;
           }
-          if (node->GetType() == StructuredData::Type::eTypeInteger) {
+          if (node->GetType() ==
+              StructuredDataType::eStructuredDataTypeInteger) {
             strm.Printf("0x%" PRIx64, node->GetAsInteger()->GetValue());
             success = true;
           }
-          if (node->GetType() == StructuredData::Type::eTypeFloat) {
+          if (node->GetType() == StructuredDataType::eStructuredDataTypeFloat) {
             strm.Printf("0x%f", node->GetAsFloat()->GetValue());
             success = true;
           }
-          if (node->GetType() == StructuredData::Type::eTypeBoolean) {
+          if (node->GetType() ==
+              StructuredDataType::eStructuredDataTypeBoolean) {
             if (node->GetAsBoolean()->GetValue() == true)
               strm.Printf("true");
             else
               strm.Printf("false");
             success = true;
           }
-          if (node->GetType() == StructuredData::Type::eTypeNull) {
+          if (node->GetType() == StructuredDataType::eStructuredDataTypeNull) {
             strm.Printf("null");
             success = true;
           }
         }
       }
     } else {
       if (log)
         log->Printf("SBThread(%p)::GetInfoItemByPathAsString() => error: "

source/Core/FormatEntity.cpp

static bool FormatThreadExtendedInfoRecurse(
     const StructuredData::ObjectSP &thread_info_dictionary,
     const SymbolContext *sc, const ExecutionContext *exe_ctx, Stream &s) {
   llvm::StringRef path(entry.string);
 
   StructuredData::ObjectSP value =
       thread_info_dictionary->GetObjectForDotSeparatedPath(path);
 
   if (value) {
-    if (value->GetType() == StructuredData::Type::eTypeInteger) {
+    if (value->GetType() == StructuredDataType::eStructuredDataTypeInteger) {
       const char *token_format = "0x%4.4" PRIx64;
       if (!entry.printf_format.empty())
         token_format = entry.printf_format.c_str();
       s.Printf(token_format, value->GetAsInteger()->GetValue());
       return true;
-    } else if (value->GetType() == StructuredData::Type::eTypeFloat) {
+    } else if (value->GetType() ==
+               StructuredDataType::eStructuredDataTypeFloat) {
       s.Printf("%f", value->GetAsFloat()->GetValue());
       return true;
-    } else if (value->GetType() == StructuredData::Type::eTypeString) {
+    } else if (value->GetType() ==
+               StructuredDataType::eStructuredDataTypeString) {
       s.Format("{0}", value->GetAsString()->GetValue());
       return true;
-    } else if (value->GetType() == StructuredData::Type::eTypeArray) {
+    } else if (value->GetType() ==
+               StructuredDataType::eStructuredDataTypeArray) {
       if (value->GetAsArray()->GetSize() > 0) {
         s.Printf("%zu", value->GetAsArray()->GetSize());
         return true;
       }
-    } else if (value->GetType() == StructuredData::Type::eTypeDictionary) {
+    } else if (value->GetType() ==
+               StructuredDataType::eStructuredDataTypeDictionary) {
       s.Printf("%zu",
                value->GetAsDictionary()->GetKeys()->GetAsArray()->GetSize());
       return true;
     }
   }
 
   return false;
 }
case Entry::Type::ScriptThread:
     return false;
 
   case Entry::Type::ThreadInfo:
     if (exe_ctx) {
       Thread *thread = exe_ctx->GetThreadPtr();
       if (thread) {
         StructuredData::ObjectSP object_sp = thread->GetExtendedInfo();
         if (object_sp &&
-            object_sp->GetType() == StructuredData::Type::eTypeDictionary) {
+            object_sp->GetType() ==
+                StructuredDataType::eStructuredDataTypeDictionary) {
           if (FormatThreadExtendedInfoRecurse(entry, object_sp, sc, exe_ctx, s))
             return true;
         }
       }
     }
     return false;
 
   case Entry::Type::TargetArch:

source/Core/StructuredData.cpp

 StructuredData::ObjectSP StructuredData::ParseJSON(std::string json_text) {
   JSONParser json_parser(json_text.c_str());
   StructuredData::ObjectSP object_sp = ParseJSONValue(json_parser);
   return object_sp;
 }
 
 StructuredData::ObjectSP
 StructuredData::Object::GetObjectForDotSeparatedPath(llvm::StringRef path) {
-  if (this->GetType() == Type::eTypeDictionary) {
+  if (this->GetType() ==
+      lldb::StructuredDataType::eStructuredDataTypeDictionary) {
     std::pair<llvm::StringRef, llvm::StringRef> match = path.split('.');
     std::string key = match.first.str();
     ObjectSP value = this->GetAsDictionary()->GetValueForKey(key);
     if (value.get()) {
       // Do we have additional words to descend?  If not, return the
       // value we're at right now.
       if (match.second.empty()) {
         return value;
       } else {
         return value->GetObjectForDotSeparatedPath(match.second);
       }
     }
     return ObjectSP();
   }
 
-  if (this->GetType() == Type::eTypeArray) {
+  if (this->GetType() == lldb::StructuredDataType::eStructuredDataTypeArray) {
     std::pair<llvm::StringRef, llvm::StringRef> match = path.split('[');
     if (match.second.size() == 0) {
       return this->shared_from_this();
     }
     errno = 0;
     uint64_t val = strtoul(match.second.str().c_str(), NULL, 10);
     if (errno == 0) {
       return this->GetAsArray()->GetItemAtIndex(val);

source/Target/Thread.cpp

 #include "lldb/Target/ThreadPlanStepThrough.h"
 #include "lldb/Target/ThreadPlanStepUntil.h"
 #include "lldb/Target/ThreadSpec.h"
 #include "lldb/Target/Unwind.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/RegularExpression.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/Utility/StreamString.h"
+#include "lldb/lldb-enumerations.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 const ThreadPropertiesSP &Thread::GetGlobalProperties() {
   // NOTE: intentional leak so we don't crash if global destructor chain gets
   // called as other threads still use the result of this function
   static ThreadPropertiesSP *g_settings_sp_ptr =
lldb::StopInfoSP Thread::GetStopInfo() {
 
   bool have_valid_stop_info = m_stop_info_sp &&
       m_stop_info_sp ->IsValid() &&
       m_stop_info_stop_id == stop_id;
   bool have_valid_completed_plan = completed_plan_sp && completed_plan_sp->PlanSucceeded();
   bool plan_overrides_trace =
     have_valid_stop_info && have_valid_completed_plan
     && (m_stop_info_sp->GetStopReason() == eStopReasonTrace);
-    
   if (have_valid_stop_info && !plan_overrides_trace) {
     return m_stop_info_sp;
   } else if (have_valid_completed_plan) {
     return StopInfo::CreateStopReasonWithPlan(
         completed_plan_sp, GetReturnValueObject(), GetExpressionVariable());
   } else {
     GetPrivateStopInfo();
     return m_stop_info_sp;
if (!saved_state.register_backup_sp)
     return false;
 
   saved_state.stop_info_sp = GetStopInfo();
   ProcessSP process_sp(GetProcess());
   if (process_sp)
     saved_state.orig_stop_id = process_sp->GetStopID();
   saved_state.current_inlined_depth = GetCurrentInlinedDepth();
   saved_state.m_completed_plan_stack = m_completed_plan_stack;
-  
   return true;
 }
 
 bool Thread::RestoreRegisterStateFromCheckpoint(
     ThreadStateCheckpoint &saved_state) {
   if (saved_state.register_backup_sp) {
     lldb::StackFrameSP frame_sp(GetStackFrameAtIndex(0));
     if (frame_sp) {
if (thread_info) {
     StructuredData::ObjectSP activity =
         thread_info->GetObjectForDotSeparatedPath("activity");
     StructuredData::ObjectSP breadcrumb =
         thread_info->GetObjectForDotSeparatedPath("breadcrumb");
     StructuredData::ObjectSP messages =
         thread_info->GetObjectForDotSeparatedPath("trace_messages");
 
     bool printed_activity = false;
-    if (activity &&
-        activity->GetType() == StructuredData::Type::eTypeDictionary) {
+    if (activity && activity->GetType() ==
+                        StructuredDataType::eStructuredDataTypeDictionary) {
       StructuredData::Dictionary *activity_dict = activity->GetAsDictionary();
       StructuredData::ObjectSP id = activity_dict->GetValueForKey("id");
       StructuredData::ObjectSP name = activity_dict->GetValueForKey("name");
-      if (name && name->GetType() == StructuredData::Type::eTypeString && id &&
-          id->GetType() == StructuredData::Type::eTypeInteger) {
+      if (name &&
+          name->GetType() == StructuredDataType::eStructuredDataTypeString &&
+          id &&
+          id->GetType() == StructuredDataType::eStructuredDataTypeInteger) {
         strm.Format("  Activity '{0}', {1:x}\n",
                     name->GetAsString()->GetValue(),
                     id->GetAsInteger()->GetValue());
       }
       printed_activity = true;
     }
     bool printed_breadcrumb = false;
-    if (breadcrumb &&
-        breadcrumb->GetType() == StructuredData::Type::eTypeDictionary) {
+    if (breadcrumb && breadcrumb->GetType() ==
+                          StructuredDataType::eStructuredDataTypeDictionary) {
       if (printed_activity)
         strm.Printf("\n");
       StructuredData::Dictionary *breadcrumb_dict =
           breadcrumb->GetAsDictionary();
       StructuredData::ObjectSP breadcrumb_text =
           breadcrumb_dict->GetValueForKey("name");
       if (breadcrumb_text &&
-          breadcrumb_text->GetType() == StructuredData::Type::eTypeString) {
+          breadcrumb_text->GetType() ==
+              StructuredDataType::eStructuredDataTypeString) {
         strm.Format("  Current Breadcrumb: {0}\n",
                     breadcrumb_text->GetAsString()->GetValue());
       }
       printed_breadcrumb = true;
     }
-    if (messages && messages->GetType() == StructuredData::Type::eTypeArray) {
+    if (messages &&
+        messages->GetType() == StructuredDataType::eStructuredDataTypeArray) {
       if (printed_breadcrumb)
         strm.Printf("\n");
       StructuredData::Array *messages_array = messages->GetAsArray();
       const size_t msg_count = messages_array->GetSize();
       if (msg_count > 0) {
         strm.Printf("  %zu trace messages:\n", msg_count);
         for (size_t i = 0; i < msg_count; i++) {
           StructuredData::ObjectSP message = messages_array->GetItemAtIndex(i);
           if (message &&
-              message->GetType() == StructuredData::Type::eTypeDictionary) {
+              message->GetType() ==
+                  StructuredDataType::eStructuredDataTypeDictionary) {
             StructuredData::Dictionary *message_dict =
                 message->GetAsDictionary();
             StructuredData::ObjectSP message_text =
                 message_dict->GetValueForKey("message");
             if (message_text &&
-                message_text->GetType() == StructuredData::Type::eTypeString) {
+                message_text->GetType() ==
+                    StructuredDataType::eStructuredDataTypeString) {
               strm.Format("    {0}\n", message_text->GetAsString()->GetValue());
             }
           }
         }
       }
     }
   }
 

unittests/ScriptInterpreter/Python/PythonDataObjectsTests.cpp

 #include "Plugins/ScriptInterpreter/Python/lldb-python.h"
 #include "gtest/gtest.h"
 
 #include "Plugins/ScriptInterpreter/Python/PythonDataObjects.h"
 #include "Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.h"
 #include "lldb/Host/File.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/HostInfo.h"
+#include "lldb/lldb-enumerations.h"
 
 #include "PythonTestSuite.h"
 
 using namespace lldb_private;
 
 class PythonDataObjectsTest : public PythonTestSuite {
 public:
   void SetUp() override {
TEST_F(PythonDataObjectsTest, TestPythonListToStructuredList) {
   static const long long_value0 = 5;
   static const char *const string_value1 = "String Index 1";
 
   PythonList list(PyInitialValue::Empty);
   list.AppendItem(PythonInteger(long_value0));
   list.AppendItem(PythonString(string_value1));
 
   auto array_sp = list.CreateStructuredArray();
-  EXPECT_EQ(StructuredData::Type::eTypeInteger,
+  EXPECT_EQ(lldb::StructuredDataType::eStructuredDataTypeInteger,
             array_sp->GetItemAtIndex(0)->GetType());
-  EXPECT_EQ(StructuredData::Type::eTypeString,
+  EXPECT_EQ(lldb::StructuredDataType::eStructuredDataTypeString,
             array_sp->GetItemAtIndex(1)->GetType());
 
   auto int_sp = array_sp->GetItemAtIndex(0)->GetAsInteger();
   auto string_sp = array_sp->GetItemAtIndex(1)->GetAsString();
 
   EXPECT_EQ(long_value0, long(int_sp->GetValue()));
   EXPECT_EQ(string_value1, string_sp->GetValue());
 }

 TEST_F(PythonDataObjectsTest, TestPythonTupleToStructuredList) {
   PythonInteger int_value(1);
   PythonString string_value("Test");
 
   PythonTuple tuple{int_value.get(), string_value.get()};
 
   auto array_sp = tuple.CreateStructuredArray();
   EXPECT_EQ(tuple.GetSize(), array_sp->GetSize());
-  EXPECT_EQ(StructuredData::Type::eTypeInteger,
+  EXPECT_EQ(lldb::StructuredDataType::eStructuredDataTypeInteger,
             array_sp->GetItemAtIndex(0)->GetType());
-  EXPECT_EQ(StructuredData::Type::eTypeString,
+  EXPECT_EQ(lldb::StructuredDataType::eStructuredDataTypeString,
             array_sp->GetItemAtIndex(1)->GetType());
 }
 
 TEST_F(PythonDataObjectsTest, TestPythonDictionaryValueEquality) {
   // Test that a dictionary which is built through the native
   // Python API behaves correctly when wrapped by a PythonDictionary.
   static const unsigned dict_entries = 2;
   const char *key_0 = "Key 0";