rsleevi@chromium.org | de3a6cf | 2012-04-06 12:53:02 +0900 | [diff] [blame] | 1 | // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
license.bot | f003cfe | 2008-08-24 09:55:55 +0900 | [diff] [blame] | 2 | // Use of this source code is governed by a BSD-style license that can be |
| 3 | // found in the LICENSE file. |
initial.commit | 3f4a732 | 2008-07-27 06:49:38 +0900 | [diff] [blame] | 4 | |
deanm@google.com | 19650de | 2008-08-13 23:57:51 +0900 | [diff] [blame] | 5 | #include <limits> |
| 6 | |
levin@chromium.org | 5c52868 | 2011-03-28 10:54:15 +0900 | [diff] [blame] | 7 | #include "base/memory/scoped_ptr.h" |
avi@chromium.org | 68a745c | 2013-06-11 05:11:14 +0900 | [diff] [blame] | 8 | #include "base/strings/string16.h" |
avi@chromium.org | 17f6062 | 2013-06-08 03:37:07 +0900 | [diff] [blame] | 9 | #include "base/strings/utf_string_conversions.h" |
munjal@chromium.org | 3b2d3a4 | 2010-01-16 05:09:03 +0900 | [diff] [blame] | 10 | #include "base/values.h" |
initial.commit | 3f4a732 | 2008-07-27 06:49:38 +0900 | [diff] [blame] | 11 | #include "testing/gtest/include/gtest/gtest.h" |
| 12 | |
tfarina@chromium.org | 4cdd38e | 2011-06-29 07:56:33 +0900 | [diff] [blame] | 13 | namespace base { |
initial.commit | 3f4a732 | 2008-07-27 06:49:38 +0900 | [diff] [blame] | 14 | |
tfarina@chromium.org | 4cdd38e | 2011-06-29 07:56:33 +0900 | [diff] [blame] | 15 | TEST(ValuesTest, Basic) { |
initial.commit | 3f4a732 | 2008-07-27 06:49:38 +0900 | [diff] [blame] | 16 | // Test basic dictionary getting/setting |
| 17 | DictionaryValue settings; |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 18 | std::string homepage = "http://google.com"; |
| 19 | ASSERT_FALSE(settings.GetString("global.homepage", &homepage)); |
| 20 | ASSERT_EQ(std::string("http://google.com"), homepage); |
| 21 | |
| 22 | ASSERT_FALSE(settings.Get("global", NULL)); |
tfarina@chromium.org | 50be576 | 2012-12-16 14:13:21 +0900 | [diff] [blame] | 23 | settings.Set("global", new FundamentalValue(true)); |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 24 | ASSERT_TRUE(settings.Get("global", NULL)); |
| 25 | settings.SetString("global.homepage", "http://scurvy.com"); |
| 26 | ASSERT_TRUE(settings.Get("global", NULL)); |
| 27 | homepage = "http://google.com"; |
| 28 | ASSERT_TRUE(settings.GetString("global.homepage", &homepage)); |
| 29 | ASSERT_EQ(std::string("http://scurvy.com"), homepage); |
| 30 | |
| 31 | // Test storing a dictionary in a list. |
| 32 | ListValue* toolbar_bookmarks; |
| 33 | ASSERT_FALSE( |
| 34 | settings.GetList("global.toolbar.bookmarks", &toolbar_bookmarks)); |
| 35 | |
| 36 | toolbar_bookmarks = new ListValue; |
| 37 | settings.Set("global.toolbar.bookmarks", toolbar_bookmarks); |
| 38 | ASSERT_TRUE(settings.GetList("global.toolbar.bookmarks", &toolbar_bookmarks)); |
| 39 | |
| 40 | DictionaryValue* new_bookmark = new DictionaryValue; |
| 41 | new_bookmark->SetString("name", "Froogle"); |
| 42 | new_bookmark->SetString("url", "http://froogle.com"); |
| 43 | toolbar_bookmarks->Append(new_bookmark); |
| 44 | |
| 45 | ListValue* bookmark_list; |
| 46 | ASSERT_TRUE(settings.GetList("global.toolbar.bookmarks", &bookmark_list)); |
| 47 | DictionaryValue* bookmark; |
| 48 | ASSERT_EQ(1U, bookmark_list->GetSize()); |
| 49 | ASSERT_TRUE(bookmark_list->GetDictionary(0, &bookmark)); |
| 50 | std::string bookmark_name = "Unnamed"; |
| 51 | ASSERT_TRUE(bookmark->GetString("name", &bookmark_name)); |
| 52 | ASSERT_EQ(std::string("Froogle"), bookmark_name); |
| 53 | std::string bookmark_url; |
| 54 | ASSERT_TRUE(bookmark->GetString("url", &bookmark_url)); |
| 55 | ASSERT_EQ(std::string("http://froogle.com"), bookmark_url); |
| 56 | } |
| 57 | |
tfarina@chromium.org | 4cdd38e | 2011-06-29 07:56:33 +0900 | [diff] [blame] | 58 | TEST(ValuesTest, List) { |
aa@chromium.org | c93b02f | 2009-01-21 06:05:32 +0900 | [diff] [blame] | 59 | scoped_ptr<ListValue> mixed_list(new ListValue()); |
tfarina@chromium.org | 50be576 | 2012-12-16 14:13:21 +0900 | [diff] [blame] | 60 | mixed_list->Set(0, new FundamentalValue(true)); |
| 61 | mixed_list->Set(1, new FundamentalValue(42)); |
| 62 | mixed_list->Set(2, new FundamentalValue(88.8)); |
| 63 | mixed_list->Set(3, new StringValue("foo")); |
aa@chromium.org | c93b02f | 2009-01-21 06:05:32 +0900 | [diff] [blame] | 64 | ASSERT_EQ(4u, mixed_list->GetSize()); |
maruel@chromium.org | 8fe7adc | 2009-03-04 00:01:12 +0900 | [diff] [blame] | 65 | |
aa@chromium.org | c93b02f | 2009-01-21 06:05:32 +0900 | [diff] [blame] | 66 | Value *value = NULL; |
| 67 | bool bool_value = false; |
| 68 | int int_value = 0; |
| 69 | double double_value = 0.0; |
| 70 | std::string string_value; |
| 71 | |
| 72 | ASSERT_FALSE(mixed_list->Get(4, &value)); |
| 73 | |
| 74 | ASSERT_FALSE(mixed_list->GetInteger(0, &int_value)); |
| 75 | ASSERT_EQ(0, int_value); |
yusukes@google.com | 0b18b53 | 2011-05-02 10:59:21 +0900 | [diff] [blame] | 76 | ASSERT_FALSE(mixed_list->GetBoolean(1, &bool_value)); |
| 77 | ASSERT_FALSE(bool_value); |
aa@chromium.org | c93b02f | 2009-01-21 06:05:32 +0900 | [diff] [blame] | 78 | ASSERT_FALSE(mixed_list->GetString(2, &string_value)); |
| 79 | ASSERT_EQ("", string_value); |
yusukes@google.com | 0b18b53 | 2011-05-02 10:59:21 +0900 | [diff] [blame] | 80 | ASSERT_FALSE(mixed_list->GetInteger(2, &int_value)); |
| 81 | ASSERT_EQ(0, int_value); |
aa@chromium.org | c93b02f | 2009-01-21 06:05:32 +0900 | [diff] [blame] | 82 | ASSERT_FALSE(mixed_list->GetBoolean(3, &bool_value)); |
thakis@chromium.org | c753303 | 2010-10-04 06:44:39 +0900 | [diff] [blame] | 83 | ASSERT_FALSE(bool_value); |
aa@chromium.org | c93b02f | 2009-01-21 06:05:32 +0900 | [diff] [blame] | 84 | |
| 85 | ASSERT_TRUE(mixed_list->GetBoolean(0, &bool_value)); |
thakis@chromium.org | c753303 | 2010-10-04 06:44:39 +0900 | [diff] [blame] | 86 | ASSERT_TRUE(bool_value); |
aa@chromium.org | c93b02f | 2009-01-21 06:05:32 +0900 | [diff] [blame] | 87 | ASSERT_TRUE(mixed_list->GetInteger(1, &int_value)); |
| 88 | ASSERT_EQ(42, int_value); |
yusukes@google.com | 0b18b53 | 2011-05-02 10:59:21 +0900 | [diff] [blame] | 89 | // implicit conversion from Integer to Double should be possible. |
| 90 | ASSERT_TRUE(mixed_list->GetDouble(1, &double_value)); |
| 91 | ASSERT_EQ(42, double_value); |
arv@chromium.org | 13413eb | 2011-02-01 10:02:07 +0900 | [diff] [blame] | 92 | ASSERT_TRUE(mixed_list->GetDouble(2, &double_value)); |
aa@chromium.org | c93b02f | 2009-01-21 06:05:32 +0900 | [diff] [blame] | 93 | ASSERT_EQ(88.8, double_value); |
| 94 | ASSERT_TRUE(mixed_list->GetString(3, &string_value)); |
| 95 | ASSERT_EQ("foo", string_value); |
pastarmovj@chromium.org | 1602a47 | 2011-09-20 00:23:10 +0900 | [diff] [blame] | 96 | |
| 97 | // Try searching in the mixed list. |
tfarina@chromium.org | 50be576 | 2012-12-16 14:13:21 +0900 | [diff] [blame] | 98 | base::FundamentalValue sought_value(42); |
| 99 | base::FundamentalValue not_found_value(false); |
pastarmovj@chromium.org | 1602a47 | 2011-09-20 00:23:10 +0900 | [diff] [blame] | 100 | |
tfarina@chromium.org | 50be576 | 2012-12-16 14:13:21 +0900 | [diff] [blame] | 101 | ASSERT_NE(mixed_list->end(), mixed_list->Find(sought_value)); |
| 102 | ASSERT_TRUE((*mixed_list->Find(sought_value))->GetAsInteger(&int_value)); |
pastarmovj@chromium.org | 1602a47 | 2011-09-20 00:23:10 +0900 | [diff] [blame] | 103 | ASSERT_EQ(42, int_value); |
tfarina@chromium.org | 50be576 | 2012-12-16 14:13:21 +0900 | [diff] [blame] | 104 | ASSERT_EQ(mixed_list->end(), mixed_list->Find(not_found_value)); |
aa@chromium.org | c93b02f | 2009-01-21 06:05:32 +0900 | [diff] [blame] | 105 | } |
| 106 | |
tfarina@chromium.org | 4cdd38e | 2011-06-29 07:56:33 +0900 | [diff] [blame] | 107 | TEST(ValuesTest, BinaryValue) { |
rpaquay@chromium.org | 7b1dfba | 2013-01-08 12:16:22 +0900 | [diff] [blame] | 108 | // Default constructor creates a BinaryValue with a null buffer and size 0. |
| 109 | scoped_ptr<BinaryValue> binary(new BinaryValue()); |
patrick@chromium.org | c658546 | 2009-03-25 08:37:14 +0900 | [diff] [blame] | 110 | ASSERT_TRUE(binary.get()); |
rpaquay@chromium.org | 7b1dfba | 2013-01-08 12:16:22 +0900 | [diff] [blame] | 111 | ASSERT_EQ(NULL, binary->GetBuffer()); |
mmentovai@google.com | 691ecef | 2008-08-22 01:24:51 +0900 | [diff] [blame] | 112 | ASSERT_EQ(0U, binary->GetSize()); |
initial.commit | 3f4a732 | 2008-07-27 06:49:38 +0900 | [diff] [blame] | 113 | |
| 114 | // Test the common case of a non-empty buffer |
rpaquay@chromium.org | 7b1dfba | 2013-01-08 12:16:22 +0900 | [diff] [blame] | 115 | char* buffer = new char[15]; |
| 116 | binary.reset(new BinaryValue(scoped_ptr<char[]>(buffer), 15)); |
patrick@chromium.org | c658546 | 2009-03-25 08:37:14 +0900 | [diff] [blame] | 117 | ASSERT_TRUE(binary.get()); |
initial.commit | 3f4a732 | 2008-07-27 06:49:38 +0900 | [diff] [blame] | 118 | ASSERT_TRUE(binary->GetBuffer()); |
| 119 | ASSERT_EQ(buffer, binary->GetBuffer()); |
mmentovai@google.com | 691ecef | 2008-08-22 01:24:51 +0900 | [diff] [blame] | 120 | ASSERT_EQ(15U, binary->GetSize()); |
initial.commit | 3f4a732 | 2008-07-27 06:49:38 +0900 | [diff] [blame] | 121 | |
| 122 | char stack_buffer[42]; |
| 123 | memset(stack_buffer, '!', 42); |
patrick@chromium.org | c658546 | 2009-03-25 08:37:14 +0900 | [diff] [blame] | 124 | binary.reset(BinaryValue::CreateWithCopiedBuffer(stack_buffer, 42)); |
| 125 | ASSERT_TRUE(binary.get()); |
initial.commit | 3f4a732 | 2008-07-27 06:49:38 +0900 | [diff] [blame] | 126 | ASSERT_TRUE(binary->GetBuffer()); |
| 127 | ASSERT_NE(stack_buffer, binary->GetBuffer()); |
mmentovai@google.com | 691ecef | 2008-08-22 01:24:51 +0900 | [diff] [blame] | 128 | ASSERT_EQ(42U, binary->GetSize()); |
initial.commit | 3f4a732 | 2008-07-27 06:49:38 +0900 | [diff] [blame] | 129 | ASSERT_EQ(0, memcmp(stack_buffer, binary->GetBuffer(), binary->GetSize())); |
initial.commit | 3f4a732 | 2008-07-27 06:49:38 +0900 | [diff] [blame] | 130 | } |
| 131 | |
tfarina@chromium.org | 4cdd38e | 2011-06-29 07:56:33 +0900 | [diff] [blame] | 132 | TEST(ValuesTest, StringValue) { |
estade@chromium.org | fe74951 | 2014-01-30 19:32:41 +0900 | [diff] [blame] | 133 | // Test overloaded StringValue constructor. |
tfarina@chromium.org | 50be576 | 2012-12-16 14:13:21 +0900 | [diff] [blame] | 134 | scoped_ptr<Value> narrow_value(new StringValue("narrow")); |
patrick@chromium.org | c658546 | 2009-03-25 08:37:14 +0900 | [diff] [blame] | 135 | ASSERT_TRUE(narrow_value.get()); |
scherkus@chromium.org | 2b923e7 | 2008-12-11 10:23:17 +0900 | [diff] [blame] | 136 | ASSERT_TRUE(narrow_value->IsType(Value::TYPE_STRING)); |
tfarina@chromium.org | 50be576 | 2012-12-16 14:13:21 +0900 | [diff] [blame] | 137 | scoped_ptr<Value> utf16_value(new StringValue(ASCIIToUTF16("utf16"))); |
viettrungluu@chromium.org | 31b80ba | 2010-08-04 00:42:58 +0900 | [diff] [blame] | 138 | ASSERT_TRUE(utf16_value.get()); |
| 139 | ASSERT_TRUE(utf16_value->IsType(Value::TYPE_STRING)); |
| 140 | |
estade@chromium.org | 6ebcd52 | 2014-02-12 07:57:34 +0900 | [diff] [blame] | 141 | // Test overloaded GetAsString. |
viettrungluu@chromium.org | 31b80ba | 2010-08-04 00:42:58 +0900 | [diff] [blame] | 142 | std::string narrow = "http://google.com"; |
| 143 | string16 utf16 = ASCIIToUTF16("http://google.com"); |
estade@chromium.org | 6ebcd52 | 2014-02-12 07:57:34 +0900 | [diff] [blame] | 144 | const StringValue* string_value = NULL; |
viettrungluu@chromium.org | 31b80ba | 2010-08-04 00:42:58 +0900 | [diff] [blame] | 145 | ASSERT_TRUE(narrow_value->GetAsString(&narrow)); |
| 146 | ASSERT_TRUE(narrow_value->GetAsString(&utf16)); |
estade@chromium.org | 6ebcd52 | 2014-02-12 07:57:34 +0900 | [diff] [blame] | 147 | ASSERT_TRUE(narrow_value->GetAsString(&string_value)); |
viettrungluu@chromium.org | 31b80ba | 2010-08-04 00:42:58 +0900 | [diff] [blame] | 148 | ASSERT_EQ(std::string("narrow"), narrow); |
| 149 | ASSERT_EQ(ASCIIToUTF16("narrow"), utf16); |
estade@chromium.org | 6ebcd52 | 2014-02-12 07:57:34 +0900 | [diff] [blame] | 150 | ASSERT_EQ(string_value->GetString(), narrow); |
viettrungluu@chromium.org | 31b80ba | 2010-08-04 00:42:58 +0900 | [diff] [blame] | 151 | |
| 152 | ASSERT_TRUE(utf16_value->GetAsString(&narrow)); |
| 153 | ASSERT_TRUE(utf16_value->GetAsString(&utf16)); |
estade@chromium.org | 6ebcd52 | 2014-02-12 07:57:34 +0900 | [diff] [blame] | 154 | ASSERT_TRUE(utf16_value->GetAsString(&string_value)); |
viettrungluu@chromium.org | 31b80ba | 2010-08-04 00:42:58 +0900 | [diff] [blame] | 155 | ASSERT_EQ(std::string("utf16"), narrow); |
| 156 | ASSERT_EQ(ASCIIToUTF16("utf16"), utf16); |
estade@chromium.org | 6ebcd52 | 2014-02-12 07:57:34 +0900 | [diff] [blame] | 157 | ASSERT_EQ(string_value->GetString(), narrow); |
| 158 | |
| 159 | // Don't choke on NULL values. |
| 160 | ASSERT_TRUE(narrow_value->GetAsString(static_cast<string16*>(NULL))); |
| 161 | ASSERT_TRUE(narrow_value->GetAsString(static_cast<std::string*>(NULL))); |
| 162 | ASSERT_TRUE(narrow_value->GetAsString( |
| 163 | static_cast<const StringValue**>(NULL))); |
viettrungluu@chromium.org | 31b80ba | 2010-08-04 00:42:58 +0900 | [diff] [blame] | 164 | } |
| 165 | |
initial.commit | 3f4a732 | 2008-07-27 06:49:38 +0900 | [diff] [blame] | 166 | // This is a Value object that allows us to tell if it's been |
| 167 | // properly deleted by modifying the value of external flag on destruction. |
| 168 | class DeletionTestValue : public Value { |
finnur@chromium.org | 07b7b08 | 2009-07-03 11:28:55 +0900 | [diff] [blame] | 169 | public: |
erg@google.com | bf6ce9f | 2010-01-27 08:08:02 +0900 | [diff] [blame] | 170 | explicit DeletionTestValue(bool* deletion_flag) : Value(TYPE_NULL) { |
initial.commit | 3f4a732 | 2008-07-27 06:49:38 +0900 | [diff] [blame] | 171 | Init(deletion_flag); // Separate function so that we can use ASSERT_* |
| 172 | } |
| 173 | |
| 174 | void Init(bool* deletion_flag) { |
| 175 | ASSERT_TRUE(deletion_flag); |
| 176 | deletion_flag_ = deletion_flag; |
| 177 | *deletion_flag_ = false; |
| 178 | } |
| 179 | |
rsleevi@chromium.org | de3a6cf | 2012-04-06 12:53:02 +0900 | [diff] [blame] | 180 | virtual ~DeletionTestValue() { |
initial.commit | 3f4a732 | 2008-07-27 06:49:38 +0900 | [diff] [blame] | 181 | *deletion_flag_ = true; |
| 182 | } |
| 183 | |
finnur@chromium.org | 07b7b08 | 2009-07-03 11:28:55 +0900 | [diff] [blame] | 184 | private: |
initial.commit | 3f4a732 | 2008-07-27 06:49:38 +0900 | [diff] [blame] | 185 | bool* deletion_flag_; |
| 186 | }; |
| 187 | |
tfarina@chromium.org | 4cdd38e | 2011-06-29 07:56:33 +0900 | [diff] [blame] | 188 | TEST(ValuesTest, ListDeletion) { |
initial.commit | 3f4a732 | 2008-07-27 06:49:38 +0900 | [diff] [blame] | 189 | bool deletion_flag = true; |
| 190 | |
| 191 | { |
| 192 | ListValue list; |
| 193 | list.Append(new DeletionTestValue(&deletion_flag)); |
| 194 | EXPECT_FALSE(deletion_flag); |
| 195 | } |
| 196 | EXPECT_TRUE(deletion_flag); |
| 197 | |
| 198 | { |
| 199 | ListValue list; |
| 200 | list.Append(new DeletionTestValue(&deletion_flag)); |
| 201 | EXPECT_FALSE(deletion_flag); |
| 202 | list.Clear(); |
| 203 | EXPECT_TRUE(deletion_flag); |
| 204 | } |
| 205 | |
| 206 | { |
| 207 | ListValue list; |
| 208 | list.Append(new DeletionTestValue(&deletion_flag)); |
| 209 | EXPECT_FALSE(deletion_flag); |
| 210 | EXPECT_TRUE(list.Set(0, Value::CreateNullValue())); |
| 211 | EXPECT_TRUE(deletion_flag); |
| 212 | } |
| 213 | } |
| 214 | |
tfarina@chromium.org | 4cdd38e | 2011-06-29 07:56:33 +0900 | [diff] [blame] | 215 | TEST(ValuesTest, ListRemoval) { |
initial.commit | 3f4a732 | 2008-07-27 06:49:38 +0900 | [diff] [blame] | 216 | bool deletion_flag = true; |
bauerb@chromium.org | ae43e0a | 2013-08-06 22:33:04 +0900 | [diff] [blame] | 217 | scoped_ptr<Value> removed_item; |
initial.commit | 3f4a732 | 2008-07-27 06:49:38 +0900 | [diff] [blame] | 218 | |
| 219 | { |
| 220 | ListValue list; |
| 221 | list.Append(new DeletionTestValue(&deletion_flag)); |
| 222 | EXPECT_FALSE(deletion_flag); |
mmentovai@google.com | 691ecef | 2008-08-22 01:24:51 +0900 | [diff] [blame] | 223 | EXPECT_EQ(1U, list.GetSize()); |
deanm@google.com | 19650de | 2008-08-13 23:57:51 +0900 | [diff] [blame] | 224 | EXPECT_FALSE(list.Remove(std::numeric_limits<size_t>::max(), |
| 225 | &removed_item)); |
initial.commit | 3f4a732 | 2008-07-27 06:49:38 +0900 | [diff] [blame] | 226 | EXPECT_FALSE(list.Remove(1, &removed_item)); |
| 227 | EXPECT_TRUE(list.Remove(0, &removed_item)); |
| 228 | ASSERT_TRUE(removed_item); |
mmentovai@google.com | 691ecef | 2008-08-22 01:24:51 +0900 | [diff] [blame] | 229 | EXPECT_EQ(0U, list.GetSize()); |
initial.commit | 3f4a732 | 2008-07-27 06:49:38 +0900 | [diff] [blame] | 230 | } |
| 231 | EXPECT_FALSE(deletion_flag); |
bauerb@chromium.org | ae43e0a | 2013-08-06 22:33:04 +0900 | [diff] [blame] | 232 | removed_item.reset(); |
initial.commit | 3f4a732 | 2008-07-27 06:49:38 +0900 | [diff] [blame] | 233 | EXPECT_TRUE(deletion_flag); |
| 234 | |
| 235 | { |
| 236 | ListValue list; |
| 237 | list.Append(new DeletionTestValue(&deletion_flag)); |
| 238 | EXPECT_FALSE(deletion_flag); |
| 239 | EXPECT_TRUE(list.Remove(0, NULL)); |
| 240 | EXPECT_TRUE(deletion_flag); |
mmentovai@google.com | 691ecef | 2008-08-22 01:24:51 +0900 | [diff] [blame] | 241 | EXPECT_EQ(0U, list.GetSize()); |
initial.commit | 3f4a732 | 2008-07-27 06:49:38 +0900 | [diff] [blame] | 242 | } |
pkasting@chromium.org | dfe6a69 | 2009-12-01 04:59:11 +0900 | [diff] [blame] | 243 | |
| 244 | { |
| 245 | ListValue list; |
| 246 | DeletionTestValue* value = new DeletionTestValue(&deletion_flag); |
| 247 | list.Append(value); |
| 248 | EXPECT_FALSE(deletion_flag); |
tfarina@chromium.org | 09cf434 | 2011-08-14 02:34:31 +0900 | [diff] [blame] | 249 | size_t index = 0; |
| 250 | list.Remove(*value, &index); |
| 251 | EXPECT_EQ(0U, index); |
pkasting@chromium.org | dfe6a69 | 2009-12-01 04:59:11 +0900 | [diff] [blame] | 252 | EXPECT_TRUE(deletion_flag); |
| 253 | EXPECT_EQ(0U, list.GetSize()); |
| 254 | } |
initial.commit | 3f4a732 | 2008-07-27 06:49:38 +0900 | [diff] [blame] | 255 | } |
| 256 | |
tfarina@chromium.org | 4cdd38e | 2011-06-29 07:56:33 +0900 | [diff] [blame] | 257 | TEST(ValuesTest, DictionaryDeletion) { |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 258 | std::string key = "test"; |
| 259 | bool deletion_flag = true; |
| 260 | |
| 261 | { |
| 262 | DictionaryValue dict; |
| 263 | dict.Set(key, new DeletionTestValue(&deletion_flag)); |
| 264 | EXPECT_FALSE(deletion_flag); |
| 265 | } |
| 266 | EXPECT_TRUE(deletion_flag); |
| 267 | |
| 268 | { |
| 269 | DictionaryValue dict; |
| 270 | dict.Set(key, new DeletionTestValue(&deletion_flag)); |
| 271 | EXPECT_FALSE(deletion_flag); |
| 272 | dict.Clear(); |
| 273 | EXPECT_TRUE(deletion_flag); |
| 274 | } |
| 275 | |
| 276 | { |
| 277 | DictionaryValue dict; |
| 278 | dict.Set(key, new DeletionTestValue(&deletion_flag)); |
| 279 | EXPECT_FALSE(deletion_flag); |
| 280 | dict.Set(key, Value::CreateNullValue()); |
| 281 | EXPECT_TRUE(deletion_flag); |
| 282 | } |
| 283 | } |
| 284 | |
tfarina@chromium.org | 4cdd38e | 2011-06-29 07:56:33 +0900 | [diff] [blame] | 285 | TEST(ValuesTest, DictionaryRemoval) { |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 286 | std::string key = "test"; |
| 287 | bool deletion_flag = true; |
bauerb@chromium.org | ae43e0a | 2013-08-06 22:33:04 +0900 | [diff] [blame] | 288 | scoped_ptr<Value> removed_item; |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 289 | |
| 290 | { |
| 291 | DictionaryValue dict; |
| 292 | dict.Set(key, new DeletionTestValue(&deletion_flag)); |
| 293 | EXPECT_FALSE(deletion_flag); |
| 294 | EXPECT_TRUE(dict.HasKey(key)); |
| 295 | EXPECT_FALSE(dict.Remove("absent key", &removed_item)); |
| 296 | EXPECT_TRUE(dict.Remove(key, &removed_item)); |
| 297 | EXPECT_FALSE(dict.HasKey(key)); |
| 298 | ASSERT_TRUE(removed_item); |
| 299 | } |
| 300 | EXPECT_FALSE(deletion_flag); |
bauerb@chromium.org | ae43e0a | 2013-08-06 22:33:04 +0900 | [diff] [blame] | 301 | removed_item.reset(); |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 302 | EXPECT_TRUE(deletion_flag); |
| 303 | |
| 304 | { |
| 305 | DictionaryValue dict; |
| 306 | dict.Set(key, new DeletionTestValue(&deletion_flag)); |
| 307 | EXPECT_FALSE(deletion_flag); |
| 308 | EXPECT_TRUE(dict.HasKey(key)); |
| 309 | EXPECT_TRUE(dict.Remove(key, NULL)); |
| 310 | EXPECT_TRUE(deletion_flag); |
| 311 | EXPECT_FALSE(dict.HasKey(key)); |
| 312 | } |
| 313 | } |
| 314 | |
tfarina@chromium.org | 4cdd38e | 2011-06-29 07:56:33 +0900 | [diff] [blame] | 315 | TEST(ValuesTest, DictionaryWithoutPathExpansion) { |
pkasting@chromium.org | 36515db | 2009-11-26 05:47:52 +0900 | [diff] [blame] | 316 | DictionaryValue dict; |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 317 | dict.Set("this.is.expanded", Value::CreateNullValue()); |
| 318 | dict.SetWithoutPathExpansion("this.isnt.expanded", Value::CreateNullValue()); |
| 319 | |
| 320 | EXPECT_FALSE(dict.HasKey("this.is.expanded")); |
| 321 | EXPECT_TRUE(dict.HasKey("this")); |
| 322 | Value* value1; |
| 323 | EXPECT_TRUE(dict.Get("this", &value1)); |
| 324 | DictionaryValue* value2; |
| 325 | ASSERT_TRUE(dict.GetDictionaryWithoutPathExpansion("this", &value2)); |
| 326 | EXPECT_EQ(value1, value2); |
| 327 | EXPECT_EQ(1U, value2->size()); |
| 328 | |
| 329 | EXPECT_TRUE(dict.HasKey("this.isnt.expanded")); |
| 330 | Value* value3; |
| 331 | EXPECT_FALSE(dict.Get("this.isnt.expanded", &value3)); |
| 332 | Value* value4; |
| 333 | ASSERT_TRUE(dict.GetWithoutPathExpansion("this.isnt.expanded", &value4)); |
| 334 | EXPECT_EQ(Value::TYPE_NULL, value4->GetType()); |
| 335 | } |
| 336 | |
gab@chromium.org | 903d5c9 | 2013-11-27 10:38:24 +0900 | [diff] [blame] | 337 | TEST(ValuesTest, DictionaryRemovePath) { |
| 338 | DictionaryValue dict; |
estade@chromium.org | fe74951 | 2014-01-30 19:32:41 +0900 | [diff] [blame] | 339 | dict.Set("a.long.way.down", new FundamentalValue(1)); |
| 340 | dict.Set("a.long.key.path", new FundamentalValue(true)); |
gab@chromium.org | 903d5c9 | 2013-11-27 10:38:24 +0900 | [diff] [blame] | 341 | |
| 342 | scoped_ptr<Value> removed_item; |
| 343 | EXPECT_TRUE(dict.RemovePath("a.long.way.down", &removed_item)); |
| 344 | ASSERT_TRUE(removed_item); |
| 345 | EXPECT_TRUE(removed_item->IsType(base::Value::TYPE_INTEGER)); |
| 346 | EXPECT_FALSE(dict.HasKey("a.long.way.down")); |
| 347 | EXPECT_FALSE(dict.HasKey("a.long.way")); |
| 348 | EXPECT_TRUE(dict.Get("a.long.key.path", NULL)); |
| 349 | |
| 350 | removed_item.reset(); |
| 351 | EXPECT_FALSE(dict.RemovePath("a.long.way.down", &removed_item)); |
| 352 | EXPECT_FALSE(removed_item); |
| 353 | EXPECT_TRUE(dict.Get("a.long.key.path", NULL)); |
| 354 | |
| 355 | removed_item.reset(); |
| 356 | EXPECT_TRUE(dict.RemovePath("a.long.key.path", &removed_item)); |
| 357 | ASSERT_TRUE(removed_item); |
| 358 | EXPECT_TRUE(removed_item->IsType(base::Value::TYPE_BOOLEAN)); |
| 359 | EXPECT_TRUE(dict.empty()); |
| 360 | } |
| 361 | |
tfarina@chromium.org | 4cdd38e | 2011-06-29 07:56:33 +0900 | [diff] [blame] | 362 | TEST(ValuesTest, DeepCopy) { |
initial.commit | 3f4a732 | 2008-07-27 06:49:38 +0900 | [diff] [blame] | 363 | DictionaryValue original_dict; |
| 364 | Value* original_null = Value::CreateNullValue(); |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 365 | original_dict.Set("null", original_null); |
tfarina@chromium.org | 50be576 | 2012-12-16 14:13:21 +0900 | [diff] [blame] | 366 | FundamentalValue* original_bool = new FundamentalValue(true); |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 367 | original_dict.Set("bool", original_bool); |
tfarina@chromium.org | 50be576 | 2012-12-16 14:13:21 +0900 | [diff] [blame] | 368 | FundamentalValue* original_int = new FundamentalValue(42); |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 369 | original_dict.Set("int", original_int); |
tfarina@chromium.org | 50be576 | 2012-12-16 14:13:21 +0900 | [diff] [blame] | 370 | FundamentalValue* original_double = new FundamentalValue(3.14); |
arv@chromium.org | 13413eb | 2011-02-01 10:02:07 +0900 | [diff] [blame] | 371 | original_dict.Set("double", original_double); |
tfarina@chromium.org | 50be576 | 2012-12-16 14:13:21 +0900 | [diff] [blame] | 372 | StringValue* original_string = new StringValue("hello"); |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 373 | original_dict.Set("string", original_string); |
tfarina@chromium.org | 50be576 | 2012-12-16 14:13:21 +0900 | [diff] [blame] | 374 | StringValue* original_string16 = new StringValue(ASCIIToUTF16("hello16")); |
viettrungluu@chromium.org | 31b80ba | 2010-08-04 00:42:58 +0900 | [diff] [blame] | 375 | original_dict.Set("string16", original_string16); |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 376 | |
rpaquay@chromium.org | 7b1dfba | 2013-01-08 12:16:22 +0900 | [diff] [blame] | 377 | scoped_ptr<char[]> original_buffer(new char[42]); |
| 378 | memset(original_buffer.get(), '!', 42); |
| 379 | BinaryValue* original_binary = new BinaryValue(original_buffer.Pass(), 42); |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 380 | original_dict.Set("binary", original_binary); |
| 381 | |
| 382 | ListValue* original_list = new ListValue(); |
tfarina@chromium.org | 50be576 | 2012-12-16 14:13:21 +0900 | [diff] [blame] | 383 | FundamentalValue* original_list_element_0 = new FundamentalValue(0); |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 384 | original_list->Append(original_list_element_0); |
tfarina@chromium.org | 50be576 | 2012-12-16 14:13:21 +0900 | [diff] [blame] | 385 | FundamentalValue* original_list_element_1 = new FundamentalValue(1); |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 386 | original_list->Append(original_list_element_1); |
| 387 | original_dict.Set("list", original_list); |
| 388 | |
battre@chromium.org | 29eaa25 | 2011-11-26 10:11:44 +0900 | [diff] [blame] | 389 | DictionaryValue* original_nested_dictionary = new DictionaryValue(); |
tfarina@chromium.org | 50be576 | 2012-12-16 14:13:21 +0900 | [diff] [blame] | 390 | original_nested_dictionary->Set("key", new StringValue("value")); |
battre@chromium.org | 29eaa25 | 2011-11-26 10:11:44 +0900 | [diff] [blame] | 391 | original_dict.Set("dictionary", original_nested_dictionary); |
| 392 | |
akalin@chromium.org | 810f92f | 2011-01-18 11:16:59 +0900 | [diff] [blame] | 393 | scoped_ptr<DictionaryValue> copy_dict(original_dict.DeepCopy()); |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 394 | ASSERT_TRUE(copy_dict.get()); |
| 395 | ASSERT_NE(copy_dict.get(), &original_dict); |
| 396 | |
| 397 | Value* copy_null = NULL; |
| 398 | ASSERT_TRUE(copy_dict->Get("null", ©_null)); |
| 399 | ASSERT_TRUE(copy_null); |
| 400 | ASSERT_NE(copy_null, original_null); |
| 401 | ASSERT_TRUE(copy_null->IsType(Value::TYPE_NULL)); |
| 402 | |
| 403 | Value* copy_bool = NULL; |
| 404 | ASSERT_TRUE(copy_dict->Get("bool", ©_bool)); |
| 405 | ASSERT_TRUE(copy_bool); |
| 406 | ASSERT_NE(copy_bool, original_bool); |
| 407 | ASSERT_TRUE(copy_bool->IsType(Value::TYPE_BOOLEAN)); |
| 408 | bool copy_bool_value = false; |
| 409 | ASSERT_TRUE(copy_bool->GetAsBoolean(©_bool_value)); |
| 410 | ASSERT_TRUE(copy_bool_value); |
| 411 | |
| 412 | Value* copy_int = NULL; |
| 413 | ASSERT_TRUE(copy_dict->Get("int", ©_int)); |
| 414 | ASSERT_TRUE(copy_int); |
| 415 | ASSERT_NE(copy_int, original_int); |
| 416 | ASSERT_TRUE(copy_int->IsType(Value::TYPE_INTEGER)); |
| 417 | int copy_int_value = 0; |
| 418 | ASSERT_TRUE(copy_int->GetAsInteger(©_int_value)); |
| 419 | ASSERT_EQ(42, copy_int_value); |
| 420 | |
arv@chromium.org | 13413eb | 2011-02-01 10:02:07 +0900 | [diff] [blame] | 421 | Value* copy_double = NULL; |
| 422 | ASSERT_TRUE(copy_dict->Get("double", ©_double)); |
| 423 | ASSERT_TRUE(copy_double); |
| 424 | ASSERT_NE(copy_double, original_double); |
| 425 | ASSERT_TRUE(copy_double->IsType(Value::TYPE_DOUBLE)); |
| 426 | double copy_double_value = 0; |
| 427 | ASSERT_TRUE(copy_double->GetAsDouble(©_double_value)); |
| 428 | ASSERT_EQ(3.14, copy_double_value); |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 429 | |
| 430 | Value* copy_string = NULL; |
| 431 | ASSERT_TRUE(copy_dict->Get("string", ©_string)); |
| 432 | ASSERT_TRUE(copy_string); |
| 433 | ASSERT_NE(copy_string, original_string); |
| 434 | ASSERT_TRUE(copy_string->IsType(Value::TYPE_STRING)); |
| 435 | std::string copy_string_value; |
viettrungluu@chromium.org | 31b80ba | 2010-08-04 00:42:58 +0900 | [diff] [blame] | 436 | string16 copy_string16_value; |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 437 | ASSERT_TRUE(copy_string->GetAsString(©_string_value)); |
viettrungluu@chromium.org | 31b80ba | 2010-08-04 00:42:58 +0900 | [diff] [blame] | 438 | ASSERT_TRUE(copy_string->GetAsString(©_string16_value)); |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 439 | ASSERT_EQ(std::string("hello"), copy_string_value); |
viettrungluu@chromium.org | 31b80ba | 2010-08-04 00:42:58 +0900 | [diff] [blame] | 440 | ASSERT_EQ(ASCIIToUTF16("hello"), copy_string16_value); |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 441 | |
viettrungluu@chromium.org | 31b80ba | 2010-08-04 00:42:58 +0900 | [diff] [blame] | 442 | Value* copy_string16 = NULL; |
| 443 | ASSERT_TRUE(copy_dict->Get("string16", ©_string16)); |
| 444 | ASSERT_TRUE(copy_string16); |
| 445 | ASSERT_NE(copy_string16, original_string16); |
| 446 | ASSERT_TRUE(copy_string16->IsType(Value::TYPE_STRING)); |
| 447 | ASSERT_TRUE(copy_string16->GetAsString(©_string_value)); |
| 448 | ASSERT_TRUE(copy_string16->GetAsString(©_string16_value)); |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 449 | ASSERT_EQ(std::string("hello16"), copy_string_value); |
viettrungluu@chromium.org | 31b80ba | 2010-08-04 00:42:58 +0900 | [diff] [blame] | 450 | ASSERT_EQ(ASCIIToUTF16("hello16"), copy_string16_value); |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 451 | |
| 452 | Value* copy_binary = NULL; |
| 453 | ASSERT_TRUE(copy_dict->Get("binary", ©_binary)); |
| 454 | ASSERT_TRUE(copy_binary); |
| 455 | ASSERT_NE(copy_binary, original_binary); |
stevenjb@google.com | f4f5827 | 2011-08-26 10:54:00 +0900 | [diff] [blame] | 456 | ASSERT_TRUE(copy_binary->IsType(Value::TYPE_BINARY)); |
| 457 | ASSERT_NE(original_binary->GetBuffer(), |
| 458 | static_cast<BinaryValue*>(copy_binary)->GetBuffer()); |
| 459 | ASSERT_EQ(original_binary->GetSize(), |
| 460 | static_cast<BinaryValue*>(copy_binary)->GetSize()); |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 461 | ASSERT_EQ(0, memcmp(original_binary->GetBuffer(), |
stevenjb@google.com | f4f5827 | 2011-08-26 10:54:00 +0900 | [diff] [blame] | 462 | static_cast<BinaryValue*>(copy_binary)->GetBuffer(), |
| 463 | original_binary->GetSize())); |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 464 | |
| 465 | Value* copy_value = NULL; |
| 466 | ASSERT_TRUE(copy_dict->Get("list", ©_value)); |
| 467 | ASSERT_TRUE(copy_value); |
| 468 | ASSERT_NE(copy_value, original_list); |
stevenjb@google.com | f4f5827 | 2011-08-26 10:54:00 +0900 | [diff] [blame] | 469 | ASSERT_TRUE(copy_value->IsType(Value::TYPE_LIST)); |
battre@chromium.org | 29eaa25 | 2011-11-26 10:11:44 +0900 | [diff] [blame] | 470 | ListValue* copy_list = NULL; |
| 471 | ASSERT_TRUE(copy_value->GetAsList(©_list)); |
| 472 | ASSERT_TRUE(copy_list); |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 473 | ASSERT_EQ(2U, copy_list->GetSize()); |
| 474 | |
| 475 | Value* copy_list_element_0; |
| 476 | ASSERT_TRUE(copy_list->Get(0, ©_list_element_0)); |
| 477 | ASSERT_TRUE(copy_list_element_0); |
| 478 | ASSERT_NE(copy_list_element_0, original_list_element_0); |
| 479 | int copy_list_element_0_value; |
| 480 | ASSERT_TRUE(copy_list_element_0->GetAsInteger(©_list_element_0_value)); |
| 481 | ASSERT_EQ(0, copy_list_element_0_value); |
| 482 | |
| 483 | Value* copy_list_element_1; |
| 484 | ASSERT_TRUE(copy_list->Get(1, ©_list_element_1)); |
| 485 | ASSERT_TRUE(copy_list_element_1); |
| 486 | ASSERT_NE(copy_list_element_1, original_list_element_1); |
| 487 | int copy_list_element_1_value; |
| 488 | ASSERT_TRUE(copy_list_element_1->GetAsInteger(©_list_element_1_value)); |
| 489 | ASSERT_EQ(1, copy_list_element_1_value); |
battre@chromium.org | 29eaa25 | 2011-11-26 10:11:44 +0900 | [diff] [blame] | 490 | |
| 491 | copy_value = NULL; |
| 492 | ASSERT_TRUE(copy_dict->Get("dictionary", ©_value)); |
| 493 | ASSERT_TRUE(copy_value); |
| 494 | ASSERT_NE(copy_value, original_nested_dictionary); |
| 495 | ASSERT_TRUE(copy_value->IsType(Value::TYPE_DICTIONARY)); |
| 496 | DictionaryValue* copy_nested_dictionary = NULL; |
| 497 | ASSERT_TRUE(copy_value->GetAsDictionary(©_nested_dictionary)); |
| 498 | ASSERT_TRUE(copy_nested_dictionary); |
| 499 | EXPECT_TRUE(copy_nested_dictionary->HasKey("key")); |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 500 | } |
| 501 | |
tfarina@chromium.org | 4cdd38e | 2011-06-29 07:56:33 +0900 | [diff] [blame] | 502 | TEST(ValuesTest, Equals) { |
initial.commit | 3f4a732 | 2008-07-27 06:49:38 +0900 | [diff] [blame] | 503 | Value* null1 = Value::CreateNullValue(); |
| 504 | Value* null2 = Value::CreateNullValue(); |
| 505 | EXPECT_NE(null1, null2); |
| 506 | EXPECT_TRUE(null1->Equals(null2)); |
| 507 | |
tfarina@chromium.org | 50be576 | 2012-12-16 14:13:21 +0900 | [diff] [blame] | 508 | Value* boolean = new FundamentalValue(false); |
initial.commit | 3f4a732 | 2008-07-27 06:49:38 +0900 | [diff] [blame] | 509 | EXPECT_FALSE(null1->Equals(boolean)); |
| 510 | delete null1; |
| 511 | delete null2; |
| 512 | delete boolean; |
| 513 | |
| 514 | DictionaryValue dv; |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 515 | dv.SetBoolean("a", false); |
| 516 | dv.SetInteger("b", 2); |
arv@chromium.org | 13413eb | 2011-02-01 10:02:07 +0900 | [diff] [blame] | 517 | dv.SetDouble("c", 2.5); |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 518 | dv.SetString("d1", "string"); |
viettrungluu@chromium.org | b7b6aa0 | 2010-08-05 01:58:12 +0900 | [diff] [blame] | 519 | dv.SetString("d2", ASCIIToUTF16("http://google.com")); |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 520 | dv.Set("e", Value::CreateNullValue()); |
| 521 | |
mnissler@chromium.org | fd5fde9 | 2010-08-19 01:23:40 +0900 | [diff] [blame] | 522 | scoped_ptr<DictionaryValue> copy; |
akalin@chromium.org | 810f92f | 2011-01-18 11:16:59 +0900 | [diff] [blame] | 523 | copy.reset(dv.DeepCopy()); |
mnissler@chromium.org | fd5fde9 | 2010-08-19 01:23:40 +0900 | [diff] [blame] | 524 | EXPECT_TRUE(dv.Equals(copy.get())); |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 525 | |
| 526 | ListValue* list = new ListValue; |
| 527 | list->Append(Value::CreateNullValue()); |
| 528 | list->Append(new DictionaryValue); |
| 529 | dv.Set("f", list); |
| 530 | |
mnissler@chromium.org | fd5fde9 | 2010-08-19 01:23:40 +0900 | [diff] [blame] | 531 | EXPECT_FALSE(dv.Equals(copy.get())); |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 532 | copy->Set("f", list->DeepCopy()); |
mnissler@chromium.org | fd5fde9 | 2010-08-19 01:23:40 +0900 | [diff] [blame] | 533 | EXPECT_TRUE(dv.Equals(copy.get())); |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 534 | |
tfarina@chromium.org | 50be576 | 2012-12-16 14:13:21 +0900 | [diff] [blame] | 535 | list->Append(new FundamentalValue(true)); |
mnissler@chromium.org | fd5fde9 | 2010-08-19 01:23:40 +0900 | [diff] [blame] | 536 | EXPECT_FALSE(dv.Equals(copy.get())); |
| 537 | |
| 538 | // Check if Equals detects differences in only the keys. |
akalin@chromium.org | 810f92f | 2011-01-18 11:16:59 +0900 | [diff] [blame] | 539 | copy.reset(dv.DeepCopy()); |
mnissler@chromium.org | fd5fde9 | 2010-08-19 01:23:40 +0900 | [diff] [blame] | 540 | EXPECT_TRUE(dv.Equals(copy.get())); |
| 541 | copy->Remove("a", NULL); |
| 542 | copy->SetBoolean("aa", false); |
| 543 | EXPECT_FALSE(dv.Equals(copy.get())); |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 544 | } |
| 545 | |
tfarina@chromium.org | 4cdd38e | 2011-06-29 07:56:33 +0900 | [diff] [blame] | 546 | TEST(ValuesTest, StaticEquals) { |
bauerb@chromium.org | fbd55e1 | 2010-12-07 03:13:43 +0900 | [diff] [blame] | 547 | scoped_ptr<Value> null1(Value::CreateNullValue()); |
| 548 | scoped_ptr<Value> null2(Value::CreateNullValue()); |
| 549 | EXPECT_TRUE(Value::Equals(null1.get(), null2.get())); |
| 550 | EXPECT_TRUE(Value::Equals(NULL, NULL)); |
| 551 | |
tfarina@chromium.org | 50be576 | 2012-12-16 14:13:21 +0900 | [diff] [blame] | 552 | scoped_ptr<Value> i42(new FundamentalValue(42)); |
| 553 | scoped_ptr<Value> j42(new FundamentalValue(42)); |
| 554 | scoped_ptr<Value> i17(new FundamentalValue(17)); |
bauerb@chromium.org | fbd55e1 | 2010-12-07 03:13:43 +0900 | [diff] [blame] | 555 | EXPECT_TRUE(Value::Equals(i42.get(), i42.get())); |
| 556 | EXPECT_TRUE(Value::Equals(j42.get(), i42.get())); |
| 557 | EXPECT_TRUE(Value::Equals(i42.get(), j42.get())); |
| 558 | EXPECT_FALSE(Value::Equals(i42.get(), i17.get())); |
| 559 | EXPECT_FALSE(Value::Equals(i42.get(), NULL)); |
| 560 | EXPECT_FALSE(Value::Equals(NULL, i42.get())); |
| 561 | |
| 562 | // NULL and Value::CreateNullValue() are intentionally different: We need |
| 563 | // support for NULL as a return value for "undefined" without caring for |
| 564 | // ownership of the pointer. |
| 565 | EXPECT_FALSE(Value::Equals(null1.get(), NULL)); |
| 566 | EXPECT_FALSE(Value::Equals(NULL, null1.get())); |
| 567 | } |
| 568 | |
tfarina@chromium.org | 4cdd38e | 2011-06-29 07:56:33 +0900 | [diff] [blame] | 569 | TEST(ValuesTest, DeepCopyCovariantReturnTypes) { |
akalin@chromium.org | 810f92f | 2011-01-18 11:16:59 +0900 | [diff] [blame] | 570 | DictionaryValue original_dict; |
| 571 | Value* original_null = Value::CreateNullValue(); |
| 572 | original_dict.Set("null", original_null); |
tfarina@chromium.org | 50be576 | 2012-12-16 14:13:21 +0900 | [diff] [blame] | 573 | FundamentalValue* original_bool = new FundamentalValue(true); |
akalin@chromium.org | 810f92f | 2011-01-18 11:16:59 +0900 | [diff] [blame] | 574 | original_dict.Set("bool", original_bool); |
tfarina@chromium.org | 50be576 | 2012-12-16 14:13:21 +0900 | [diff] [blame] | 575 | FundamentalValue* original_int = new FundamentalValue(42); |
akalin@chromium.org | 810f92f | 2011-01-18 11:16:59 +0900 | [diff] [blame] | 576 | original_dict.Set("int", original_int); |
tfarina@chromium.org | 50be576 | 2012-12-16 14:13:21 +0900 | [diff] [blame] | 577 | FundamentalValue* original_double = new FundamentalValue(3.14); |
arv@chromium.org | 13413eb | 2011-02-01 10:02:07 +0900 | [diff] [blame] | 578 | original_dict.Set("double", original_double); |
tfarina@chromium.org | 50be576 | 2012-12-16 14:13:21 +0900 | [diff] [blame] | 579 | StringValue* original_string = new StringValue("hello"); |
akalin@chromium.org | 810f92f | 2011-01-18 11:16:59 +0900 | [diff] [blame] | 580 | original_dict.Set("string", original_string); |
tfarina@chromium.org | 50be576 | 2012-12-16 14:13:21 +0900 | [diff] [blame] | 581 | StringValue* original_string16 = new StringValue(ASCIIToUTF16("hello16")); |
akalin@chromium.org | 810f92f | 2011-01-18 11:16:59 +0900 | [diff] [blame] | 582 | original_dict.Set("string16", original_string16); |
| 583 | |
rpaquay@chromium.org | 7b1dfba | 2013-01-08 12:16:22 +0900 | [diff] [blame] | 584 | scoped_ptr<char[]> original_buffer(new char[42]); |
| 585 | memset(original_buffer.get(), '!', 42); |
| 586 | BinaryValue* original_binary = new BinaryValue(original_buffer.Pass(), 42); |
akalin@chromium.org | 810f92f | 2011-01-18 11:16:59 +0900 | [diff] [blame] | 587 | original_dict.Set("binary", original_binary); |
| 588 | |
| 589 | ListValue* original_list = new ListValue(); |
tfarina@chromium.org | 50be576 | 2012-12-16 14:13:21 +0900 | [diff] [blame] | 590 | FundamentalValue* original_list_element_0 = new FundamentalValue(0); |
akalin@chromium.org | 810f92f | 2011-01-18 11:16:59 +0900 | [diff] [blame] | 591 | original_list->Append(original_list_element_0); |
tfarina@chromium.org | 50be576 | 2012-12-16 14:13:21 +0900 | [diff] [blame] | 592 | FundamentalValue* original_list_element_1 = new FundamentalValue(1); |
akalin@chromium.org | 810f92f | 2011-01-18 11:16:59 +0900 | [diff] [blame] | 593 | original_list->Append(original_list_element_1); |
| 594 | original_dict.Set("list", original_list); |
| 595 | |
| 596 | Value* original_dict_value = &original_dict; |
| 597 | Value* original_bool_value = original_bool; |
| 598 | Value* original_int_value = original_int; |
arv@chromium.org | 13413eb | 2011-02-01 10:02:07 +0900 | [diff] [blame] | 599 | Value* original_double_value = original_double; |
akalin@chromium.org | 810f92f | 2011-01-18 11:16:59 +0900 | [diff] [blame] | 600 | Value* original_string_value = original_string; |
| 601 | Value* original_string16_value = original_string16; |
| 602 | Value* original_binary_value = original_binary; |
| 603 | Value* original_list_value = original_list; |
| 604 | |
| 605 | scoped_ptr<Value> copy_dict_value(original_dict_value->DeepCopy()); |
| 606 | scoped_ptr<Value> copy_bool_value(original_bool_value->DeepCopy()); |
| 607 | scoped_ptr<Value> copy_int_value(original_int_value->DeepCopy()); |
arv@chromium.org | 13413eb | 2011-02-01 10:02:07 +0900 | [diff] [blame] | 608 | scoped_ptr<Value> copy_double_value(original_double_value->DeepCopy()); |
akalin@chromium.org | 810f92f | 2011-01-18 11:16:59 +0900 | [diff] [blame] | 609 | scoped_ptr<Value> copy_string_value(original_string_value->DeepCopy()); |
| 610 | scoped_ptr<Value> copy_string16_value(original_string16_value->DeepCopy()); |
| 611 | scoped_ptr<Value> copy_binary_value(original_binary_value->DeepCopy()); |
| 612 | scoped_ptr<Value> copy_list_value(original_list_value->DeepCopy()); |
| 613 | |
| 614 | EXPECT_TRUE(original_dict_value->Equals(copy_dict_value.get())); |
| 615 | EXPECT_TRUE(original_bool_value->Equals(copy_bool_value.get())); |
| 616 | EXPECT_TRUE(original_int_value->Equals(copy_int_value.get())); |
arv@chromium.org | 13413eb | 2011-02-01 10:02:07 +0900 | [diff] [blame] | 617 | EXPECT_TRUE(original_double_value->Equals(copy_double_value.get())); |
akalin@chromium.org | 810f92f | 2011-01-18 11:16:59 +0900 | [diff] [blame] | 618 | EXPECT_TRUE(original_string_value->Equals(copy_string_value.get())); |
| 619 | EXPECT_TRUE(original_string16_value->Equals(copy_string16_value.get())); |
| 620 | EXPECT_TRUE(original_binary_value->Equals(copy_binary_value.get())); |
| 621 | EXPECT_TRUE(original_list_value->Equals(copy_list_value.get())); |
| 622 | } |
| 623 | |
tfarina@chromium.org | 4cdd38e | 2011-06-29 07:56:33 +0900 | [diff] [blame] | 624 | TEST(ValuesTest, RemoveEmptyChildren) { |
tony@chromium.org | e4948ab | 2009-12-02 09:20:32 +0900 | [diff] [blame] | 625 | scoped_ptr<DictionaryValue> root(new DictionaryValue); |
| 626 | // Remove empty lists and dictionaries. |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 627 | root->Set("empty_dict", new DictionaryValue); |
| 628 | root->Set("empty_list", new ListValue); |
| 629 | root->SetWithoutPathExpansion("a.b.c.d.e", new DictionaryValue); |
| 630 | root.reset(root->DeepCopyWithoutEmptyChildren()); |
| 631 | EXPECT_TRUE(root->empty()); |
| 632 | |
| 633 | // Make sure we don't prune too much. |
| 634 | root->SetBoolean("bool", true); |
| 635 | root->Set("empty_dict", new DictionaryValue); |
dcheng@chromium.org | 8164c2c | 2013-04-09 17:46:45 +0900 | [diff] [blame] | 636 | root->SetString("empty_string", std::string()); |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 637 | root.reset(root->DeepCopyWithoutEmptyChildren()); |
| 638 | EXPECT_EQ(2U, root->size()); |
| 639 | |
| 640 | // Should do nothing. |
| 641 | root.reset(root->DeepCopyWithoutEmptyChildren()); |
| 642 | EXPECT_EQ(2U, root->size()); |
| 643 | |
| 644 | // Nested test cases. These should all reduce back to the bool and string |
| 645 | // set above. |
| 646 | { |
| 647 | root->Set("a.b.c.d.e", new DictionaryValue); |
| 648 | root.reset(root->DeepCopyWithoutEmptyChildren()); |
| 649 | EXPECT_EQ(2U, root->size()); |
| 650 | } |
| 651 | { |
| 652 | DictionaryValue* inner = new DictionaryValue; |
| 653 | root->Set("dict_with_emtpy_children", inner); |
| 654 | inner->Set("empty_dict", new DictionaryValue); |
| 655 | inner->Set("empty_list", new ListValue); |
| 656 | root.reset(root->DeepCopyWithoutEmptyChildren()); |
| 657 | EXPECT_EQ(2U, root->size()); |
| 658 | } |
| 659 | { |
| 660 | ListValue* inner = new ListValue; |
| 661 | root->Set("list_with_empty_children", inner); |
| 662 | inner->Append(new DictionaryValue); |
| 663 | inner->Append(new ListValue); |
| 664 | root.reset(root->DeepCopyWithoutEmptyChildren()); |
| 665 | EXPECT_EQ(2U, root->size()); |
| 666 | } |
| 667 | |
| 668 | // Nested with siblings. |
| 669 | { |
| 670 | ListValue* inner = new ListValue; |
| 671 | root->Set("list_with_empty_children", inner); |
| 672 | inner->Append(new DictionaryValue); |
| 673 | inner->Append(new ListValue); |
| 674 | DictionaryValue* inner2 = new DictionaryValue; |
| 675 | root->Set("dict_with_empty_children", inner2); |
| 676 | inner2->Set("empty_dict", new DictionaryValue); |
| 677 | inner2->Set("empty_list", new ListValue); |
| 678 | root.reset(root->DeepCopyWithoutEmptyChildren()); |
| 679 | EXPECT_EQ(2U, root->size()); |
| 680 | } |
| 681 | |
| 682 | // Make sure nested values don't get pruned. |
| 683 | { |
| 684 | ListValue* inner = new ListValue; |
| 685 | root->Set("list_with_empty_children", inner); |
| 686 | ListValue* inner2 = new ListValue; |
| 687 | inner->Append(new DictionaryValue); |
| 688 | inner->Append(inner2); |
tfarina@chromium.org | 50be576 | 2012-12-16 14:13:21 +0900 | [diff] [blame] | 689 | inner2->Append(new StringValue("hello")); |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 690 | root.reset(root->DeepCopyWithoutEmptyChildren()); |
| 691 | EXPECT_EQ(3U, root->size()); |
| 692 | EXPECT_TRUE(root->GetList("list_with_empty_children", &inner)); |
| 693 | EXPECT_EQ(1U, inner->GetSize()); // Dictionary was pruned. |
| 694 | EXPECT_TRUE(inner->GetList(0, &inner2)); |
| 695 | EXPECT_EQ(1U, inner2->GetSize()); |
| 696 | } |
| 697 | } |
| 698 | |
tfarina@chromium.org | 4cdd38e | 2011-06-29 07:56:33 +0900 | [diff] [blame] | 699 | TEST(ValuesTest, MergeDictionary) { |
mnissler@chromium.org | 17cee0e | 2010-05-14 22:17:40 +0900 | [diff] [blame] | 700 | scoped_ptr<DictionaryValue> base(new DictionaryValue); |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 701 | base->SetString("base_key", "base_key_value_base"); |
| 702 | base->SetString("collide_key", "collide_key_value_base"); |
| 703 | DictionaryValue* base_sub_dict = new DictionaryValue; |
| 704 | base_sub_dict->SetString("sub_base_key", "sub_base_key_value_base"); |
| 705 | base_sub_dict->SetString("sub_collide_key", "sub_collide_key_value_base"); |
| 706 | base->Set("sub_dict_key", base_sub_dict); |
| 707 | |
| 708 | scoped_ptr<DictionaryValue> merge(new DictionaryValue); |
| 709 | merge->SetString("merge_key", "merge_key_value_merge"); |
| 710 | merge->SetString("collide_key", "collide_key_value_merge"); |
| 711 | DictionaryValue* merge_sub_dict = new DictionaryValue; |
| 712 | merge_sub_dict->SetString("sub_merge_key", "sub_merge_key_value_merge"); |
| 713 | merge_sub_dict->SetString("sub_collide_key", "sub_collide_key_value_merge"); |
| 714 | merge->Set("sub_dict_key", merge_sub_dict); |
| 715 | |
| 716 | base->MergeDictionary(merge.get()); |
| 717 | |
| 718 | EXPECT_EQ(4U, base->size()); |
| 719 | std::string base_key_value; |
| 720 | EXPECT_TRUE(base->GetString("base_key", &base_key_value)); |
| 721 | EXPECT_EQ("base_key_value_base", base_key_value); // Base value preserved. |
| 722 | std::string collide_key_value; |
| 723 | EXPECT_TRUE(base->GetString("collide_key", &collide_key_value)); |
| 724 | EXPECT_EQ("collide_key_value_merge", collide_key_value); // Replaced. |
| 725 | std::string merge_key_value; |
| 726 | EXPECT_TRUE(base->GetString("merge_key", &merge_key_value)); |
| 727 | EXPECT_EQ("merge_key_value_merge", merge_key_value); // Merged in. |
| 728 | |
| 729 | DictionaryValue* res_sub_dict; |
| 730 | EXPECT_TRUE(base->GetDictionary("sub_dict_key", &res_sub_dict)); |
| 731 | EXPECT_EQ(3U, res_sub_dict->size()); |
| 732 | std::string sub_base_key_value; |
| 733 | EXPECT_TRUE(res_sub_dict->GetString("sub_base_key", &sub_base_key_value)); |
| 734 | EXPECT_EQ("sub_base_key_value_base", sub_base_key_value); // Preserved. |
| 735 | std::string sub_collide_key_value; |
| 736 | EXPECT_TRUE(res_sub_dict->GetString("sub_collide_key", |
| 737 | &sub_collide_key_value)); |
| 738 | EXPECT_EQ("sub_collide_key_value_merge", sub_collide_key_value); // Replaced. |
| 739 | std::string sub_merge_key_value; |
| 740 | EXPECT_TRUE(res_sub_dict->GetString("sub_merge_key", &sub_merge_key_value)); |
| 741 | EXPECT_EQ("sub_merge_key_value_merge", sub_merge_key_value); // Merged in. |
| 742 | } |
tfarina@chromium.org | 4cdd38e | 2011-06-29 07:56:33 +0900 | [diff] [blame] | 743 | |
jhawkins@chromium.org | cbb2239 | 2012-05-10 06:54:27 +0900 | [diff] [blame] | 744 | TEST(ValuesTest, MergeDictionaryDeepCopy) { |
| 745 | DictionaryValue* child = new DictionaryValue; |
| 746 | child->SetString("test", "value"); |
| 747 | EXPECT_EQ(1U, child->size()); |
| 748 | |
| 749 | std::string value; |
| 750 | EXPECT_TRUE(child->GetString("test", &value)); |
| 751 | EXPECT_EQ("value", value); |
| 752 | |
| 753 | scoped_ptr<DictionaryValue> base(new DictionaryValue); |
| 754 | base->Set("dict", child); |
| 755 | EXPECT_EQ(1U, base->size()); |
| 756 | |
| 757 | DictionaryValue* ptr; |
| 758 | EXPECT_TRUE(base->GetDictionary("dict", &ptr)); |
| 759 | EXPECT_EQ(child, ptr); |
| 760 | |
| 761 | scoped_ptr<DictionaryValue> merged(new DictionaryValue); |
| 762 | merged->MergeDictionary(base.get()); |
| 763 | EXPECT_EQ(1U, merged->size()); |
| 764 | EXPECT_TRUE(merged->GetDictionary("dict", &ptr)); |
| 765 | EXPECT_NE(child, ptr); |
| 766 | EXPECT_TRUE(ptr->GetString("test", &value)); |
| 767 | EXPECT_EQ("value", value); |
| 768 | |
| 769 | child->SetString("test", "overwrite"); |
| 770 | base.reset(); |
| 771 | EXPECT_TRUE(ptr->GetString("test", &value)); |
| 772 | EXPECT_EQ("value", value); |
| 773 | } |
| 774 | |
kalman@chromium.org | 1604ad6 | 2011-11-09 06:26:41 +0900 | [diff] [blame] | 775 | TEST(ValuesTest, DictionaryIterator) { |
| 776 | DictionaryValue dict; |
pneubeck@chromium.org | d6c6d24 | 2013-04-12 18:25:23 +0900 | [diff] [blame] | 777 | for (DictionaryValue::Iterator it(dict); !it.IsAtEnd(); it.Advance()) { |
kalman@chromium.org | 1604ad6 | 2011-11-09 06:26:41 +0900 | [diff] [blame] | 778 | ADD_FAILURE(); |
| 779 | } |
| 780 | |
| 781 | StringValue value1("value1"); |
| 782 | dict.Set("key1", value1.DeepCopy()); |
| 783 | bool seen1 = false; |
pneubeck@chromium.org | d6c6d24 | 2013-04-12 18:25:23 +0900 | [diff] [blame] | 784 | for (DictionaryValue::Iterator it(dict); !it.IsAtEnd(); it.Advance()) { |
kalman@chromium.org | 1604ad6 | 2011-11-09 06:26:41 +0900 | [diff] [blame] | 785 | EXPECT_FALSE(seen1); |
| 786 | EXPECT_EQ("key1", it.key()); |
| 787 | EXPECT_TRUE(value1.Equals(&it.value())); |
| 788 | seen1 = true; |
| 789 | } |
| 790 | EXPECT_TRUE(seen1); |
| 791 | |
| 792 | StringValue value2("value2"); |
| 793 | dict.Set("key2", value2.DeepCopy()); |
| 794 | bool seen2 = seen1 = false; |
pneubeck@chromium.org | d6c6d24 | 2013-04-12 18:25:23 +0900 | [diff] [blame] | 795 | for (DictionaryValue::Iterator it(dict); !it.IsAtEnd(); it.Advance()) { |
kalman@chromium.org | 1604ad6 | 2011-11-09 06:26:41 +0900 | [diff] [blame] | 796 | if (it.key() == "key1") { |
| 797 | EXPECT_FALSE(seen1); |
| 798 | EXPECT_TRUE(value1.Equals(&it.value())); |
| 799 | seen1 = true; |
| 800 | } else if (it.key() == "key2") { |
| 801 | EXPECT_FALSE(seen2); |
| 802 | EXPECT_TRUE(value2.Equals(&it.value())); |
| 803 | seen2 = true; |
| 804 | } else { |
| 805 | ADD_FAILURE(); |
| 806 | } |
| 807 | } |
| 808 | EXPECT_TRUE(seen1); |
| 809 | EXPECT_TRUE(seen2); |
| 810 | } |
| 811 | |
gab@chromium.org | b3fa814 | 2014-03-09 16:13:23 +0900 | [diff] [blame^] | 812 | // DictionaryValue/ListValue's Get*() methods should accept NULL as an out-value |
| 813 | // and still return true/false based on success. |
| 814 | TEST(ValuesTest, GetWithNullOutValue) { |
| 815 | DictionaryValue main_dict; |
| 816 | ListValue main_list; |
| 817 | |
| 818 | FundamentalValue bool_value(false); |
| 819 | FundamentalValue int_value(1234); |
| 820 | FundamentalValue double_value(12.34567); |
| 821 | StringValue string_value("foo"); |
| 822 | BinaryValue binary_value; |
| 823 | DictionaryValue dict_value; |
| 824 | ListValue list_value; |
| 825 | |
| 826 | main_dict.Set("bool", bool_value.DeepCopy()); |
| 827 | main_dict.Set("int", int_value.DeepCopy()); |
| 828 | main_dict.Set("double", double_value.DeepCopy()); |
| 829 | main_dict.Set("string", string_value.DeepCopy()); |
| 830 | main_dict.Set("binary", binary_value.DeepCopy()); |
| 831 | main_dict.Set("dict", dict_value.DeepCopy()); |
| 832 | main_dict.Set("list", list_value.DeepCopy()); |
| 833 | |
| 834 | main_list.Append(bool_value.DeepCopy()); |
| 835 | main_list.Append(int_value.DeepCopy()); |
| 836 | main_list.Append(double_value.DeepCopy()); |
| 837 | main_list.Append(string_value.DeepCopy()); |
| 838 | main_list.Append(binary_value.DeepCopy()); |
| 839 | main_list.Append(dict_value.DeepCopy()); |
| 840 | main_list.Append(list_value.DeepCopy()); |
| 841 | |
| 842 | EXPECT_TRUE(main_dict.Get("bool", NULL)); |
| 843 | EXPECT_TRUE(main_dict.Get("int", NULL)); |
| 844 | EXPECT_TRUE(main_dict.Get("double", NULL)); |
| 845 | EXPECT_TRUE(main_dict.Get("string", NULL)); |
| 846 | EXPECT_TRUE(main_dict.Get("binary", NULL)); |
| 847 | EXPECT_TRUE(main_dict.Get("dict", NULL)); |
| 848 | EXPECT_TRUE(main_dict.Get("list", NULL)); |
| 849 | EXPECT_FALSE(main_dict.Get("DNE", NULL)); |
| 850 | |
| 851 | EXPECT_TRUE(main_dict.GetBoolean("bool", NULL)); |
| 852 | EXPECT_FALSE(main_dict.GetBoolean("int", NULL)); |
| 853 | EXPECT_FALSE(main_dict.GetBoolean("double", NULL)); |
| 854 | EXPECT_FALSE(main_dict.GetBoolean("string", NULL)); |
| 855 | EXPECT_FALSE(main_dict.GetBoolean("binary", NULL)); |
| 856 | EXPECT_FALSE(main_dict.GetBoolean("dict", NULL)); |
| 857 | EXPECT_FALSE(main_dict.GetBoolean("list", NULL)); |
| 858 | EXPECT_FALSE(main_dict.GetBoolean("DNE", NULL)); |
| 859 | |
| 860 | EXPECT_FALSE(main_dict.GetInteger("bool", NULL)); |
| 861 | EXPECT_TRUE(main_dict.GetInteger("int", NULL)); |
| 862 | EXPECT_FALSE(main_dict.GetInteger("double", NULL)); |
| 863 | EXPECT_FALSE(main_dict.GetInteger("string", NULL)); |
| 864 | EXPECT_FALSE(main_dict.GetInteger("binary", NULL)); |
| 865 | EXPECT_FALSE(main_dict.GetInteger("dict", NULL)); |
| 866 | EXPECT_FALSE(main_dict.GetInteger("list", NULL)); |
| 867 | EXPECT_FALSE(main_dict.GetInteger("DNE", NULL)); |
| 868 | |
| 869 | // Both int and double values can be obtained from GetDouble. |
| 870 | EXPECT_FALSE(main_dict.GetDouble("bool", NULL)); |
| 871 | EXPECT_TRUE(main_dict.GetDouble("int", NULL)); |
| 872 | EXPECT_TRUE(main_dict.GetDouble("double", NULL)); |
| 873 | EXPECT_FALSE(main_dict.GetDouble("string", NULL)); |
| 874 | EXPECT_FALSE(main_dict.GetDouble("binary", NULL)); |
| 875 | EXPECT_FALSE(main_dict.GetDouble("dict", NULL)); |
| 876 | EXPECT_FALSE(main_dict.GetDouble("list", NULL)); |
| 877 | EXPECT_FALSE(main_dict.GetDouble("DNE", NULL)); |
| 878 | |
| 879 | EXPECT_FALSE(main_dict.GetString("bool", static_cast<std::string*>(NULL))); |
| 880 | EXPECT_FALSE(main_dict.GetString("int", static_cast<std::string*>(NULL))); |
| 881 | EXPECT_FALSE(main_dict.GetString("double", static_cast<std::string*>(NULL))); |
| 882 | EXPECT_TRUE(main_dict.GetString("string", static_cast<std::string*>(NULL))); |
| 883 | EXPECT_FALSE(main_dict.GetString("binary", static_cast<std::string*>(NULL))); |
| 884 | EXPECT_FALSE(main_dict.GetString("dict", static_cast<std::string*>(NULL))); |
| 885 | EXPECT_FALSE(main_dict.GetString("list", static_cast<std::string*>(NULL))); |
| 886 | EXPECT_FALSE(main_dict.GetString("DNE", static_cast<std::string*>(NULL))); |
| 887 | |
| 888 | EXPECT_FALSE(main_dict.GetString("bool", static_cast<string16*>(NULL))); |
| 889 | EXPECT_FALSE(main_dict.GetString("int", static_cast<string16*>(NULL))); |
| 890 | EXPECT_FALSE(main_dict.GetString("double", static_cast<string16*>(NULL))); |
| 891 | EXPECT_TRUE(main_dict.GetString("string", static_cast<string16*>(NULL))); |
| 892 | EXPECT_FALSE(main_dict.GetString("binary", static_cast<string16*>(NULL))); |
| 893 | EXPECT_FALSE(main_dict.GetString("dict", static_cast<string16*>(NULL))); |
| 894 | EXPECT_FALSE(main_dict.GetString("list", static_cast<string16*>(NULL))); |
| 895 | EXPECT_FALSE(main_dict.GetString("DNE", static_cast<string16*>(NULL))); |
| 896 | |
| 897 | EXPECT_FALSE(main_dict.GetBinary("bool", NULL)); |
| 898 | EXPECT_FALSE(main_dict.GetBinary("int", NULL)); |
| 899 | EXPECT_FALSE(main_dict.GetBinary("double", NULL)); |
| 900 | EXPECT_FALSE(main_dict.GetBinary("string", NULL)); |
| 901 | EXPECT_TRUE(main_dict.GetBinary("binary", NULL)); |
| 902 | EXPECT_FALSE(main_dict.GetBinary("dict", NULL)); |
| 903 | EXPECT_FALSE(main_dict.GetBinary("list", NULL)); |
| 904 | EXPECT_FALSE(main_dict.GetBinary("DNE", NULL)); |
| 905 | |
| 906 | EXPECT_FALSE(main_dict.GetDictionary("bool", NULL)); |
| 907 | EXPECT_FALSE(main_dict.GetDictionary("int", NULL)); |
| 908 | EXPECT_FALSE(main_dict.GetDictionary("double", NULL)); |
| 909 | EXPECT_FALSE(main_dict.GetDictionary("string", NULL)); |
| 910 | EXPECT_FALSE(main_dict.GetDictionary("binary", NULL)); |
| 911 | EXPECT_TRUE(main_dict.GetDictionary("dict", NULL)); |
| 912 | EXPECT_FALSE(main_dict.GetDictionary("list", NULL)); |
| 913 | EXPECT_FALSE(main_dict.GetDictionary("DNE", NULL)); |
| 914 | |
| 915 | EXPECT_FALSE(main_dict.GetList("bool", NULL)); |
| 916 | EXPECT_FALSE(main_dict.GetList("int", NULL)); |
| 917 | EXPECT_FALSE(main_dict.GetList("double", NULL)); |
| 918 | EXPECT_FALSE(main_dict.GetList("string", NULL)); |
| 919 | EXPECT_FALSE(main_dict.GetList("binary", NULL)); |
| 920 | EXPECT_FALSE(main_dict.GetList("dict", NULL)); |
| 921 | EXPECT_TRUE(main_dict.GetList("list", NULL)); |
| 922 | EXPECT_FALSE(main_dict.GetList("DNE", NULL)); |
| 923 | |
| 924 | EXPECT_TRUE(main_dict.GetWithoutPathExpansion("bool", NULL)); |
| 925 | EXPECT_TRUE(main_dict.GetWithoutPathExpansion("int", NULL)); |
| 926 | EXPECT_TRUE(main_dict.GetWithoutPathExpansion("double", NULL)); |
| 927 | EXPECT_TRUE(main_dict.GetWithoutPathExpansion("string", NULL)); |
| 928 | EXPECT_TRUE(main_dict.GetWithoutPathExpansion("binary", NULL)); |
| 929 | EXPECT_TRUE(main_dict.GetWithoutPathExpansion("dict", NULL)); |
| 930 | EXPECT_TRUE(main_dict.GetWithoutPathExpansion("list", NULL)); |
| 931 | EXPECT_FALSE(main_dict.GetWithoutPathExpansion("DNE", NULL)); |
| 932 | |
| 933 | EXPECT_TRUE(main_dict.GetBooleanWithoutPathExpansion("bool", NULL)); |
| 934 | EXPECT_FALSE(main_dict.GetBooleanWithoutPathExpansion("int", NULL)); |
| 935 | EXPECT_FALSE(main_dict.GetBooleanWithoutPathExpansion("double", NULL)); |
| 936 | EXPECT_FALSE(main_dict.GetBooleanWithoutPathExpansion("string", NULL)); |
| 937 | EXPECT_FALSE(main_dict.GetBooleanWithoutPathExpansion("binary", NULL)); |
| 938 | EXPECT_FALSE(main_dict.GetBooleanWithoutPathExpansion("dict", NULL)); |
| 939 | EXPECT_FALSE(main_dict.GetBooleanWithoutPathExpansion("list", NULL)); |
| 940 | EXPECT_FALSE(main_dict.GetBooleanWithoutPathExpansion("DNE", NULL)); |
| 941 | |
| 942 | EXPECT_FALSE(main_dict.GetIntegerWithoutPathExpansion("bool", NULL)); |
| 943 | EXPECT_TRUE(main_dict.GetIntegerWithoutPathExpansion("int", NULL)); |
| 944 | EXPECT_FALSE(main_dict.GetIntegerWithoutPathExpansion("double", NULL)); |
| 945 | EXPECT_FALSE(main_dict.GetIntegerWithoutPathExpansion("string", NULL)); |
| 946 | EXPECT_FALSE(main_dict.GetIntegerWithoutPathExpansion("binary", NULL)); |
| 947 | EXPECT_FALSE(main_dict.GetIntegerWithoutPathExpansion("dict", NULL)); |
| 948 | EXPECT_FALSE(main_dict.GetIntegerWithoutPathExpansion("list", NULL)); |
| 949 | EXPECT_FALSE(main_dict.GetIntegerWithoutPathExpansion("DNE", NULL)); |
| 950 | |
| 951 | EXPECT_FALSE(main_dict.GetDoubleWithoutPathExpansion("bool", NULL)); |
| 952 | EXPECT_TRUE(main_dict.GetDoubleWithoutPathExpansion("int", NULL)); |
| 953 | EXPECT_TRUE(main_dict.GetDoubleWithoutPathExpansion("double", NULL)); |
| 954 | EXPECT_FALSE(main_dict.GetDoubleWithoutPathExpansion("string", NULL)); |
| 955 | EXPECT_FALSE(main_dict.GetDoubleWithoutPathExpansion("binary", NULL)); |
| 956 | EXPECT_FALSE(main_dict.GetDoubleWithoutPathExpansion("dict", NULL)); |
| 957 | EXPECT_FALSE(main_dict.GetDoubleWithoutPathExpansion("list", NULL)); |
| 958 | EXPECT_FALSE(main_dict.GetDoubleWithoutPathExpansion("DNE", NULL)); |
| 959 | |
| 960 | EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion( |
| 961 | "bool", static_cast<std::string*>(NULL))); |
| 962 | EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion( |
| 963 | "int", static_cast<std::string*>(NULL))); |
| 964 | EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion( |
| 965 | "double", static_cast<std::string*>(NULL))); |
| 966 | EXPECT_TRUE(main_dict.GetStringWithoutPathExpansion( |
| 967 | "string", static_cast<std::string*>(NULL))); |
| 968 | EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion( |
| 969 | "binary", static_cast<std::string*>(NULL))); |
| 970 | EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion( |
| 971 | "dict", static_cast<std::string*>(NULL))); |
| 972 | EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion( |
| 973 | "list", static_cast<std::string*>(NULL))); |
| 974 | EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion( |
| 975 | "DNE", static_cast<std::string*>(NULL))); |
| 976 | |
| 977 | EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion( |
| 978 | "bool", static_cast<string16*>(NULL))); |
| 979 | EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion( |
| 980 | "int", static_cast<string16*>(NULL))); |
| 981 | EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion( |
| 982 | "double", static_cast<string16*>(NULL))); |
| 983 | EXPECT_TRUE(main_dict.GetStringWithoutPathExpansion( |
| 984 | "string", static_cast<string16*>(NULL))); |
| 985 | EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion( |
| 986 | "binary", static_cast<string16*>(NULL))); |
| 987 | EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion( |
| 988 | "dict", static_cast<string16*>(NULL))); |
| 989 | EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion( |
| 990 | "list", static_cast<string16*>(NULL))); |
| 991 | EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion( |
| 992 | "DNE", static_cast<string16*>(NULL))); |
| 993 | |
| 994 | // There is no GetBinaryWithoutPathExpansion for some reason, but if there |
| 995 | // were it should be tested here... |
| 996 | |
| 997 | EXPECT_FALSE(main_dict.GetDictionaryWithoutPathExpansion("bool", NULL)); |
| 998 | EXPECT_FALSE(main_dict.GetDictionaryWithoutPathExpansion("int", NULL)); |
| 999 | EXPECT_FALSE(main_dict.GetDictionaryWithoutPathExpansion("double", NULL)); |
| 1000 | EXPECT_FALSE(main_dict.GetDictionaryWithoutPathExpansion("string", NULL)); |
| 1001 | EXPECT_FALSE(main_dict.GetDictionaryWithoutPathExpansion("binary", NULL)); |
| 1002 | EXPECT_TRUE(main_dict.GetDictionaryWithoutPathExpansion("dict", NULL)); |
| 1003 | EXPECT_FALSE(main_dict.GetDictionaryWithoutPathExpansion("list", NULL)); |
| 1004 | EXPECT_FALSE(main_dict.GetDictionaryWithoutPathExpansion("DNE", NULL)); |
| 1005 | |
| 1006 | EXPECT_FALSE(main_dict.GetListWithoutPathExpansion("bool", NULL)); |
| 1007 | EXPECT_FALSE(main_dict.GetListWithoutPathExpansion("int", NULL)); |
| 1008 | EXPECT_FALSE(main_dict.GetListWithoutPathExpansion("double", NULL)); |
| 1009 | EXPECT_FALSE(main_dict.GetListWithoutPathExpansion("string", NULL)); |
| 1010 | EXPECT_FALSE(main_dict.GetListWithoutPathExpansion("binary", NULL)); |
| 1011 | EXPECT_FALSE(main_dict.GetListWithoutPathExpansion("dict", NULL)); |
| 1012 | EXPECT_TRUE(main_dict.GetListWithoutPathExpansion("list", NULL)); |
| 1013 | EXPECT_FALSE(main_dict.GetListWithoutPathExpansion("DNE", NULL)); |
| 1014 | |
| 1015 | EXPECT_TRUE(main_list.Get(0, NULL)); |
| 1016 | EXPECT_TRUE(main_list.Get(1, NULL)); |
| 1017 | EXPECT_TRUE(main_list.Get(2, NULL)); |
| 1018 | EXPECT_TRUE(main_list.Get(3, NULL)); |
| 1019 | EXPECT_TRUE(main_list.Get(4, NULL)); |
| 1020 | EXPECT_TRUE(main_list.Get(5, NULL)); |
| 1021 | EXPECT_TRUE(main_list.Get(6, NULL)); |
| 1022 | EXPECT_FALSE(main_list.Get(7, NULL)); |
| 1023 | |
| 1024 | EXPECT_TRUE(main_list.GetBoolean(0, NULL)); |
| 1025 | EXPECT_FALSE(main_list.GetBoolean(1, NULL)); |
| 1026 | EXPECT_FALSE(main_list.GetBoolean(2, NULL)); |
| 1027 | EXPECT_FALSE(main_list.GetBoolean(3, NULL)); |
| 1028 | EXPECT_FALSE(main_list.GetBoolean(4, NULL)); |
| 1029 | EXPECT_FALSE(main_list.GetBoolean(5, NULL)); |
| 1030 | EXPECT_FALSE(main_list.GetBoolean(6, NULL)); |
| 1031 | EXPECT_FALSE(main_list.GetBoolean(7, NULL)); |
| 1032 | |
| 1033 | EXPECT_FALSE(main_list.GetInteger(0, NULL)); |
| 1034 | EXPECT_TRUE(main_list.GetInteger(1, NULL)); |
| 1035 | EXPECT_FALSE(main_list.GetInteger(2, NULL)); |
| 1036 | EXPECT_FALSE(main_list.GetInteger(3, NULL)); |
| 1037 | EXPECT_FALSE(main_list.GetInteger(4, NULL)); |
| 1038 | EXPECT_FALSE(main_list.GetInteger(5, NULL)); |
| 1039 | EXPECT_FALSE(main_list.GetInteger(6, NULL)); |
| 1040 | EXPECT_FALSE(main_list.GetInteger(7, NULL)); |
| 1041 | |
| 1042 | EXPECT_FALSE(main_list.GetDouble(0, NULL)); |
| 1043 | EXPECT_TRUE(main_list.GetDouble(1, NULL)); |
| 1044 | EXPECT_TRUE(main_list.GetDouble(2, NULL)); |
| 1045 | EXPECT_FALSE(main_list.GetDouble(3, NULL)); |
| 1046 | EXPECT_FALSE(main_list.GetDouble(4, NULL)); |
| 1047 | EXPECT_FALSE(main_list.GetDouble(5, NULL)); |
| 1048 | EXPECT_FALSE(main_list.GetDouble(6, NULL)); |
| 1049 | EXPECT_FALSE(main_list.GetDouble(7, NULL)); |
| 1050 | |
| 1051 | EXPECT_FALSE(main_list.GetString(0, static_cast<std::string*>(NULL))); |
| 1052 | EXPECT_FALSE(main_list.GetString(1, static_cast<std::string*>(NULL))); |
| 1053 | EXPECT_FALSE(main_list.GetString(2, static_cast<std::string*>(NULL))); |
| 1054 | EXPECT_TRUE(main_list.GetString(3, static_cast<std::string*>(NULL))); |
| 1055 | EXPECT_FALSE(main_list.GetString(4, static_cast<std::string*>(NULL))); |
| 1056 | EXPECT_FALSE(main_list.GetString(5, static_cast<std::string*>(NULL))); |
| 1057 | EXPECT_FALSE(main_list.GetString(6, static_cast<std::string*>(NULL))); |
| 1058 | EXPECT_FALSE(main_list.GetString(7, static_cast<std::string*>(NULL))); |
| 1059 | |
| 1060 | EXPECT_FALSE(main_list.GetString(0, static_cast<string16*>(NULL))); |
| 1061 | EXPECT_FALSE(main_list.GetString(1, static_cast<string16*>(NULL))); |
| 1062 | EXPECT_FALSE(main_list.GetString(2, static_cast<string16*>(NULL))); |
| 1063 | EXPECT_TRUE(main_list.GetString(3, static_cast<string16*>(NULL))); |
| 1064 | EXPECT_FALSE(main_list.GetString(4, static_cast<string16*>(NULL))); |
| 1065 | EXPECT_FALSE(main_list.GetString(5, static_cast<string16*>(NULL))); |
| 1066 | EXPECT_FALSE(main_list.GetString(6, static_cast<string16*>(NULL))); |
| 1067 | EXPECT_FALSE(main_list.GetString(7, static_cast<string16*>(NULL))); |
| 1068 | |
| 1069 | EXPECT_FALSE(main_list.GetBinary(0, NULL)); |
| 1070 | EXPECT_FALSE(main_list.GetBinary(1, NULL)); |
| 1071 | EXPECT_FALSE(main_list.GetBinary(2, NULL)); |
| 1072 | EXPECT_FALSE(main_list.GetBinary(3, NULL)); |
| 1073 | EXPECT_TRUE(main_list.GetBinary(4, NULL)); |
| 1074 | EXPECT_FALSE(main_list.GetBinary(5, NULL)); |
| 1075 | EXPECT_FALSE(main_list.GetBinary(6, NULL)); |
| 1076 | EXPECT_FALSE(main_list.GetBinary(7, NULL)); |
| 1077 | |
| 1078 | EXPECT_FALSE(main_list.GetDictionary(0, NULL)); |
| 1079 | EXPECT_FALSE(main_list.GetDictionary(1, NULL)); |
| 1080 | EXPECT_FALSE(main_list.GetDictionary(2, NULL)); |
| 1081 | EXPECT_FALSE(main_list.GetDictionary(3, NULL)); |
| 1082 | EXPECT_FALSE(main_list.GetDictionary(4, NULL)); |
| 1083 | EXPECT_TRUE(main_list.GetDictionary(5, NULL)); |
| 1084 | EXPECT_FALSE(main_list.GetDictionary(6, NULL)); |
| 1085 | EXPECT_FALSE(main_list.GetDictionary(7, NULL)); |
| 1086 | |
| 1087 | EXPECT_FALSE(main_list.GetList(0, NULL)); |
| 1088 | EXPECT_FALSE(main_list.GetList(1, NULL)); |
| 1089 | EXPECT_FALSE(main_list.GetList(2, NULL)); |
| 1090 | EXPECT_FALSE(main_list.GetList(3, NULL)); |
| 1091 | EXPECT_FALSE(main_list.GetList(4, NULL)); |
| 1092 | EXPECT_FALSE(main_list.GetList(5, NULL)); |
| 1093 | EXPECT_TRUE(main_list.GetList(6, NULL)); |
| 1094 | EXPECT_FALSE(main_list.GetList(7, NULL)); |
| 1095 | } |
| 1096 | |
tfarina@chromium.org | 4cdd38e | 2011-06-29 07:56:33 +0900 | [diff] [blame] | 1097 | } // namespace base |