[Lldb-commits] [lldb] r250327 - Get Python unit tests working with Python 3.
Zachary Turner via lldb-commits
lldb-commits at lists.llvm.org
Wed Oct 14 14:06:13 PDT 2015
Author: zturner
Date: Wed Oct 14 16:06:13 2015
New Revision: 250327
URL: http://llvm.org/viewvc/llvm-project?rev=250327&view=rev
Log:
Get Python unit tests working with Python 3.
There were a couple of issues related to string handling that
needed to be fixed. In particular, we cannot get away with
converting `PyUnicode` objects to `PyBytes` objects and storing
the `PyBytes` regardless of Python version. Instead we have to
store a `PyUnicode` on Python 3 and a `PyString` on Python 2.
The reason for this is that if you call `PyObject_Str` on a
`PyBytes` in Python 3, it will return you a string that actually
contains the string value wrappedin the characters b''. So if we
create a `PythonString` with the value "test", and we call Str()
on it, we will get back the string "b'test'", which breaks string
equality. The only way to fix this is to store a native
`PyUnicode` object under Python 3.
With this CL, ScriptInterpreterPythonTests unit tests pass 100%
under Python 2 and Python 3.
Modified:
lldb/trunk/source/Plugins/ScriptInterpreter/Python/PythonDataObjects.cpp
lldb/trunk/unittests/ScriptInterpreter/Python/PythonDataObjectsTests.cpp
Modified: lldb/trunk/source/Plugins/ScriptInterpreter/Python/PythonDataObjects.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Plugins/ScriptInterpreter/Python/PythonDataObjects.cpp?rev=250327&r1=250326&r2=250327&view=diff
==============================================================================
--- lldb/trunk/source/Plugins/ScriptInterpreter/Python/PythonDataObjects.cpp (original)
+++ lldb/trunk/source/Plugins/ScriptInterpreter/Python/PythonDataObjects.cpp Wed Oct 14 16:06:13 2015
@@ -67,22 +67,14 @@ PythonObject::GetObjectType() const
if (!IsAllocated())
return PyObjectType::None;
- if (PyList_Check(m_py_obj))
+ if (PythonList::Check(m_py_obj))
return PyObjectType::List;
- if (PyDict_Check(m_py_obj))
+ if (PythonDictionary::Check(m_py_obj))
return PyObjectType::Dictionary;
- if (PyUnicode_Check(m_py_obj))
+ if (PythonString::Check(m_py_obj))
return PyObjectType::String;
- if (PyLong_Check(m_py_obj))
+ if (PythonInteger::Check(m_py_obj))
return PyObjectType::Integer;
-#if PY_MAJOR_VERSION < 3
- // These functions don't exist in Python 3.x. PyString is PyUnicode
- // and PyInt is PyLong.
- if (PyString_Check(m_py_obj))
- return PyObjectType::String;
- if (PyInt_Check(m_py_obj))
- return PyObjectType::Integer;
-#endif
return PyObjectType::Unknown;
}
@@ -187,11 +179,11 @@ PythonString::Check(PyObject *py_obj)
{
if (!py_obj)
return false;
+
#if PY_MAJOR_VERSION >= 3
- // Python 3 does not have PyString objects, only PyUnicode.
return PyUnicode_Check(py_obj);
#else
- return PyUnicode_Check(py_obj) || PyString_Check(py_obj);
+ return PyString_Check(py_obj);
#endif
}
@@ -208,18 +200,6 @@ PythonString::Reset(PyRefType type, PyOb
return;
}
- // Convert this to a PyBytes object, and only store the PyBytes. Note that in
- // Python 2.x, PyString and PyUnicode are interchangeable, and PyBytes is an alias
- // of PyString. So on 2.x, if we get into this branch, we already have a PyBytes.
- if (PyUnicode_Check(py_obj))
- {
- // Since we're converting this to a different object, we assume ownership of the
- // new object regardless of the value of `type`.
- result.Reset(PyRefType::Owned, PyUnicode_AsUTF8String(py_obj));
- }
-
- assert(PyBytes_Check(result.get()) && "PythonString::Reset received a non-string");
-
// Calling PythonObject::Reset(const PythonObject&) will lead to stack overflow since it calls
// back into the virtual implementation.
PythonObject::Reset(PyRefType::Borrowed, result.get());
@@ -228,21 +208,31 @@ PythonString::Reset(PyRefType type, PyOb
llvm::StringRef
PythonString::GetString() const
{
- if (IsValid())
- {
- Py_ssize_t size;
- char *c;
- PyBytes_AsStringAndSize(m_py_obj, &c, &size);
- return llvm::StringRef(c, size);
- }
- return llvm::StringRef();
+ if (!IsValid())
+ return llvm::StringRef();
+
+ Py_ssize_t size;
+ char *c;
+
+#if PY_MAJOR_VERSION >= 3
+ c = PyUnicode_AsUTF8AndSize(m_py_obj, &size);
+#else
+ PyString_AsStringAndSize(m_py_obj, &c, &size);
+#endif
+ return llvm::StringRef(c, size);
}
size_t
PythonString::GetSize() const
{
if (IsValid())
- return PyBytes_Size(m_py_obj);
+ {
+#if PY_MAJOR_VERSION >= 3
+ return PyUnicode_GetSize(m_py_obj);
+#else
+ return PyString_Size(m_py_obj);
+#endif
+ }
return 0;
}
@@ -251,11 +241,10 @@ PythonString::SetString (llvm::StringRef
{
#if PY_MAJOR_VERSION >= 3
PyObject *unicode = PyUnicode_FromStringAndSize(string.data(), string.size());
- PyObject *bytes = PyUnicode_AsUTF8String(unicode);
- PythonObject::Reset(PyRefType::Owned, bytes);
- Py_DECREF(unicode);
+ PythonObject::Reset(PyRefType::Owned, unicode);
#else
- PythonObject::Reset(PyRefType::Owned, PyString_FromStringAndSize(string.data(), string.size()));
+ PyObject *str = PyString_FromStringAndSize(string.data(), string.size());
+ PythonObject::Reset(PyRefType::Owned, str);
#endif
}
Modified: lldb/trunk/unittests/ScriptInterpreter/Python/PythonDataObjectsTests.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/unittests/ScriptInterpreter/Python/PythonDataObjectsTests.cpp?rev=250327&r1=250326&r2=250327&view=diff
==============================================================================
--- lldb/trunk/unittests/ScriptInterpreter/Python/PythonDataObjectsTests.cpp (original)
+++ lldb/trunk/unittests/ScriptInterpreter/Python/PythonDataObjectsTests.cpp Wed Oct 14 16:06:13 2015
@@ -49,21 +49,22 @@ class PythonDataObjectsTest : public tes
TEST_F(PythonDataObjectsTest, TestOwnedReferences)
{
- // After creating a new object, the refcount should be 1
+ // After creating a new object, the refcount should be >= 1
PyObject *obj = PyLong_FromLong(3);
- EXPECT_EQ(1, obj->ob_refcnt);
+ Py_ssize_t original_refcnt = obj->ob_refcnt;
+ EXPECT_LE(1, original_refcnt);
- // If we take an owned reference, the refcount should still be 1
+ // If we take an owned reference, the refcount should be the same
PythonObject owned_long(PyRefType::Owned, obj);
- EXPECT_EQ(1, owned_long.get()->ob_refcnt);
+ EXPECT_EQ(original_refcnt, owned_long.get()->ob_refcnt);
- // Take another reference and verify that the refcount increases
+ // Take another reference and verify that the refcount increases by 1
PythonObject strong_ref(owned_long);
- EXPECT_EQ(2, strong_ref.get()->ob_refcnt);
+ EXPECT_EQ(original_refcnt + 1, strong_ref.get()->ob_refcnt);
- // If we reset the first one, the refcount should be 1 again.
+ // If we reset the first one, the refcount should be the original value.
owned_long.Reset();
- EXPECT_EQ(1, strong_ref.get()->ob_refcnt);
+ EXPECT_EQ(original_refcnt, strong_ref.get()->ob_refcnt);
}
TEST_F(PythonDataObjectsTest, TestResetting)
@@ -86,10 +87,11 @@ TEST_F(PythonDataObjectsTest, TestResett
TEST_F(PythonDataObjectsTest, TestBorrowedReferences)
{
PythonInteger long_value(PyRefType::Owned, PyLong_FromLong(3));
- EXPECT_EQ(1, long_value.get()->ob_refcnt);
+ Py_ssize_t original_refcnt = long_value.get()->ob_refcnt;
+ EXPECT_LE(1, original_refcnt);
PythonInteger borrowed_long(PyRefType::Borrowed, long_value.get());
- EXPECT_EQ(2, borrowed_long.get()->ob_refcnt);
+ EXPECT_EQ(original_refcnt + 1, borrowed_long.get()->ob_refcnt);
}
TEST_F(PythonDataObjectsTest, TestPythonInteger)
@@ -107,7 +109,7 @@ TEST_F(PythonDataObjectsTest, TestPython
EXPECT_EQ(12, python_int.GetInteger());
#endif
- // Verify that `PythonInt` works correctly when given a PyLong object.
+ // Verify that `PythonInteger` works correctly when given a PyLong object.
PyObject *py_long = PyLong_FromLong(12);
EXPECT_TRUE(PythonInteger::Check(py_long));
PythonInteger python_long(PyRefType::Owned, py_long);
@@ -116,14 +118,20 @@ TEST_F(PythonDataObjectsTest, TestPython
// Verify that you can reset the value and that it is reflected properly.
python_long.SetInteger(40);
EXPECT_EQ(40, python_long.GetInteger());
+
+ // Test that creating a `PythonInteger` object works correctly with the
+ // int constructor.
+ PythonInteger constructed_int(7);
+ EXPECT_EQ(7, constructed_int.GetInteger());
}
TEST_F(PythonDataObjectsTest, TestPythonString)
{
// Test that strings behave correctly when wrapped by a PythonString.
- static const char *test_string = "PythonDataObjectsTest::TestPythonString";
- static const char *test_string2 = "PythonDataObjectsTest::TestPythonString";
+ static const char *test_string = "PythonDataObjectsTest::TestPythonString1";
+ static const char *test_string2 = "PythonDataObjectsTest::TestPythonString2";
+ static const char *test_string3 = "PythonDataObjectsTest::TestPythonString3";
#if PY_MAJOR_VERSION < 3
// Verify that `PythonString` works correctly when given a PyString object.
@@ -134,36 +142,66 @@ TEST_F(PythonDataObjectsTest, TestPython
EXPECT_EQ(PyObjectType::String, python_string.GetObjectType());
EXPECT_STREQ(test_string, python_string.GetString().data());
-#endif
-
+#else
// Verify that `PythonString` works correctly when given a PyUnicode object.
PyObject *py_unicode = PyUnicode_FromString(test_string);
EXPECT_TRUE(PythonString::Check(py_unicode));
PythonString python_unicode(PyRefType::Owned, py_unicode);
-
EXPECT_EQ(PyObjectType::String, python_unicode.GetObjectType());
EXPECT_STREQ(test_string, python_unicode.GetString().data());
+#endif
- // Verify that you can reset the value and that it is reflected properly.
- python_unicode.SetString(test_string2);
- EXPECT_STREQ(test_string2, python_unicode.GetString().data());
+ // Test that creating a `PythonString` object works correctly with the
+ // string constructor
+ PythonString constructed_string(test_string3);
+ EXPECT_STREQ(test_string3, constructed_string.GetString().str().c_str());
}
-TEST_F(PythonDataObjectsTest, TestPythonListPrebuilt)
+TEST_F(PythonDataObjectsTest, TestPythonStringToStr)
+{
+ const char *c_str = "PythonDataObjectsTest::TestPythonStringToStr";
+
+ PythonString str(c_str);
+ EXPECT_STREQ(c_str, str.GetString().str().c_str());
+
+ PythonString str_str = str.Str();
+ EXPECT_STREQ(c_str, str_str.GetString().str().c_str());
+}
+
+TEST_F(PythonDataObjectsTest, TestPythonIntegerToStr)
+{
+}
+
+TEST_F(PythonDataObjectsTest, TestPythonIntegerToStructuredInteger)
+{
+ PythonInteger integer(7);
+ auto int_sp = integer.CreateStructuredInteger();
+ EXPECT_EQ(7, int_sp->GetValue());
+}
+
+TEST_F(PythonDataObjectsTest, TestPythonStringToStructuredString)
+{
+ static const char *test_string = "PythonDataObjectsTest::TestPythonStringToStructuredString";
+ PythonString constructed_string(test_string);
+ auto string_sp = constructed_string.CreateStructuredString();
+ EXPECT_STREQ(test_string, string_sp->GetStringValue().c_str());
+}
+
+TEST_F(PythonDataObjectsTest, TestPythonListValueEquality)
{
// Test that a list which is built through the native
// Python API behaves correctly when wrapped by a PythonList.
static const int list_size = 2;
- static const long long_idx0 = 5;
- static const char *const string_idx1 = "String Index 1";
+ static const long long_value0 = 5;
+ static const char *const string_value1 = "String Index 1";
PyObject *py_list = PyList_New(2);
EXPECT_TRUE(PythonList::Check(py_list));
PythonList list(PyRefType::Owned, py_list);
PythonObject list_items[list_size];
- list_items[0].Reset(PyRefType::Owned, PyLong_FromLong(long_idx0));
- list_items[1].Reset(PyRefType::Owned, PyString_FromString(string_idx1));
+ list_items[0].Reset(PythonInteger(long_value0));
+ list_items[1].Reset(PythonString(string_value1));
for (int i = 0; i < list_size; ++i)
list.SetItemAtIndex(i, list_items[i]);
@@ -171,64 +209,106 @@ TEST_F(PythonDataObjectsTest, TestPython
EXPECT_EQ(list_size, list.GetSize());
EXPECT_EQ(PyObjectType::List, list.GetObjectType());
- // PythonList doesn't yet support getting objects by type.
- // For now, we have to call CreateStructuredArray and use
- // those objects. That will be in a different test.
- // TODO: Add the ability for GetItemByIndex() to return a
- // typed object.
+ // Verify that the values match
+ PythonObject chk_value1 = list.GetItemAtIndex(0);
+ PythonObject chk_value2 = list.GetItemAtIndex(1);
+ EXPECT_TRUE(PythonInteger::Check(chk_value1.get()));
+ EXPECT_TRUE(PythonString::Check(chk_value2.get()));
+
+ PythonInteger chk_int(PyRefType::Borrowed, chk_value1.get());
+ PythonString chk_str(PyRefType::Borrowed, chk_value2.get());
+
+ EXPECT_EQ(long_value0, chk_int.GetInteger());
+ EXPECT_STREQ(string_value1, chk_str.GetString().str().c_str());
+}
+
+TEST_F(PythonDataObjectsTest, TestPythonListManipulation)
+{
+ // Test that manipulation of a PythonList behaves correctly when
+ // wrapped by a PythonDictionary.
+
+ static const long long_value0 = 5;
+ static const char *const string_value1 = "String Index 1";
+
+ PythonList list(PyInitialValue::Empty);
+ PythonInteger integer(long_value0);
+ PythonString string(string_value1);
+
+ list.AppendItem(integer);
+ list.AppendItem(string);
+ EXPECT_EQ(2, list.GetSize());
+
+ // Verify that the values match
+ PythonObject chk_value1 = list.GetItemAtIndex(0);
+ PythonObject chk_value2 = list.GetItemAtIndex(1);
+ EXPECT_TRUE(PythonInteger::Check(chk_value1.get()));
+ EXPECT_TRUE(PythonString::Check(chk_value2.get()));
+
+ PythonInteger chk_int(PyRefType::Borrowed, chk_value1.get());
+ PythonString chk_str(PyRefType::Borrowed, chk_value2.get());
+
+ EXPECT_EQ(long_value0, chk_int.GetInteger());
+ EXPECT_STREQ(string_value1, chk_str.GetString().str().c_str());
}
-TEST_F(PythonDataObjectsTest, TestPythonDictionaryPrebuilt)
+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, array_sp->GetItemAtIndex(0)->GetType());
+ EXPECT_EQ(StructuredData::Type::eTypeString, 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, int_sp->GetValue());
+ EXPECT_STREQ(string_value1, string_sp->GetValue().c_str());
+}
+
+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 int dict_entries = 2;
-
- PythonObject keys[dict_entries];
- PythonObject values[dict_entries];
-
- keys[0].Reset(PyRefType::Owned, PyString_FromString("Key 0"));
- keys[1].Reset(PyRefType::Owned, PyLong_FromLong(1));
- values[0].Reset(PyRefType::Owned, PyLong_FromLong(0));
- values[1].Reset(PyRefType::Owned, PyString_FromString("Value 1"));
+ const char *key_0 = "Key 0";
+ int key_1 = 1;
+ const int value_0 = 0;
+ const char *value_1 = "Value 1";
+
+ PythonObject py_keys[dict_entries];
+ PythonObject py_values[dict_entries];
+
+ py_keys[0].Reset(PythonString(key_0));
+ py_keys[1].Reset(PythonInteger(key_1));
+ py_values[0].Reset(PythonInteger(value_0));
+ py_values[1].Reset(PythonString(value_1));
PyObject *py_dict = PyDict_New();
EXPECT_TRUE(PythonDictionary::Check(py_dict));
PythonDictionary dict(PyRefType::Owned, py_dict);
for (int i = 0; i < dict_entries; ++i)
- PyDict_SetItem(py_dict, keys[i].get(), values[i].get());
+ PyDict_SetItem(py_dict, py_keys[i].get(), py_values[i].get());
EXPECT_EQ(dict.GetSize(), dict_entries);
EXPECT_EQ(PyObjectType::Dictionary, dict.GetObjectType());
- // PythonDictionary doesn't yet support getting objects by type.
- // For now, we have to call CreateStructuredDictionary and use
- // those objects. That will be in a different test.
- // TODO: Add the ability for GetItemByKey() to return a
- // typed object.
-}
+ // Verify that the values match
+ PythonObject chk_value1 = dict.GetItemForKey(py_keys[0]);
+ PythonObject chk_value2 = dict.GetItemForKey(py_keys[1]);
+ EXPECT_TRUE(PythonInteger::Check(chk_value1.get()));
+ EXPECT_TRUE(PythonString::Check(chk_value2.get()));
-TEST_F(PythonDataObjectsTest, TestPythonListManipulation)
-{
- // Test that manipulation of a PythonList behaves correctly when
- // wrapped by a PythonDictionary.
+ PythonInteger chk_int(PyRefType::Borrowed, chk_value1.get());
+ PythonString chk_str(PyRefType::Borrowed, chk_value2.get());
- static const long long_idx0 = 5;
- static const char *const string_idx1 = "String Index 1";
-
- PythonList list(PyInitialValue::Empty);
- PythonInteger integer(long_idx0);
- PythonString string(string_idx1);
-
- list.AppendItem(integer);
- list.AppendItem(string);
- EXPECT_EQ(2, list.GetSize());
-
- // PythonList doesn't yet support getting typed objects out, so we
- // can't easily test that the first item is an integer with the correct
- // value, etc.
- // TODO: Add the ability for GetItemByIndex() to return a
- // typed object.
+ EXPECT_EQ(value_0, chk_int.GetInteger());
+ EXPECT_STREQ(value_1, chk_str.GetString().str().c_str());
}
TEST_F(PythonDataObjectsTest, TestPythonDictionaryManipulation)
@@ -237,13 +317,18 @@ TEST_F(PythonDataObjectsTest, TestPython
// by a PythonDictionary.
static const int dict_entries = 2;
+ const char *const key_0 = "Key 0";
+ const char *const key_1 = "Key 1";
+ const long value_0 = 1;
+ const char *const value_1 = "Value 1";
+
PythonString keys[dict_entries];
PythonObject values[dict_entries];
- keys[0].Reset(PyRefType::Owned, PyString_FromString("Key 0"));
- keys[1].Reset(PyRefType::Owned, PyString_FromString("Key 1"));
- values[0].Reset(PyRefType::Owned, PyLong_FromLong(1));
- values[1].Reset(PyRefType::Owned, PyString_FromString("Value 1"));
+ keys[0].Reset(PythonString(key_0));
+ keys[1].Reset(PythonString(key_1));
+ values[0].Reset(PythonInteger(value_0));
+ values[1].Reset(PythonString(value_1));
PythonDictionary dict(PyInitialValue::Empty);
for (int i = 0; i < 2; ++i)
@@ -251,212 +336,40 @@ TEST_F(PythonDataObjectsTest, TestPython
EXPECT_EQ(dict_entries, dict.GetSize());
- // PythonDictionary doesn't yet support getting objects by type.
- // For now, we have to call CreateStructuredDictionary and use
- // those objects. That will be in a different test.
- // TODO: Add the ability for GetItemByKey() to return a
- // typed object.
-}
-
-TEST_F(PythonDataObjectsTest, TestPythonListToStructuredObject)
-{
- // Test that a PythonList is properly converted to a StructuredArray.
- // This includes verifying that a list can contain a nested list as
- // well as a nested dictionary.
-
- static const int item_count = 4;
- static const long long_idx0 = 5;
- static const char *const string_idx1 = "String Index 1";
-
- static const long nested_list_long_idx0 = 6;
- static const char *const nested_list_str_idx1 = "Nested String Index 1";
-
- static const char *const nested_dict_key0 = "Nested Key 0";
- static const char *const nested_dict_value0 = "Nested Value 0";
- static const char *const nested_dict_key1 = "Nested Key 1";
- static const long nested_dict_value1 = 2;
-
- PythonList list(PyInitialValue::Empty);
- PythonList nested_list(PyInitialValue::Empty);
- PythonDictionary nested_dict(PyInitialValue::Empty);
-
- nested_list.AppendItem(PythonInteger(nested_list_long_idx0));
- nested_list.AppendItem(PythonString(nested_list_str_idx1));
- nested_dict.SetItemForKey(PythonString(nested_dict_key0), PythonString(nested_dict_value0));
- nested_dict.SetItemForKey(PythonString(nested_dict_key1), PythonInteger(nested_dict_value1));
-
- list.AppendItem(PythonInteger(long_idx0));
- list.AppendItem(PythonString(string_idx1));
- list.AppendItem(nested_list);
- list.AppendItem(nested_dict);
-
- EXPECT_EQ(item_count, list.GetSize());
+ // Verify that the keys and values match
+ PythonObject chk_value1 = dict.GetItemForKey(keys[0]);
+ PythonObject chk_value2 = dict.GetItemForKey(keys[1]);
+ EXPECT_TRUE(PythonInteger::Check(chk_value1.get()));
+ EXPECT_TRUE(PythonString::Check(chk_value2.get()));
- StructuredData::ArraySP array_sp = list.CreateStructuredArray();
- EXPECT_EQ(list.GetSize(), array_sp->GetSize());
- EXPECT_EQ(StructuredData::Type::eTypeInteger, array_sp->GetItemAtIndex(0)->GetType());
- EXPECT_EQ(StructuredData::Type::eTypeString, array_sp->GetItemAtIndex(1)->GetType());
- EXPECT_EQ(StructuredData::Type::eTypeArray, array_sp->GetItemAtIndex(2)->GetType());
- EXPECT_EQ(StructuredData::Type::eTypeDictionary, array_sp->GetItemAtIndex(3)->GetType());
+ PythonInteger chk_int(PyRefType::Borrowed, chk_value1.get());
+ PythonString chk_str(PyRefType::Borrowed, chk_value2.get());
- auto list_int_sp = std::static_pointer_cast<StructuredData::Integer>(array_sp->GetItemAtIndex(0));
- auto list_str_sp = std::static_pointer_cast<StructuredData::String>(array_sp->GetItemAtIndex(1));
- auto list_list_sp = std::static_pointer_cast<StructuredData::Array>(array_sp->GetItemAtIndex(2));
- auto list_dict_sp = std::static_pointer_cast<StructuredData::Dictionary>(array_sp->GetItemAtIndex(3));
-
- // Verify that the first item (long) has the correct value
- EXPECT_EQ(long_idx0, list_int_sp->GetValue());
-
- // Verify that the second item (string) has the correct value
- EXPECT_STREQ(string_idx1, list_str_sp->GetValue().c_str());
-
- // Verify that the third item is a list with the correct length and element types
- EXPECT_EQ(nested_list.GetSize(), list_list_sp->GetSize());
- EXPECT_EQ(StructuredData::Type::eTypeInteger, list_list_sp->GetItemAtIndex(0)->GetType());
- EXPECT_EQ(StructuredData::Type::eTypeString, list_list_sp->GetItemAtIndex(1)->GetType());
- // Verify that the values of each element in the list are correct
- auto nested_list_value_0 = std::static_pointer_cast<StructuredData::Integer>(list_list_sp->GetItemAtIndex(0));
- auto nested_list_value_1 = std::static_pointer_cast<StructuredData::String>(list_list_sp->GetItemAtIndex(1));
- EXPECT_EQ(nested_list_long_idx0, nested_list_value_0->GetValue());
- EXPECT_STREQ(nested_list_str_idx1, nested_list_value_1->GetValue().c_str());
-
- // Verify that the fourth item is a dictionary with the correct length
- EXPECT_EQ(nested_dict.GetSize(), list_dict_sp->GetSize());
- auto dict_keys = std::static_pointer_cast<StructuredData::Array>(list_dict_sp->GetKeys());
-
- // Verify that all of the keys match the values and types of keys we inserted
- EXPECT_EQ(StructuredData::Type::eTypeString, dict_keys->GetItemAtIndex(0)->GetType());
- EXPECT_EQ(StructuredData::Type::eTypeString, dict_keys->GetItemAtIndex(1)->GetType());
- auto nested_key_0 = std::static_pointer_cast<StructuredData::String>(dict_keys->GetItemAtIndex(0));
- auto nested_key_1 = std::static_pointer_cast<StructuredData::String>(dict_keys->GetItemAtIndex(1));
- EXPECT_STREQ(nested_dict_key0, nested_key_0->GetValue().c_str());
- EXPECT_STREQ(nested_dict_key1, nested_key_1->GetValue().c_str());
-
- // Verify that for each key, the value has the correct type and value as what we inserted.
- auto nested_dict_value_0 = list_dict_sp->GetValueForKey(nested_key_0->GetValue());
- auto nested_dict_value_1 = list_dict_sp->GetValueForKey(nested_key_1->GetValue());
- EXPECT_EQ(StructuredData::Type::eTypeString, nested_dict_value_0->GetType());
- EXPECT_EQ(StructuredData::Type::eTypeInteger, nested_dict_value_1->GetType());
- auto nested_dict_str_value_0 = std::static_pointer_cast<StructuredData::String>(nested_dict_value_0);
- auto nested_dict_int_value_1 = std::static_pointer_cast<StructuredData::Integer>(nested_dict_value_1);
- EXPECT_STREQ(nested_dict_value0, nested_dict_str_value_0->GetValue().c_str());
- EXPECT_EQ(nested_dict_value1, nested_dict_int_value_1->GetValue());
-}
-
-TEST_F(PythonDataObjectsTest, TestPythonDictionaryToStructuredObject)
-{
- // Test that a PythonDictionary is properly converted to a
- // StructuredDictionary. This includes verifying that a dictionary
- // can contain a nested dictionary as well as a nested list.
-
- static const int dict_item_count = 4;
- static const char *const dict_keys[dict_item_count] = {"Key 0 (str)", "Key 1 (long)", "Key 2 (dict)",
- "Key 3 (list)"};
-
- static const StructuredData::Type dict_value_types[dict_item_count] = {
- StructuredData::Type::eTypeString, StructuredData::Type::eTypeInteger, StructuredData::Type::eTypeDictionary,
- StructuredData::Type::eTypeArray};
-
- static const char *const nested_dict_keys[2] = {"Nested Key 0 (str)", "Nested Key 1 (long)"};
-
- static const StructuredData::Type nested_dict_value_types[2] = {
- StructuredData::Type::eTypeString, StructuredData::Type::eTypeInteger,
- };
-
- static const StructuredData::Type nested_list_value_types[2] = {StructuredData::Type::eTypeInteger,
- StructuredData::Type::eTypeString};
-
- static const char *const dict_value0 = "Value 0";
- static const long dict_value1 = 2;
+ EXPECT_EQ(value_0, chk_int.GetInteger());
+ EXPECT_STREQ(value_1, chk_str.GetString().str().c_str());
+}
- static const long nested_list_value0 = 5;
- static const char *const nested_list_value1 = "Nested list string";
+TEST_F(PythonDataObjectsTest, TestPythonDictionaryToStructuredDictionary)
+{
+ static const char *const string_key0 = "String Key 0";
+ static const char *const string_key1 = "String Key 1";
- static const char *const nested_dict_value0 = "Nested Dict Value 0";
- static const long nested_dict_value1 = 7;
+ static const char *const string_value0 = "String Value 0";
+ static const long int_value1 = 7;
PythonDictionary dict(PyInitialValue::Empty);
- PythonDictionary nested_dict(PyInitialValue::Empty);
- PythonList nested_list(PyInitialValue::Empty);
+ dict.SetItemForKey(PythonString(string_key0), PythonString(string_value0));
+ dict.SetItemForKey(PythonString(string_key1), PythonInteger(int_value1));
+
+ auto dict_sp = dict.CreateStructuredDictionary();
+ EXPECT_EQ(2, dict_sp->GetSize());
- nested_dict.SetItemForKey(PythonString(nested_dict_keys[0]), PythonString(nested_dict_value0));
- nested_dict.SetItemForKey(PythonString(nested_dict_keys[1]), PythonInteger(nested_dict_value1));
+ EXPECT_TRUE(dict_sp->HasKey(string_key0));
+ EXPECT_TRUE(dict_sp->HasKey(string_key1));
- nested_list.AppendItem(PythonInteger(nested_list_value0));
- nested_list.AppendItem(PythonString(nested_list_value1));
+ auto string_sp = dict_sp->GetValueForKey(string_key0)->GetAsString();
+ auto int_sp = dict_sp->GetValueForKey(string_key1)->GetAsInteger();
- dict.SetItemForKey(PythonString(dict_keys[0]), PythonString(dict_value0));
- dict.SetItemForKey(PythonString(dict_keys[1]), PythonInteger(dict_value1));
- dict.SetItemForKey(PythonString(dict_keys[2]), nested_dict);
- dict.SetItemForKey(PythonString(dict_keys[3]), nested_list);
-
- StructuredData::DictionarySP dict_sp = dict.CreateStructuredDictionary();
- EXPECT_EQ(dict_item_count, dict_sp->GetSize());
- auto dict_keys_array = std::static_pointer_cast<StructuredData::Array>(dict_sp->GetKeys());
-
- std::vector<StructuredData::StringSP> converted_keys;
- std::vector<StructuredData::ObjectSP> converted_values;
- // Verify that all of the keys match the values and types of keys we inserted
- // (Keys are always strings, so this is easy)
- for (int i = 0; i < dict_sp->GetSize(); ++i)
- {
- EXPECT_EQ(StructuredData::Type::eTypeString, dict_keys_array->GetItemAtIndex(i)->GetType());
- auto converted_key = std::static_pointer_cast<StructuredData::String>(dict_keys_array->GetItemAtIndex(i));
- converted_keys.push_back(converted_key);
- converted_values.push_back(dict_sp->GetValueForKey(converted_key->GetValue().c_str()));
-
- EXPECT_STREQ(dict_keys[i], converted_key->GetValue().c_str());
- EXPECT_EQ(dict_value_types[i], converted_values[i]->GetType());
- }
-
- auto dict_string_value = std::static_pointer_cast<StructuredData::String>(converted_values[0]);
- auto dict_int_value = std::static_pointer_cast<StructuredData::Integer>(converted_values[1]);
- auto dict_dict_value = std::static_pointer_cast<StructuredData::Dictionary>(converted_values[2]);
- auto dict_list_value = std::static_pointer_cast<StructuredData::Array>(converted_values[3]);
-
- // The first two dictionary values are easy to test, because they are just a string and an integer.
- EXPECT_STREQ(dict_value0, dict_string_value->GetValue().c_str());
- EXPECT_EQ(dict_value1, dict_int_value->GetValue());
-
- // For the nested dictionary, repeat the same process as before.
- EXPECT_EQ(2, dict_dict_value->GetSize());
- auto nested_dict_keys_array = std::static_pointer_cast<StructuredData::Array>(dict_dict_value->GetKeys());
-
- std::vector<StructuredData::StringSP> nested_converted_keys;
- std::vector<StructuredData::ObjectSP> nested_converted_values;
- // Verify that all of the keys match the values and types of keys we inserted
- // (Keys are always strings, so this is easy)
- for (int i = 0; i < dict_dict_value->GetSize(); ++i)
- {
- EXPECT_EQ(StructuredData::Type::eTypeString, nested_dict_keys_array->GetItemAtIndex(i)->GetType());
- auto converted_key =
- std::static_pointer_cast<StructuredData::String>(nested_dict_keys_array->GetItemAtIndex(i));
- nested_converted_keys.push_back(converted_key);
- nested_converted_values.push_back(dict_dict_value->GetValueForKey(converted_key->GetValue().c_str()));
-
- EXPECT_STREQ(nested_dict_keys[i], converted_key->GetValue().c_str());
- EXPECT_EQ(nested_dict_value_types[i], converted_values[i]->GetType());
- }
-
- auto converted_nested_dict_value_0 = std::static_pointer_cast<StructuredData::String>(nested_converted_values[0]);
- auto converted_nested_dict_value_1 = std::static_pointer_cast<StructuredData::Integer>(nested_converted_values[1]);
-
- // The first two dictionary values are easy to test, because they are just a string and an integer.
- EXPECT_STREQ(nested_dict_value0, converted_nested_dict_value_0->GetValue().c_str());
- EXPECT_EQ(nested_dict_value1, converted_nested_dict_value_1->GetValue());
-
- // For the nested list, just verify the size, type and value of each item
- nested_converted_values.clear();
- EXPECT_EQ(2, dict_list_value->GetSize());
- for (int i = 0; i < dict_list_value->GetSize(); ++i)
- {
- auto converted_value = dict_list_value->GetItemAtIndex(i);
- EXPECT_EQ(nested_list_value_types[i], converted_value->GetType());
- nested_converted_values.push_back(converted_value);
- }
-
- auto converted_nested_list_value_0 = std::static_pointer_cast<StructuredData::Integer>(nested_converted_values[0]);
- auto converted_nested_list_value_1 = std::static_pointer_cast<StructuredData::String>(nested_converted_values[1]);
- EXPECT_EQ(nested_list_value0, converted_nested_list_value_0->GetValue());
- EXPECT_STREQ(nested_list_value1, converted_nested_list_value_1->GetValue().c_str());
+ EXPECT_STREQ(string_value0, string_sp->GetValue().c_str());
+ EXPECT_EQ(int_value1, int_sp->GetValue());
}
More information about the lldb-commits
mailing list