| // Copyright (c) 2013 The Chromium Embedded Framework Authors. All rights |
| // reserved. Use of this source code is governed by a BSD-style license that |
| // can be found in the LICENSE file. |
| |
| #include "include/cef_task.h" |
| #include "include/cef_values.h" |
| #include "tests/ceftests/test_handler.h" |
| #include "tests/ceftests/test_util.h" |
| #include "tests/gtest/include/gtest/gtest.h" |
| |
| namespace { |
| |
| // Dictionary test keys. |
| const char* kNullKey = "null_key"; |
| const char* kBoolKey = "bool_key"; |
| const char* kIntKey = "int_key"; |
| const char* kDoubleKey = "double_key"; |
| const char* kStringKey = "string_key"; |
| const char* kBinaryKey = "binary_key"; |
| const char* kDictionaryKey = "dict_key"; |
| const char* kListKey = "list_key"; |
| |
| // List test indexes. |
| enum { |
| kNullIndex = 0, |
| kBoolIndex, |
| kIntIndex, |
| kDoubleIndex, |
| kStringIndex, |
| kBinaryIndex, |
| kDictionaryIndex, |
| kListIndex, |
| }; |
| |
| // Dictionary/list test values. |
| const bool kBoolValue = true; |
| const int kIntValue = 12; |
| const double kDoubleValue = 4.5432; |
| const char* kStringValue = "My string value"; |
| |
| // BINARY TEST HELPERS |
| |
| // Test a binary value. |
| void TestBinary(CefRefPtr<CefBinaryValue> value, char* data, size_t data_size) { |
| // Testing requires strings longer than 15 characters. |
| EXPECT_GT(data_size, 15U); |
| |
| EXPECT_EQ(data_size, value->GetSize()); |
| |
| char* buff = new char[data_size + 1]; |
| char old_char; |
| |
| // Test full read. |
| memset(buff, 0, data_size + 1); |
| EXPECT_EQ(data_size, value->GetData(buff, data_size, 0)); |
| EXPECT_TRUE(!strcmp(buff, data)); |
| |
| // Test partial read with offset. |
| memset(buff, 0, data_size + 1); |
| old_char = data[15]; |
| data[15] = 0; |
| EXPECT_EQ(10U, value->GetData(buff, 10, 5)); |
| EXPECT_TRUE(!strcmp(buff, data + 5)); |
| data[15] = old_char; |
| |
| // Test that changes to the original data have no effect. |
| memset(buff, 0, data_size + 1); |
| old_char = data[0]; |
| data[0] = '.'; |
| EXPECT_EQ(1U, value->GetData(buff, 1, 0)); |
| EXPECT_EQ(old_char, buff[0]); |
| data[0] = old_char; |
| |
| // Test copy. |
| CefRefPtr<CefBinaryValue> copy = value->Copy(); |
| TestBinaryEqual(copy, value); |
| |
| delete[] buff; |
| } |
| |
| // Used to test access of binary data on a different thread. |
| class BinaryTask : public CefTask { |
| public: |
| BinaryTask(CefRefPtr<CefBinaryValue> value, char* data, size_t data_size) |
| : value_(value), data_(data), data_size_(data_size) {} |
| |
| void Execute() override { TestBinary(value_, data_, data_size_); } |
| |
| private: |
| CefRefPtr<CefBinaryValue> value_; |
| char* data_; |
| size_t data_size_; |
| |
| IMPLEMENT_REFCOUNTING(BinaryTask); |
| }; |
| |
| // DICTIONARY TEST HELPERS |
| |
| // Test dictionary null value. |
| void TestDictionaryNull(CefRefPtr<CefDictionaryValue> value) { |
| EXPECT_FALSE(value->HasKey(kNullKey)); |
| EXPECT_TRUE(value->SetNull(kNullKey)); |
| EXPECT_TRUE(value->HasKey(kNullKey)); |
| EXPECT_EQ(VTYPE_NULL, value->GetType(kNullKey)); |
| } |
| |
| // Test dictionary bool value. |
| void TestDictionaryBool(CefRefPtr<CefDictionaryValue> value) { |
| EXPECT_FALSE(value->HasKey(kBoolKey)); |
| EXPECT_TRUE(value->SetBool(kBoolKey, kBoolValue)); |
| EXPECT_TRUE(value->HasKey(kBoolKey)); |
| EXPECT_EQ(VTYPE_BOOL, value->GetType(kBoolKey)); |
| EXPECT_EQ(kBoolValue, value->GetBool(kBoolKey)); |
| } |
| |
| // Test dictionary int value. |
| void TestDictionaryInt(CefRefPtr<CefDictionaryValue> value) { |
| EXPECT_FALSE(value->HasKey(kIntKey)); |
| EXPECT_TRUE(value->SetInt(kIntKey, kIntValue)); |
| EXPECT_TRUE(value->HasKey(kIntKey)); |
| EXPECT_EQ(VTYPE_INT, value->GetType(kIntKey)); |
| EXPECT_EQ(kIntValue, value->GetInt(kIntKey)); |
| } |
| |
| // Test dictionary double value. |
| void TestDictionaryDouble(CefRefPtr<CefDictionaryValue> value) { |
| EXPECT_FALSE(value->HasKey(kDoubleKey)); |
| EXPECT_TRUE(value->SetDouble(kDoubleKey, kDoubleValue)); |
| EXPECT_TRUE(value->HasKey(kDoubleKey)); |
| EXPECT_EQ(VTYPE_DOUBLE, value->GetType(kDoubleKey)); |
| EXPECT_EQ(kDoubleValue, value->GetDouble(kDoubleKey)); |
| } |
| |
| // Test dictionary string value. |
| void TestDictionaryString(CefRefPtr<CefDictionaryValue> value) { |
| EXPECT_FALSE(value->HasKey(kStringKey)); |
| EXPECT_TRUE(value->SetString(kStringKey, kStringValue)); |
| EXPECT_TRUE(value->HasKey(kStringKey)); |
| EXPECT_EQ(VTYPE_STRING, value->GetType(kStringKey)); |
| EXPECT_EQ(kStringValue, value->GetString(kStringKey).ToString()); |
| } |
| |
| // Test dictionary binary value. |
| void TestDictionaryBinary(CefRefPtr<CefDictionaryValue> value, |
| char* binary_data, |
| size_t binary_data_size, |
| CefRefPtr<CefBinaryValue>& binary_value) { |
| binary_value = CefBinaryValue::Create(binary_data, binary_data_size); |
| EXPECT_TRUE(binary_value.get()); |
| EXPECT_TRUE(binary_value->IsValid()); |
| EXPECT_FALSE(binary_value->IsOwned()); |
| EXPECT_FALSE(value->HasKey(kBinaryKey)); |
| EXPECT_TRUE(value->SetBinary(kBinaryKey, binary_value)); |
| EXPECT_FALSE(binary_value->IsValid()); // Value should be detached |
| EXPECT_TRUE(value->HasKey(kBinaryKey)); |
| EXPECT_EQ(VTYPE_BINARY, value->GetType(kBinaryKey)); |
| binary_value = value->GetBinary(kBinaryKey); |
| EXPECT_TRUE(binary_value.get()); |
| EXPECT_TRUE(binary_value->IsValid()); |
| EXPECT_TRUE(binary_value->IsOwned()); |
| TestBinary(binary_value, binary_data, binary_data_size); |
| } |
| |
| // Test dictionary dictionary value. |
| void TestDictionaryDictionary(CefRefPtr<CefDictionaryValue> value, |
| CefRefPtr<CefDictionaryValue>& dictionary_value) { |
| dictionary_value = CefDictionaryValue::Create(); |
| EXPECT_TRUE(dictionary_value.get()); |
| EXPECT_TRUE(dictionary_value->IsValid()); |
| EXPECT_FALSE(dictionary_value->IsOwned()); |
| EXPECT_FALSE(dictionary_value->IsReadOnly()); |
| EXPECT_TRUE(dictionary_value->SetInt(kIntKey, kIntValue)); |
| EXPECT_EQ(1U, dictionary_value->GetSize()); |
| EXPECT_FALSE(value->HasKey(kDictionaryKey)); |
| EXPECT_TRUE(value->SetDictionary(kDictionaryKey, dictionary_value)); |
| EXPECT_FALSE(dictionary_value->IsValid()); // Value should be detached |
| EXPECT_TRUE(value->HasKey(kDictionaryKey)); |
| EXPECT_EQ(VTYPE_DICTIONARY, value->GetType(kDictionaryKey)); |
| dictionary_value = value->GetDictionary(kDictionaryKey); |
| EXPECT_TRUE(dictionary_value.get()); |
| EXPECT_TRUE(dictionary_value->IsValid()); |
| EXPECT_TRUE(dictionary_value->IsOwned()); |
| EXPECT_FALSE(dictionary_value->IsReadOnly()); |
| EXPECT_EQ(1U, dictionary_value->GetSize()); |
| EXPECT_EQ(kIntValue, dictionary_value->GetInt(kIntKey)); |
| } |
| |
| // Test dictionary list value. |
| void TestDictionaryList(CefRefPtr<CefDictionaryValue> value, |
| CefRefPtr<CefListValue>& list_value) { |
| list_value = CefListValue::Create(); |
| EXPECT_TRUE(list_value.get()); |
| EXPECT_TRUE(list_value->IsValid()); |
| EXPECT_FALSE(list_value->IsOwned()); |
| EXPECT_FALSE(list_value->IsReadOnly()); |
| EXPECT_TRUE(list_value->SetInt(0, kIntValue)); |
| EXPECT_EQ(1U, list_value->GetSize()); |
| EXPECT_FALSE(value->HasKey(kListKey)); |
| EXPECT_TRUE(value->SetList(kListKey, list_value)); |
| EXPECT_FALSE(list_value->IsValid()); // Value should be detached |
| EXPECT_TRUE(value->HasKey(kListKey)); |
| EXPECT_EQ(VTYPE_LIST, value->GetType(kListKey)); |
| list_value = value->GetList(kListKey); |
| EXPECT_TRUE(list_value.get()); |
| EXPECT_TRUE(list_value->IsValid()); |
| EXPECT_TRUE(list_value->IsOwned()); |
| EXPECT_FALSE(list_value->IsReadOnly()); |
| EXPECT_EQ(1U, list_value->GetSize()); |
| EXPECT_EQ(kIntValue, list_value->GetInt(0)); |
| } |
| |
| // Test dictionary value. |
| void TestDictionary(CefRefPtr<CefDictionaryValue> value, |
| char* binary_data, |
| size_t binary_data_size) { |
| CefRefPtr<CefBinaryValue> binary_value; |
| CefRefPtr<CefDictionaryValue> dictionary_value; |
| CefRefPtr<CefListValue> list_value; |
| |
| // Test the size. |
| EXPECT_EQ(0U, value->GetSize()); |
| |
| TestDictionaryNull(value); |
| TestDictionaryBool(value); |
| TestDictionaryInt(value); |
| TestDictionaryDouble(value); |
| TestDictionaryString(value); |
| TestDictionaryBinary(value, binary_data, binary_data_size, binary_value); |
| TestDictionaryDictionary(value, dictionary_value); |
| TestDictionaryList(value, list_value); |
| |
| // Test the size. |
| EXPECT_EQ(8U, value->GetSize()); |
| |
| // Test copy. |
| CefRefPtr<CefDictionaryValue> copy = value->Copy(false); |
| TestDictionaryEqual(value, copy); |
| |
| // Test removal. |
| EXPECT_TRUE(value->Remove(kNullKey)); |
| EXPECT_FALSE(value->HasKey(kNullKey)); |
| |
| EXPECT_TRUE(value->Remove(kBoolKey)); |
| EXPECT_FALSE(value->HasKey(kBoolKey)); |
| |
| EXPECT_TRUE(value->Remove(kIntKey)); |
| EXPECT_FALSE(value->HasKey(kIntKey)); |
| |
| EXPECT_TRUE(value->Remove(kDoubleKey)); |
| EXPECT_FALSE(value->HasKey(kDoubleKey)); |
| |
| EXPECT_TRUE(value->Remove(kStringKey)); |
| EXPECT_FALSE(value->HasKey(kStringKey)); |
| |
| EXPECT_TRUE(value->Remove(kBinaryKey)); |
| EXPECT_FALSE(value->HasKey(kBinaryKey)); |
| EXPECT_FALSE(binary_value->IsValid()); // Value should be detached |
| |
| EXPECT_TRUE(value->Remove(kDictionaryKey)); |
| EXPECT_FALSE(value->HasKey(kDictionaryKey)); |
| EXPECT_FALSE(dictionary_value->IsValid()); // Value should be detached |
| |
| EXPECT_TRUE(value->Remove(kListKey)); |
| EXPECT_FALSE(value->HasKey(kListKey)); |
| EXPECT_FALSE(list_value->IsValid()); // Value should be detached |
| |
| // Test the size. |
| EXPECT_EQ(0U, value->GetSize()); |
| |
| // Re-add some values. |
| TestDictionaryNull(value); |
| TestDictionaryBool(value); |
| TestDictionaryDictionary(value, dictionary_value); |
| |
| // Test the size. |
| EXPECT_EQ(3U, value->GetSize()); |
| |
| // Clear the values. |
| EXPECT_TRUE(value->Clear()); |
| EXPECT_EQ(0U, value->GetSize()); |
| EXPECT_FALSE(dictionary_value->IsValid()); // Value should be detached |
| } |
| |
| // Used to test access of dictionary data on a different thread. |
| class DictionaryTask : public CefTask { |
| public: |
| DictionaryTask(CefRefPtr<CefDictionaryValue> value, |
| char* binary_data, |
| size_t binary_data_size) |
| : value_(value), |
| binary_data_(binary_data), |
| binary_data_size_(binary_data_size) {} |
| |
| void Execute() override { |
| TestDictionary(value_, binary_data_, binary_data_size_); |
| } |
| |
| private: |
| CefRefPtr<CefDictionaryValue> value_; |
| char* binary_data_; |
| size_t binary_data_size_; |
| |
| IMPLEMENT_REFCOUNTING(DictionaryTask); |
| }; |
| |
| // LIST TEST HELPERS |
| |
| // Test list null value. |
| void TestListNull(CefRefPtr<CefListValue> value, size_t index) { |
| CefValueType type = value->GetType(index); |
| EXPECT_TRUE(type == VTYPE_INVALID || type == VTYPE_NULL); |
| |
| EXPECT_TRUE(value->SetNull(index)); |
| EXPECT_EQ(VTYPE_NULL, value->GetType(index)); |
| } |
| |
| // Test list bool value. |
| void TestListBool(CefRefPtr<CefListValue> value, size_t index) { |
| CefValueType type = value->GetType(index); |
| EXPECT_TRUE(type == VTYPE_INVALID || type == VTYPE_NULL); |
| |
| EXPECT_TRUE(value->SetBool(index, kBoolValue)); |
| EXPECT_EQ(VTYPE_BOOL, value->GetType(index)); |
| EXPECT_EQ(kBoolValue, value->GetBool(index)); |
| } |
| |
| // Test list int value. |
| void TestListInt(CefRefPtr<CefListValue> value, size_t index) { |
| CefValueType type = value->GetType(index); |
| EXPECT_TRUE(type == VTYPE_INVALID || type == VTYPE_NULL); |
| |
| EXPECT_TRUE(value->SetInt(index, kIntValue)); |
| EXPECT_EQ(VTYPE_INT, value->GetType(index)); |
| EXPECT_EQ(kIntValue, value->GetInt(index)); |
| } |
| |
| // Test list double value. |
| void TestListDouble(CefRefPtr<CefListValue> value, size_t index) { |
| CefValueType type = value->GetType(index); |
| EXPECT_TRUE(type == VTYPE_INVALID || type == VTYPE_NULL); |
| |
| EXPECT_TRUE(value->SetDouble(index, kDoubleValue)); |
| EXPECT_EQ(VTYPE_DOUBLE, value->GetType(index)); |
| EXPECT_EQ(kDoubleValue, value->GetDouble(index)); |
| } |
| |
| // Test list string value. |
| void TestListString(CefRefPtr<CefListValue> value, size_t index) { |
| CefValueType type = value->GetType(index); |
| EXPECT_TRUE(type == VTYPE_INVALID || type == VTYPE_NULL); |
| |
| EXPECT_TRUE(value->SetString(index, kStringValue)); |
| EXPECT_EQ(VTYPE_STRING, value->GetType(index)); |
| EXPECT_EQ(kStringValue, value->GetString(index).ToString()); |
| } |
| |
| // Test list binary value. |
| void TestListBinary(CefRefPtr<CefListValue> value, |
| size_t index, |
| char* binary_data, |
| size_t binary_data_size, |
| CefRefPtr<CefBinaryValue>& binary_value) { |
| binary_value = CefBinaryValue::Create(binary_data, binary_data_size); |
| EXPECT_TRUE(binary_value.get()); |
| EXPECT_TRUE(binary_value->IsValid()); |
| EXPECT_FALSE(binary_value->IsOwned()); |
| |
| CefValueType type = value->GetType(index); |
| EXPECT_TRUE(type == VTYPE_INVALID || type == VTYPE_NULL); |
| |
| EXPECT_TRUE(value->SetBinary(index, binary_value)); |
| EXPECT_FALSE(binary_value->IsValid()); // Value should be detached |
| EXPECT_EQ(VTYPE_BINARY, value->GetType(index)); |
| binary_value = value->GetBinary(index); |
| EXPECT_TRUE(binary_value.get()); |
| EXPECT_TRUE(binary_value->IsValid()); |
| EXPECT_TRUE(binary_value->IsOwned()); |
| TestBinary(binary_value, binary_data, binary_data_size); |
| } |
| |
| // Test list dictionary value. |
| void TestListDictionary(CefRefPtr<CefListValue> value, |
| size_t index, |
| CefRefPtr<CefDictionaryValue>& dictionary_value) { |
| dictionary_value = CefDictionaryValue::Create(); |
| EXPECT_TRUE(dictionary_value.get()); |
| EXPECT_TRUE(dictionary_value->IsValid()); |
| EXPECT_FALSE(dictionary_value->IsOwned()); |
| EXPECT_FALSE(dictionary_value->IsReadOnly()); |
| EXPECT_TRUE(dictionary_value->SetInt(kIntKey, kIntValue)); |
| EXPECT_EQ(1U, dictionary_value->GetSize()); |
| |
| CefValueType type = value->GetType(index); |
| EXPECT_TRUE(type == VTYPE_INVALID || type == VTYPE_NULL); |
| |
| EXPECT_TRUE(value->SetDictionary(index, dictionary_value)); |
| EXPECT_FALSE(dictionary_value->IsValid()); // Value should be detached |
| EXPECT_EQ(VTYPE_DICTIONARY, value->GetType(index)); |
| dictionary_value = value->GetDictionary(index); |
| EXPECT_TRUE(dictionary_value.get()); |
| EXPECT_TRUE(dictionary_value->IsValid()); |
| EXPECT_TRUE(dictionary_value->IsOwned()); |
| EXPECT_FALSE(dictionary_value->IsReadOnly()); |
| EXPECT_EQ(1U, dictionary_value->GetSize()); |
| EXPECT_EQ(kIntValue, dictionary_value->GetInt(kIntKey)); |
| } |
| |
| // Test list list value. |
| void TestListList(CefRefPtr<CefListValue> value, |
| size_t index, |
| CefRefPtr<CefListValue>& list_value) { |
| list_value = CefListValue::Create(); |
| EXPECT_TRUE(list_value.get()); |
| EXPECT_TRUE(list_value->IsValid()); |
| EXPECT_FALSE(list_value->IsOwned()); |
| EXPECT_FALSE(list_value->IsReadOnly()); |
| EXPECT_TRUE(list_value->SetInt(0, kIntValue)); |
| EXPECT_EQ(1U, list_value->GetSize()); |
| |
| CefValueType type = value->GetType(index); |
| EXPECT_TRUE(type == VTYPE_INVALID || type == VTYPE_NULL); |
| |
| EXPECT_TRUE(value->SetList(index, list_value)); |
| EXPECT_FALSE(list_value->IsValid()); // Value should be detached |
| EXPECT_EQ(VTYPE_LIST, value->GetType(index)); |
| list_value = value->GetList(index); |
| EXPECT_TRUE(list_value.get()); |
| EXPECT_TRUE(list_value->IsValid()); |
| EXPECT_TRUE(list_value->IsOwned()); |
| EXPECT_FALSE(list_value->IsReadOnly()); |
| EXPECT_EQ(1U, list_value->GetSize()); |
| EXPECT_EQ(kIntValue, list_value->GetInt(0)); |
| } |
| |
| // Test list value. |
| void TestList(CefRefPtr<CefListValue> value, |
| char* binary_data, |
| size_t binary_data_size) { |
| CefRefPtr<CefBinaryValue> binary_value; |
| CefRefPtr<CefDictionaryValue> dictionary_value; |
| CefRefPtr<CefListValue> list_value; |
| |
| // Test the size. |
| EXPECT_EQ(0U, value->GetSize()); |
| |
| // Set the size. |
| EXPECT_TRUE(value->SetSize(8)); |
| EXPECT_EQ(8U, value->GetSize()); |
| |
| EXPECT_EQ(VTYPE_NULL, value->GetType(kNullIndex)); |
| TestListNull(value, kNullIndex); |
| EXPECT_EQ(VTYPE_NULL, value->GetType(kBoolIndex)); |
| TestListBool(value, kBoolIndex); |
| EXPECT_EQ(VTYPE_NULL, value->GetType(kIntIndex)); |
| TestListInt(value, kIntIndex); |
| EXPECT_EQ(VTYPE_NULL, value->GetType(kDoubleIndex)); |
| TestListDouble(value, kDoubleIndex); |
| EXPECT_EQ(VTYPE_NULL, value->GetType(kStringIndex)); |
| TestListString(value, kStringIndex); |
| EXPECT_EQ(VTYPE_NULL, value->GetType(kBinaryIndex)); |
| TestListBinary(value, kBinaryIndex, binary_data, binary_data_size, |
| binary_value); |
| EXPECT_EQ(VTYPE_NULL, value->GetType(kDictionaryIndex)); |
| TestListDictionary(value, kDictionaryIndex, dictionary_value); |
| EXPECT_EQ(VTYPE_NULL, value->GetType(kListIndex)); |
| TestListList(value, kListIndex, list_value); |
| |
| // Test the size. |
| EXPECT_EQ(8U, value->GetSize()); |
| |
| // Test various operations with invalid index. |
| EXPECT_FALSE(list_value->Remove(9U)); |
| EXPECT_TRUE(list_value->GetType(10U) == VTYPE_INVALID); |
| EXPECT_FALSE(list_value->GetValue(11U).get() != nullptr && |
| list_value->GetValue(11U)->IsValid()); |
| |
| // Test copy. |
| CefRefPtr<CefListValue> copy = value->Copy(); |
| TestListEqual(value, copy); |
| |
| // Test removal (in reverse order so indexes stay valid). |
| EXPECT_TRUE(value->Remove(kListIndex)); |
| EXPECT_EQ(7U, value->GetSize()); |
| EXPECT_FALSE(list_value->IsValid()); // Value should be detached |
| |
| EXPECT_TRUE(value->Remove(kDictionaryIndex)); |
| EXPECT_EQ(6U, value->GetSize()); |
| EXPECT_FALSE(dictionary_value->IsValid()); // Value should be detached |
| |
| EXPECT_TRUE(value->Remove(kBinaryIndex)); |
| EXPECT_EQ(5U, value->GetSize()); |
| EXPECT_FALSE(binary_value->IsValid()); // Value should be detached |
| |
| EXPECT_TRUE(value->Remove(kStringIndex)); |
| EXPECT_EQ(4U, value->GetSize()); |
| |
| EXPECT_TRUE(value->Remove(kDoubleIndex)); |
| EXPECT_EQ(3U, value->GetSize()); |
| |
| EXPECT_TRUE(value->Remove(kIntIndex)); |
| EXPECT_EQ(2U, value->GetSize()); |
| |
| EXPECT_TRUE(value->Remove(kBoolIndex)); |
| EXPECT_EQ(1U, value->GetSize()); |
| |
| EXPECT_TRUE(value->Remove(kNullIndex)); |
| EXPECT_EQ(0U, value->GetSize()); |
| |
| // Re-add some values. |
| EXPECT_EQ(VTYPE_INVALID, value->GetType(0)); |
| TestListNull(value, 0); |
| EXPECT_EQ(VTYPE_INVALID, value->GetType(1)); |
| TestListBool(value, 1); |
| EXPECT_EQ(VTYPE_INVALID, value->GetType(2)); |
| TestListList(value, 2, list_value); |
| |
| // Test the size. |
| EXPECT_EQ(3U, value->GetSize()); |
| |
| // Clear the values. |
| EXPECT_TRUE(value->Clear()); |
| EXPECT_EQ(0U, value->GetSize()); |
| EXPECT_FALSE(list_value->IsValid()); // Value should be detached |
| |
| // Add some values in random order. |
| EXPECT_EQ(VTYPE_INVALID, value->GetType(2)); |
| TestListInt(value, 2); |
| EXPECT_EQ(VTYPE_NULL, value->GetType(0)); |
| TestListBool(value, 0); |
| EXPECT_EQ(VTYPE_NULL, value->GetType(1)); |
| TestListList(value, 1, list_value); |
| |
| EXPECT_EQ(VTYPE_BOOL, value->GetType(0)); |
| EXPECT_EQ(VTYPE_LIST, value->GetType(1)); |
| EXPECT_EQ(VTYPE_INT, value->GetType(2)); |
| |
| // Test the size. |
| EXPECT_EQ(3U, value->GetSize()); |
| |
| // Clear some values. |
| EXPECT_TRUE(value->SetSize(1)); |
| EXPECT_EQ(1U, value->GetSize()); |
| EXPECT_FALSE(list_value->IsValid()); // Value should be detached |
| |
| EXPECT_EQ(VTYPE_BOOL, value->GetType(0)); |
| EXPECT_EQ(VTYPE_INVALID, value->GetType(1)); |
| EXPECT_EQ(VTYPE_INVALID, value->GetType(2)); |
| |
| // Clear all values. |
| EXPECT_TRUE(value->Clear()); |
| EXPECT_EQ(0U, value->GetSize()); |
| } |
| |
| // Used to test access of list data on a different thread. |
| class ListTask : public CefTask { |
| public: |
| ListTask(CefRefPtr<CefListValue> value, |
| char* binary_data, |
| size_t binary_data_size) |
| : value_(value), |
| binary_data_(binary_data), |
| binary_data_size_(binary_data_size) {} |
| |
| void Execute() override { TestList(value_, binary_data_, binary_data_size_); } |
| |
| private: |
| CefRefPtr<CefListValue> value_; |
| char* binary_data_; |
| size_t binary_data_size_; |
| |
| IMPLEMENT_REFCOUNTING(ListTask); |
| }; |
| |
| void CreateAndCompareCopy(CefRefPtr<CefValue> value) { |
| CefRefPtr<CefValue> value2 = value->Copy(); |
| EXPECT_TRUE(value->IsEqual(value)); |
| EXPECT_TRUE(value->IsSame(value)); |
| EXPECT_TRUE(value2->IsEqual(value2)); |
| EXPECT_TRUE(value2->IsSame(value2)); |
| EXPECT_TRUE(value->IsEqual(value2)); |
| EXPECT_FALSE(value->IsSame(value2)); |
| EXPECT_TRUE(value2->IsEqual(value)); |
| EXPECT_FALSE(value2->IsSame(value)); |
| } |
| |
| CefRefPtr<CefBinaryValue> CreateBinaryValue() { |
| char binary_data[] = "This is my test data"; |
| const size_t binary_data_size = sizeof(binary_data) - 1; |
| |
| CefRefPtr<CefBinaryValue> binary_value = |
| CefBinaryValue::Create(binary_data, binary_data_size); |
| EXPECT_TRUE(binary_value.get()); |
| EXPECT_TRUE(binary_value->IsValid()); |
| EXPECT_FALSE(binary_value->IsOwned()); |
| TestBinary(binary_value, binary_data, binary_data_size); |
| return binary_value; |
| } |
| |
| CefRefPtr<CefListValue> CreateListValue() { |
| CefRefPtr<CefListValue> list_value = CefListValue::Create(); |
| EXPECT_TRUE(list_value.get()); |
| EXPECT_TRUE(list_value->IsValid()); |
| EXPECT_FALSE(list_value->IsOwned()); |
| EXPECT_FALSE(list_value->IsReadOnly()); |
| EXPECT_TRUE(list_value->SetInt(0, kIntValue)); |
| EXPECT_TRUE(list_value->SetInt(1, kDoubleValue)); |
| return list_value; |
| } |
| |
| const char* kKey1 = "key1"; |
| const char* kKey2 = "key2"; |
| |
| CefRefPtr<CefDictionaryValue> CreateDictionaryValue() { |
| // Create the dictionary. |
| CefRefPtr<CefDictionaryValue> dict_value = CefDictionaryValue::Create(); |
| EXPECT_TRUE(dict_value.get()); |
| EXPECT_TRUE(dict_value->IsValid()); |
| EXPECT_FALSE(dict_value->IsOwned()); |
| EXPECT_FALSE(dict_value->IsReadOnly()); |
| EXPECT_TRUE(dict_value->SetInt(kKey1, kIntValue)); |
| EXPECT_TRUE(dict_value->SetInt(kKey2, kDoubleValue)); |
| return dict_value; |
| } |
| |
| } // namespace |
| |
| // Test binary value access. |
| TEST(ValuesTest, BinaryAccess) { |
| char data[] = "This is my test data"; |
| |
| CefRefPtr<CefBinaryValue> value = |
| CefBinaryValue::Create(data, sizeof(data) - 1); |
| EXPECT_TRUE(value.get()); |
| EXPECT_TRUE(value->IsValid()); |
| EXPECT_FALSE(value->IsOwned()); |
| |
| // Test on this thread. |
| TestBinary(value, data, sizeof(data) - 1); |
| } |
| |
| // Test binary value access on a different thread. |
| TEST(ValuesTest, BinaryAccessOtherThread) { |
| char data[] = "This is my test data"; |
| |
| CefRefPtr<CefBinaryValue> value = |
| CefBinaryValue::Create(data, sizeof(data) - 1); |
| EXPECT_TRUE(value.get()); |
| EXPECT_TRUE(value->IsValid()); |
| EXPECT_FALSE(value->IsOwned()); |
| |
| // Test on a different thread. |
| CefPostTask(TID_UI, new BinaryTask(value, data, sizeof(data) - 1)); |
| WaitForUIThread(); |
| } |
| |
| // Test dictionary value access. |
| TEST(ValuesTest, DictionaryAccess) { |
| CefRefPtr<CefDictionaryValue> value = CefDictionaryValue::Create(); |
| EXPECT_TRUE(value.get()); |
| EXPECT_TRUE(value->IsValid()); |
| EXPECT_FALSE(value->IsOwned()); |
| EXPECT_FALSE(value->IsReadOnly()); |
| |
| char binary_data[] = "This is my test data"; |
| |
| // Test on this thread. |
| TestDictionary(value, binary_data, sizeof(binary_data) - 1); |
| } |
| |
| // Test dictionary value access on a different thread. |
| TEST(ValuesTest, DictionaryAccessOtherThread) { |
| CefRefPtr<CefDictionaryValue> value = CefDictionaryValue::Create(); |
| EXPECT_TRUE(value.get()); |
| EXPECT_TRUE(value->IsValid()); |
| EXPECT_FALSE(value->IsOwned()); |
| EXPECT_FALSE(value->IsReadOnly()); |
| |
| char binary_data[] = "This is my test data"; |
| |
| // Test on a different thread. |
| CefPostTask(TID_UI, |
| new DictionaryTask(value, binary_data, sizeof(binary_data) - 1)); |
| WaitForUIThread(); |
| } |
| |
| // Test dictionary value nested detachment |
| TEST(ValuesTest, DictionaryDetachment) { |
| CefRefPtr<CefDictionaryValue> value = CefDictionaryValue::Create(); |
| EXPECT_TRUE(value.get()); |
| EXPECT_TRUE(value->IsValid()); |
| EXPECT_FALSE(value->IsOwned()); |
| EXPECT_FALSE(value->IsReadOnly()); |
| |
| CefRefPtr<CefDictionaryValue> dictionary_value = CefDictionaryValue::Create(); |
| CefRefPtr<CefDictionaryValue> dictionary_value2 = |
| CefDictionaryValue::Create(); |
| CefRefPtr<CefDictionaryValue> dictionary_value3 = |
| CefDictionaryValue::Create(); |
| |
| dictionary_value2->SetDictionary(kDictionaryKey, dictionary_value3); |
| EXPECT_FALSE(dictionary_value3->IsValid()); |
| dictionary_value->SetDictionary(kDictionaryKey, dictionary_value2); |
| EXPECT_FALSE(dictionary_value2->IsValid()); |
| value->SetDictionary(kDictionaryKey, dictionary_value); |
| EXPECT_FALSE(dictionary_value->IsValid()); |
| |
| dictionary_value = value->GetDictionary(kDictionaryKey); |
| EXPECT_TRUE(dictionary_value.get()); |
| EXPECT_TRUE(dictionary_value->IsValid()); |
| |
| dictionary_value2 = dictionary_value->GetDictionary(kDictionaryKey); |
| EXPECT_TRUE(dictionary_value2.get()); |
| EXPECT_TRUE(dictionary_value2->IsValid()); |
| |
| dictionary_value3 = dictionary_value2->GetDictionary(kDictionaryKey); |
| EXPECT_TRUE(dictionary_value3.get()); |
| EXPECT_TRUE(dictionary_value3->IsValid()); |
| |
| EXPECT_TRUE(value->Remove(kDictionaryKey)); |
| EXPECT_FALSE(dictionary_value->IsValid()); |
| EXPECT_FALSE(dictionary_value2->IsValid()); |
| EXPECT_FALSE(dictionary_value3->IsValid()); |
| } |
| |
| // Test list value access. |
| TEST(ValuesTest, ListAccess) { |
| CefRefPtr<CefListValue> value = CefListValue::Create(); |
| EXPECT_TRUE(value.get()); |
| EXPECT_TRUE(value->IsValid()); |
| EXPECT_FALSE(value->IsOwned()); |
| EXPECT_FALSE(value->IsReadOnly()); |
| |
| char binary_data[] = "This is my test data"; |
| |
| // Test on this thread. |
| TestList(value, binary_data, sizeof(binary_data) - 1); |
| } |
| |
| // Test list value access on a different thread. |
| TEST(ValuesTest, ListAccessOtherThread) { |
| CefRefPtr<CefListValue> value = CefListValue::Create(); |
| EXPECT_TRUE(value.get()); |
| EXPECT_TRUE(value->IsValid()); |
| EXPECT_FALSE(value->IsOwned()); |
| EXPECT_FALSE(value->IsReadOnly()); |
| |
| char binary_data[] = "This is my test data"; |
| |
| // Test on a different thread. |
| CefPostTask(TID_UI, |
| new ListTask(value, binary_data, sizeof(binary_data) - 1)); |
| WaitForUIThread(); |
| } |
| |
| // Test list value nested detachment |
| TEST(ValuesTest, ListDetachment) { |
| CefRefPtr<CefListValue> value = CefListValue::Create(); |
| EXPECT_TRUE(value.get()); |
| EXPECT_TRUE(value->IsValid()); |
| EXPECT_FALSE(value->IsOwned()); |
| EXPECT_FALSE(value->IsReadOnly()); |
| |
| CefRefPtr<CefListValue> list_value = CefListValue::Create(); |
| CefRefPtr<CefListValue> list_value2 = CefListValue::Create(); |
| CefRefPtr<CefListValue> list_value3 = CefListValue::Create(); |
| |
| list_value2->SetList(0, list_value3); |
| EXPECT_FALSE(list_value3->IsValid()); |
| list_value->SetList(0, list_value2); |
| EXPECT_FALSE(list_value2->IsValid()); |
| value->SetList(0, list_value); |
| EXPECT_FALSE(list_value->IsValid()); |
| |
| list_value = value->GetList(0); |
| EXPECT_TRUE(list_value.get()); |
| EXPECT_TRUE(list_value->IsValid()); |
| |
| list_value2 = list_value->GetList(0); |
| EXPECT_TRUE(list_value2.get()); |
| EXPECT_TRUE(list_value2->IsValid()); |
| |
| list_value3 = list_value2->GetList(0); |
| EXPECT_TRUE(list_value3.get()); |
| EXPECT_TRUE(list_value3->IsValid()); |
| |
| EXPECT_TRUE(value->Remove(0)); |
| EXPECT_FALSE(list_value->IsValid()); |
| EXPECT_FALSE(list_value2->IsValid()); |
| EXPECT_FALSE(list_value3->IsValid()); |
| } |
| |
| // Test get/set of a CefValue simple types. |
| TEST(ValuesTest, ValueSimple) { |
| CefRefPtr<CefValue> value = CefValue::Create(); |
| EXPECT_TRUE(value.get()); |
| EXPECT_TRUE(value->IsValid()); |
| EXPECT_FALSE(value->IsReadOnly()); |
| EXPECT_FALSE(value->IsOwned()); |
| EXPECT_EQ(VTYPE_NULL, value->GetType()); |
| CreateAndCompareCopy(value); |
| |
| EXPECT_TRUE(value->SetBool(true)); |
| EXPECT_EQ(VTYPE_BOOL, value->GetType()); |
| EXPECT_TRUE(value->GetBool()); |
| EXPECT_TRUE(value->IsValid()); |
| EXPECT_FALSE(value->IsReadOnly()); |
| EXPECT_FALSE(value->IsOwned()); |
| CreateAndCompareCopy(value); |
| |
| EXPECT_TRUE(value->SetBool(false)); |
| EXPECT_EQ(VTYPE_BOOL, value->GetType()); |
| EXPECT_FALSE(value->GetBool()); |
| EXPECT_TRUE(value->IsValid()); |
| EXPECT_FALSE(value->IsReadOnly()); |
| EXPECT_FALSE(value->IsOwned()); |
| CreateAndCompareCopy(value); |
| |
| EXPECT_TRUE(value->SetInt(3)); |
| EXPECT_EQ(VTYPE_INT, value->GetType()); |
| EXPECT_EQ(3, value->GetInt()); |
| EXPECT_TRUE(value->IsValid()); |
| EXPECT_FALSE(value->IsReadOnly()); |
| EXPECT_FALSE(value->IsOwned()); |
| CreateAndCompareCopy(value); |
| |
| EXPECT_TRUE(value->SetDouble(5.665)); |
| EXPECT_EQ(VTYPE_DOUBLE, value->GetType()); |
| EXPECT_EQ(5.665, value->GetDouble()); |
| EXPECT_TRUE(value->IsValid()); |
| EXPECT_FALSE(value->IsReadOnly()); |
| EXPECT_FALSE(value->IsOwned()); |
| CreateAndCompareCopy(value); |
| |
| const char* str = "Test string"; |
| EXPECT_TRUE(value->SetString(str)); |
| EXPECT_EQ(VTYPE_STRING, value->GetType()); |
| EXPECT_STREQ(str, value->GetString().ToString().data()); |
| EXPECT_TRUE(value->IsValid()); |
| EXPECT_FALSE(value->IsReadOnly()); |
| EXPECT_FALSE(value->IsOwned()); |
| CreateAndCompareCopy(value); |
| |
| EXPECT_TRUE(value->SetNull()); |
| EXPECT_EQ(VTYPE_NULL, value->GetType()); |
| EXPECT_TRUE(value->IsValid()); |
| EXPECT_FALSE(value->IsReadOnly()); |
| EXPECT_FALSE(value->IsOwned()); |
| CreateAndCompareCopy(value); |
| } |
| |
| // Test association of a CefValue simple type with a CefListValue. |
| TEST(ValuesTest, ValueSimpleToList) { |
| const double double_value = 5.665; |
| |
| CefRefPtr<CefValue> value = CefValue::Create(); |
| EXPECT_TRUE(value->SetDouble(double_value)); |
| |
| // Add the value to the target list. |
| CefRefPtr<CefListValue> target_list = CefListValue::Create(); |
| EXPECT_TRUE(target_list->SetValue(0, value)); |
| |
| // Test the value in the target list. |
| EXPECT_EQ(VTYPE_DOUBLE, target_list->GetType(0)); |
| EXPECT_EQ(double_value, target_list->GetDouble(0)); |
| |
| // Get the value from the target list. |
| CefRefPtr<CefValue> value2 = target_list->GetValue(0); |
| EXPECT_TRUE(value2.get()); |
| EXPECT_FALSE(value2->IsOwned()); |
| EXPECT_FALSE(value2->IsReadOnly()); |
| EXPECT_EQ(VTYPE_DOUBLE, value2->GetType()); |
| EXPECT_EQ(double_value, value2->GetDouble()); |
| |
| // Values are equal but not the same. |
| EXPECT_TRUE(value->IsEqual(value2)); |
| EXPECT_TRUE(value2->IsEqual(value)); |
| EXPECT_FALSE(value->IsSame(value2)); |
| EXPECT_FALSE(value2->IsSame(value)); |
| |
| // Change the value in the target list. |
| EXPECT_TRUE(target_list->SetInt(0, 5)); |
| EXPECT_EQ(VTYPE_INT, target_list->GetType(0)); |
| EXPECT_EQ(5, target_list->GetInt(0)); |
| |
| // The other values are still valid. |
| EXPECT_TRUE(value->IsValid()); |
| EXPECT_TRUE(value2->IsValid()); |
| } |
| |
| // Test association of a CefValue simple type with a CefDictionaryValue. |
| TEST(ValuesTest, ValueSimpleToDictionary) { |
| const double double_value = 5.665; |
| const char* key = "key"; |
| |
| CefRefPtr<CefValue> value = CefValue::Create(); |
| EXPECT_TRUE(value->SetDouble(double_value)); |
| |
| // Add the value to the target dictionary. |
| CefRefPtr<CefDictionaryValue> target_dict = CefDictionaryValue::Create(); |
| EXPECT_TRUE(target_dict->SetValue(key, value)); |
| |
| // Test the value in the target dictionary. |
| EXPECT_EQ(VTYPE_DOUBLE, target_dict->GetType(key)); |
| EXPECT_EQ(double_value, target_dict->GetDouble(key)); |
| |
| // Get the value from the target dictionary. |
| CefRefPtr<CefValue> value2 = target_dict->GetValue(key); |
| EXPECT_TRUE(value2.get()); |
| EXPECT_FALSE(value2->IsOwned()); |
| EXPECT_FALSE(value2->IsReadOnly()); |
| EXPECT_EQ(VTYPE_DOUBLE, value2->GetType()); |
| EXPECT_EQ(double_value, value2->GetDouble()); |
| |
| // Values are equal but not the same. |
| EXPECT_TRUE(value->IsEqual(value2)); |
| EXPECT_TRUE(value2->IsEqual(value)); |
| EXPECT_FALSE(value->IsSame(value2)); |
| EXPECT_FALSE(value2->IsSame(value)); |
| |
| // Change the value in the target dictionary. |
| EXPECT_TRUE(target_dict->SetInt(key, 5)); |
| EXPECT_EQ(VTYPE_INT, target_dict->GetType(key)); |
| EXPECT_EQ(5, target_dict->GetInt(key)); |
| |
| // The other values are still valid. |
| EXPECT_TRUE(value->IsValid()); |
| EXPECT_TRUE(value2->IsValid()); |
| } |
| |
| // Test get/set of a CefValue binary type. |
| TEST(ValuesTest, ValueBinary) { |
| // Create the binary. |
| CefRefPtr<CefBinaryValue> binary_value = CreateBinaryValue(); |
| |
| // Create the value. |
| CefRefPtr<CefValue> value = CefValue::Create(); |
| EXPECT_TRUE(value->SetBinary(binary_value)); |
| EXPECT_EQ(VTYPE_BINARY, value->GetType()); |
| EXPECT_TRUE(value->IsValid()); |
| EXPECT_TRUE(value->IsReadOnly()); // Binary values are always read-only. |
| EXPECT_FALSE(value->IsOwned()); |
| CreateAndCompareCopy(value); |
| |
| // Get the binary reference from the value. |
| CefRefPtr<CefBinaryValue> binary_value2 = value->GetBinary(); |
| EXPECT_TRUE(binary_value2.get()); |
| EXPECT_TRUE(binary_value2->IsValid()); |
| EXPECT_FALSE(binary_value2->IsOwned()); |
| |
| // The binaries are the same and equal. |
| TestBinaryEqual(binary_value, binary_value2); |
| EXPECT_TRUE(binary_value->IsSame(binary_value2)); |
| EXPECT_TRUE(binary_value2->IsSame(binary_value)); |
| } |
| |
| // Test association of a CefValue binary with a CefListValue. |
| TEST(ValuesTest, ValueBinaryToList) { |
| // Create the binary. |
| CefRefPtr<CefBinaryValue> binary_value = CreateBinaryValue(); |
| |
| // Add the binary to a value. |
| CefRefPtr<CefValue> value = CefValue::Create(); |
| EXPECT_TRUE(value->SetBinary(binary_value)); |
| |
| // Add the value to the target list. |
| CefRefPtr<CefListValue> target_list = CefListValue::Create(); |
| EXPECT_TRUE(target_list->SetValue(0, value)); |
| |
| // The binary value is now owned by the target list. |
| EXPECT_FALSE(binary_value->IsValid()); |
| |
| // The value is still valid and points to the new reference list. |
| EXPECT_TRUE(value->IsValid()); |
| |
| CefRefPtr<CefBinaryValue> binary_value2 = value->GetBinary(); |
| CefRefPtr<CefBinaryValue> binary_value3 = target_list->GetBinary(0); |
| CefRefPtr<CefValue> value2 = target_list->GetValue(0); |
| CefRefPtr<CefBinaryValue> binary_value4 = value2->GetBinary(); |
| |
| // All values are owned by the target list. |
| EXPECT_TRUE(value->IsOwned()); |
| EXPECT_TRUE(value2->IsOwned()); |
| EXPECT_TRUE(binary_value2->IsOwned()); |
| EXPECT_TRUE(binary_value3->IsOwned()); |
| EXPECT_TRUE(binary_value4->IsOwned()); |
| |
| // All values are the same. |
| EXPECT_TRUE(binary_value2->IsSame(binary_value3)); |
| TestBinaryEqual(binary_value2, binary_value3); |
| EXPECT_TRUE(binary_value2->IsSame(binary_value4)); |
| TestBinaryEqual(binary_value2, binary_value4); |
| |
| // Change the value to something else. |
| EXPECT_TRUE(target_list->SetInt(0, kIntValue)); |
| EXPECT_EQ(VTYPE_INT, target_list->GetType(0)); |
| EXPECT_EQ(kIntValue, target_list->GetInt(0)); |
| |
| // Now the references are invalid. |
| EXPECT_FALSE(value->IsValid()); |
| EXPECT_FALSE(value2->IsValid()); |
| EXPECT_FALSE(binary_value2->IsValid()); |
| EXPECT_FALSE(binary_value3->IsValid()); |
| EXPECT_FALSE(binary_value4->IsValid()); |
| |
| // Verify that adding a binary to a list directly invalidates both the binary |
| // and the value that references it. |
| binary_value = CreateBinaryValue(); |
| value = CefValue::Create(); |
| EXPECT_TRUE(value->SetBinary(binary_value)); |
| target_list->SetBinary(0, binary_value); |
| EXPECT_FALSE(binary_value->IsValid()); |
| EXPECT_FALSE(value->IsValid()); |
| } |
| |
| // Test association of a CefValue binary with a CefDictionaryValue. |
| TEST(ValuesTest, ValueBinaryToDictionary) { |
| const char* key = "key"; |
| |
| // Create the binary. |
| CefRefPtr<CefBinaryValue> binary_value = CreateBinaryValue(); |
| |
| // Add the binary to a value. |
| CefRefPtr<CefValue> value = CefValue::Create(); |
| EXPECT_TRUE(value->SetBinary(binary_value)); |
| |
| // Add the value to the target dictionary. |
| CefRefPtr<CefDictionaryValue> target_dict = CefDictionaryValue::Create(); |
| EXPECT_TRUE(target_dict->SetValue(key, value)); |
| |
| // The list value is now owned by the target dictionary. |
| EXPECT_FALSE(binary_value->IsValid()); |
| |
| // The value is still valid and points to the new reference list. |
| EXPECT_TRUE(value->IsValid()); |
| |
| CefRefPtr<CefBinaryValue> binary_value2 = value->GetBinary(); |
| CefRefPtr<CefBinaryValue> binary_value3 = target_dict->GetBinary(key); |
| CefRefPtr<CefValue> value2 = target_dict->GetValue(key); |
| CefRefPtr<CefBinaryValue> binary_value4 = value2->GetBinary(); |
| |
| // All values are owned by the target dictionary. |
| EXPECT_TRUE(value->IsOwned()); |
| EXPECT_TRUE(value2->IsOwned()); |
| EXPECT_TRUE(binary_value2->IsOwned()); |
| EXPECT_TRUE(binary_value3->IsOwned()); |
| EXPECT_TRUE(binary_value4->IsOwned()); |
| |
| // All values are the same. |
| EXPECT_TRUE(binary_value2->IsSame(binary_value3)); |
| TestBinaryEqual(binary_value2, binary_value3); |
| EXPECT_TRUE(binary_value2->IsSame(binary_value4)); |
| TestBinaryEqual(binary_value2, binary_value4); |
| |
| // Change the value to something else. |
| EXPECT_TRUE(target_dict->SetInt(key, kIntValue)); |
| EXPECT_EQ(VTYPE_INT, target_dict->GetType(key)); |
| EXPECT_EQ(kIntValue, target_dict->GetInt(key)); |
| |
| // Now the references are invalid. |
| EXPECT_FALSE(value->IsValid()); |
| EXPECT_FALSE(value2->IsValid()); |
| EXPECT_FALSE(binary_value2->IsValid()); |
| EXPECT_FALSE(binary_value3->IsValid()); |
| EXPECT_FALSE(binary_value4->IsValid()); |
| |
| // Verify that adding a binary to a dictionary directly invalidates both the |
| // binary and the value that references it. |
| binary_value = CreateBinaryValue(); |
| value = CefValue::Create(); |
| EXPECT_TRUE(value->SetBinary(binary_value)); |
| target_dict->SetBinary(key, binary_value); |
| EXPECT_FALSE(binary_value->IsValid()); |
| EXPECT_FALSE(value->IsValid()); |
| } |
| |
| // Test get/set of a CefValue list type. |
| TEST(ValuesTest, ValueList) { |
| // Create the list. |
| CefRefPtr<CefListValue> list_value = CreateListValue(); |
| |
| // Create the value. |
| CefRefPtr<CefValue> value = CefValue::Create(); |
| EXPECT_TRUE(value->SetList(list_value)); |
| EXPECT_EQ(VTYPE_LIST, value->GetType()); |
| EXPECT_TRUE(value->IsValid()); |
| EXPECT_FALSE(value->IsReadOnly()); |
| EXPECT_FALSE(value->IsOwned()); |
| CreateAndCompareCopy(value); |
| |
| // Get the list reference from the value. |
| CefRefPtr<CefListValue> list_value2 = value->GetList(); |
| EXPECT_TRUE(list_value2.get()); |
| EXPECT_TRUE(list_value2->IsValid()); |
| EXPECT_FALSE(list_value2->IsOwned()); |
| EXPECT_FALSE(list_value2->IsReadOnly()); |
| |
| // The lists are the same and equal. |
| TestListEqual(list_value, list_value2); |
| EXPECT_TRUE(list_value->IsSame(list_value2)); |
| EXPECT_TRUE(list_value2->IsSame(list_value)); |
| |
| // Change a value in one list and verify that it's changed in the other list. |
| EXPECT_TRUE(list_value->SetString(0, kStringValue)); |
| EXPECT_EQ(VTYPE_STRING, list_value->GetType(0)); |
| EXPECT_STREQ(kStringValue, list_value->GetString(0).ToString().data()); |
| } |
| |
| // Test association of a CefValue list with a CefListValue. |
| TEST(ValuesTest, ValueListToList) { |
| // Create the list. |
| CefRefPtr<CefListValue> list_value = CreateListValue(); |
| |
| // Add the list to a value. |
| CefRefPtr<CefValue> value = CefValue::Create(); |
| EXPECT_TRUE(value->SetList(list_value)); |
| |
| // Add the value to the target list. |
| CefRefPtr<CefListValue> target_list = CefListValue::Create(); |
| EXPECT_TRUE(target_list->SetValue(0, value)); |
| |
| // The list value is now owned by the target list. |
| EXPECT_FALSE(list_value->IsValid()); |
| |
| // The value is still valid and points to the new reference list. |
| EXPECT_TRUE(value->IsValid()); |
| |
| CefRefPtr<CefListValue> list_value2 = value->GetList(); |
| CefRefPtr<CefListValue> list_value3 = target_list->GetList(0); |
| CefRefPtr<CefValue> value2 = target_list->GetValue(0); |
| CefRefPtr<CefListValue> list_value4 = value2->GetList(); |
| |
| // All values are owned by the target list. |
| EXPECT_TRUE(value->IsOwned()); |
| EXPECT_TRUE(value2->IsOwned()); |
| EXPECT_TRUE(list_value2->IsOwned()); |
| EXPECT_TRUE(list_value3->IsOwned()); |
| EXPECT_TRUE(list_value4->IsOwned()); |
| |
| // All values are the same. |
| EXPECT_TRUE(list_value2->IsSame(list_value3)); |
| TestListEqual(list_value2, list_value3); |
| EXPECT_TRUE(list_value2->IsSame(list_value4)); |
| TestListEqual(list_value2, list_value4); |
| |
| // Change the value to something else. |
| EXPECT_TRUE(target_list->SetInt(0, kIntValue)); |
| EXPECT_EQ(VTYPE_INT, target_list->GetType(0)); |
| EXPECT_EQ(kIntValue, target_list->GetInt(0)); |
| |
| // Now the references are invalid. |
| EXPECT_FALSE(value->IsValid()); |
| EXPECT_FALSE(value2->IsValid()); |
| EXPECT_FALSE(list_value2->IsValid()); |
| EXPECT_FALSE(list_value3->IsValid()); |
| EXPECT_FALSE(list_value4->IsValid()); |
| |
| // Verify that adding a list to a list directly invalidates both the list |
| // and the value that references it. |
| list_value = CreateListValue(); |
| value = CefValue::Create(); |
| EXPECT_TRUE(value->SetList(list_value)); |
| target_list->SetList(0, list_value); |
| EXPECT_FALSE(list_value->IsValid()); |
| EXPECT_FALSE(value->IsValid()); |
| } |
| |
| // Test association of a CefValue list with a CefDictionaryValue. |
| TEST(ValuesTest, ValueListToDictionary) { |
| const char* key = "key"; |
| |
| // Create the list. |
| CefRefPtr<CefListValue> list_value = CreateListValue(); |
| |
| // Add the list to a value. |
| CefRefPtr<CefValue> value = CefValue::Create(); |
| EXPECT_TRUE(value->SetList(list_value)); |
| |
| // Add the value to the target dictionary. |
| CefRefPtr<CefDictionaryValue> target_dict = CefDictionaryValue::Create(); |
| EXPECT_TRUE(target_dict->SetValue(key, value)); |
| |
| // The list value is now owned by the target dictionary. |
| EXPECT_FALSE(list_value->IsValid()); |
| |
| // The value is still valid and points to the new reference list. |
| EXPECT_TRUE(value->IsValid()); |
| |
| CefRefPtr<CefListValue> list_value2 = value->GetList(); |
| CefRefPtr<CefListValue> list_value3 = target_dict->GetList(key); |
| CefRefPtr<CefValue> value2 = target_dict->GetValue(key); |
| CefRefPtr<CefListValue> list_value4 = value2->GetList(); |
| |
| // All values are owned by the target dictionary. |
| EXPECT_TRUE(value->IsOwned()); |
| EXPECT_TRUE(value2->IsOwned()); |
| EXPECT_TRUE(list_value2->IsOwned()); |
| EXPECT_TRUE(list_value3->IsOwned()); |
| EXPECT_TRUE(list_value4->IsOwned()); |
| |
| // All values are the same. |
| EXPECT_TRUE(list_value2->IsSame(list_value3)); |
| TestListEqual(list_value2, list_value3); |
| EXPECT_TRUE(list_value2->IsSame(list_value4)); |
| TestListEqual(list_value2, list_value4); |
| |
| // Change the value to something else. |
| EXPECT_TRUE(target_dict->SetInt(key, kIntValue)); |
| EXPECT_EQ(VTYPE_INT, target_dict->GetType(key)); |
| EXPECT_EQ(kIntValue, target_dict->GetInt(key)); |
| |
| // Now the references are invalid. |
| EXPECT_FALSE(value->IsValid()); |
| EXPECT_FALSE(value2->IsValid()); |
| EXPECT_FALSE(list_value2->IsValid()); |
| EXPECT_FALSE(list_value3->IsValid()); |
| EXPECT_FALSE(list_value4->IsValid()); |
| |
| // Verify that adding a list to a dictionary directly invalidates both the |
| // list and the value that references it. |
| list_value = CreateListValue(); |
| value = CefValue::Create(); |
| EXPECT_TRUE(value->SetList(list_value)); |
| target_dict->SetList(key, list_value); |
| EXPECT_FALSE(list_value->IsValid()); |
| EXPECT_FALSE(value->IsValid()); |
| } |
| |
| // Test get/set of a CefValue dictionary type. |
| TEST(ValuesTest, ValueDictionary) { |
| // Create the dictionary. |
| CefRefPtr<CefDictionaryValue> dict_value = CreateDictionaryValue(); |
| |
| // Create the value. |
| CefRefPtr<CefValue> value = CefValue::Create(); |
| EXPECT_TRUE(value->SetDictionary(dict_value)); |
| EXPECT_EQ(VTYPE_DICTIONARY, value->GetType()); |
| EXPECT_TRUE(value->IsValid()); |
| EXPECT_FALSE(value->IsReadOnly()); |
| EXPECT_FALSE(value->IsOwned()); |
| CreateAndCompareCopy(value); |
| |
| // Get the dictionary reference from the value. |
| CefRefPtr<CefDictionaryValue> dict_value2 = value->GetDictionary(); |
| EXPECT_TRUE(dict_value2.get()); |
| EXPECT_TRUE(dict_value2->IsValid()); |
| EXPECT_FALSE(dict_value2->IsOwned()); |
| EXPECT_FALSE(dict_value2->IsReadOnly()); |
| |
| // The dictionaries are the same and equal. |
| TestDictionaryEqual(dict_value, dict_value2); |
| EXPECT_TRUE(dict_value->IsSame(dict_value2)); |
| EXPECT_TRUE(dict_value2->IsSame(dict_value)); |
| |
| // Change a value in one dictionary and verify that it's changed in the other |
| // dictionary. |
| EXPECT_TRUE(dict_value->SetString(kKey1, kStringValue)); |
| EXPECT_EQ(VTYPE_STRING, dict_value->GetType(kKey1)); |
| EXPECT_STREQ(kStringValue, dict_value->GetString(kKey1).ToString().data()); |
| } |
| |
| // Test association of a CefValue dictionary with a CefListValue. |
| TEST(ValuesTest, ValueDictionaryToList) { |
| // Create the dictionary. |
| CefRefPtr<CefDictionaryValue> dict_value = CreateDictionaryValue(); |
| |
| // Add the list to a value. |
| CefRefPtr<CefValue> value = CefValue::Create(); |
| EXPECT_TRUE(value->SetDictionary(dict_value)); |
| |
| // Add the value to the target list. |
| CefRefPtr<CefListValue> target_list = CefListValue::Create(); |
| EXPECT_TRUE(target_list->SetValue(0, value)); |
| |
| // The list value is now owned by the target list. |
| EXPECT_FALSE(dict_value->IsValid()); |
| |
| // The value is still valid and points to the new reference list. |
| EXPECT_TRUE(value->IsValid()); |
| |
| CefRefPtr<CefDictionaryValue> dict_value2 = value->GetDictionary(); |
| CefRefPtr<CefDictionaryValue> dict_value3 = target_list->GetDictionary(0); |
| CefRefPtr<CefValue> value2 = target_list->GetValue(0); |
| CefRefPtr<CefDictionaryValue> dict_value4 = value2->GetDictionary(); |
| |
| // All values are owned by the target list. |
| EXPECT_TRUE(value->IsOwned()); |
| EXPECT_TRUE(value2->IsOwned()); |
| EXPECT_TRUE(dict_value2->IsOwned()); |
| EXPECT_TRUE(dict_value3->IsOwned()); |
| EXPECT_TRUE(dict_value4->IsOwned()); |
| |
| // All values are the same. |
| EXPECT_TRUE(dict_value2->IsSame(dict_value3)); |
| TestDictionaryEqual(dict_value2, dict_value3); |
| EXPECT_TRUE(dict_value2->IsSame(dict_value4)); |
| TestDictionaryEqual(dict_value2, dict_value4); |
| |
| // Change the value to something else. |
| EXPECT_TRUE(target_list->SetInt(0, kIntValue)); |
| EXPECT_EQ(VTYPE_INT, target_list->GetType(0)); |
| EXPECT_EQ(kIntValue, target_list->GetInt(0)); |
| |
| // Now the references are invalid. |
| EXPECT_FALSE(value->IsValid()); |
| EXPECT_FALSE(value2->IsValid()); |
| EXPECT_FALSE(dict_value2->IsValid()); |
| EXPECT_FALSE(dict_value3->IsValid()); |
| EXPECT_FALSE(dict_value4->IsValid()); |
| |
| // Verify that adding a dictionary to a list directly invalidates both the |
| // dictionary and the value that references it. |
| dict_value = CreateDictionaryValue(); |
| value = CefValue::Create(); |
| EXPECT_TRUE(value->SetDictionary(dict_value)); |
| target_list->SetDictionary(0, dict_value); |
| EXPECT_FALSE(dict_value->IsValid()); |
| EXPECT_FALSE(value->IsValid()); |
| } |
| |
| // Test association of a CefValue dictionary with a CefDictionaryValue. |
| TEST(ValuesTest, ValueDictionaryToDictionary) { |
| const char* key = "key"; |
| |
| // Create the dictionary. |
| CefRefPtr<CefDictionaryValue> dict_value = CreateDictionaryValue(); |
| |
| // Add the list to a value. |
| CefRefPtr<CefValue> value = CefValue::Create(); |
| EXPECT_TRUE(value->SetDictionary(dict_value)); |
| |
| // Add the value to the target dictionary. |
| CefRefPtr<CefDictionaryValue> target_dict = CefDictionaryValue::Create(); |
| EXPECT_TRUE(target_dict->SetValue(key, value)); |
| |
| // The list value is now owned by the target dictionary. |
| EXPECT_FALSE(dict_value->IsValid()); |
| |
| // The value is still valid and points to the new reference list. |
| EXPECT_TRUE(value->IsValid()); |
| |
| CefRefPtr<CefDictionaryValue> dict_value2 = value->GetDictionary(); |
| CefRefPtr<CefDictionaryValue> dict_value3 = target_dict->GetDictionary(key); |
| CefRefPtr<CefValue> value2 = target_dict->GetValue(key); |
| CefRefPtr<CefDictionaryValue> dict_value4 = value2->GetDictionary(); |
| |
| // All values are owned by the target dictionary. |
| EXPECT_TRUE(value->IsOwned()); |
| EXPECT_TRUE(value2->IsOwned()); |
| EXPECT_TRUE(dict_value2->IsOwned()); |
| EXPECT_TRUE(dict_value3->IsOwned()); |
| EXPECT_TRUE(dict_value4->IsOwned()); |
| |
| // All values are the same. |
| EXPECT_TRUE(dict_value2->IsSame(dict_value3)); |
| TestDictionaryEqual(dict_value2, dict_value3); |
| EXPECT_TRUE(dict_value2->IsSame(dict_value4)); |
| TestDictionaryEqual(dict_value2, dict_value4); |
| |
| // Change the value to something else. |
| EXPECT_TRUE(target_dict->SetInt(key, kIntValue)); |
| EXPECT_EQ(VTYPE_INT, target_dict->GetType(key)); |
| EXPECT_EQ(kIntValue, target_dict->GetInt(key)); |
| |
| // Now the references are invalid. |
| EXPECT_FALSE(value->IsValid()); |
| EXPECT_FALSE(value2->IsValid()); |
| EXPECT_FALSE(dict_value2->IsValid()); |
| EXPECT_FALSE(dict_value3->IsValid()); |
| EXPECT_FALSE(dict_value4->IsValid()); |
| |
| // Verify that adding a dictionary to a dictionary directly invalidates both |
| // the dictionary and the value that references it. |
| dict_value = CreateDictionaryValue(); |
| value = CefValue::Create(); |
| EXPECT_TRUE(value->SetDictionary(dict_value)); |
| target_dict->SetDictionary(key, dict_value); |
| EXPECT_FALSE(dict_value->IsValid()); |
| EXPECT_FALSE(value->IsValid()); |
| } |