blob: 8a42f784bdfb40da58b8f293c8f75e6d389d4089 [file] [log] [blame]
[email protected]44106182012-04-06 03:53:021// Copyright (c) 2012 The Chromium Authors. All rights reserved.
license.botbf09a502008-08-24 00:55:552// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
initial.commitd7cae122008-07-26 21:49:384
[email protected]836061b2008-08-13 14:57:515#include <limits>
6
[email protected]3b63f8f42011-03-28 01:54:157#include "base/memory/scoped_ptr.h"
[email protected]9101ef1e2010-01-15 20:09:038#include "base/string16.h"
[email protected]be1ce6a72010-08-03 14:35:229#include "base/utf_string_conversions.h"
[email protected]9101ef1e2010-01-15 20:09:0310#include "base/values.h"
initial.commitd7cae122008-07-26 21:49:3811#include "testing/gtest/include/gtest/gtest.h"
12
[email protected]58b916e2011-06-28 22:56:3313namespace base {
initial.commitd7cae122008-07-26 21:49:3814
[email protected]58b916e2011-06-28 22:56:3315TEST(ValuesTest, Basic) {
initial.commitd7cae122008-07-26 21:49:3816 // Test basic dictionary getting/setting
17 DictionaryValue settings;
[email protected]9e4cda7332010-07-31 04:56:1418 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));
[email protected]7e3ec42c2012-12-16 05:13:2123 settings.Set("global", new FundamentalValue(true));
[email protected]9e4cda7332010-07-31 04:56:1424 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
[email protected]58b916e2011-06-28 22:56:3358TEST(ValuesTest, List) {
[email protected]f82fb4952009-01-20 21:05:3259 scoped_ptr<ListValue> mixed_list(new ListValue());
[email protected]7e3ec42c2012-12-16 05:13:2160 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"));
[email protected]f82fb4952009-01-20 21:05:3264 ASSERT_EQ(4u, mixed_list->GetSize());
[email protected]52a261f2009-03-03 15:01:1265
[email protected]f82fb4952009-01-20 21:05:3266 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);
[email protected]d3accda2011-05-02 01:59:2176 ASSERT_FALSE(mixed_list->GetBoolean(1, &bool_value));
77 ASSERT_FALSE(bool_value);
[email protected]f82fb4952009-01-20 21:05:3278 ASSERT_FALSE(mixed_list->GetString(2, &string_value));
79 ASSERT_EQ("", string_value);
[email protected]d3accda2011-05-02 01:59:2180 ASSERT_FALSE(mixed_list->GetInteger(2, &int_value));
81 ASSERT_EQ(0, int_value);
[email protected]f82fb4952009-01-20 21:05:3282 ASSERT_FALSE(mixed_list->GetBoolean(3, &bool_value));
[email protected]74e3af72010-10-03 21:44:3983 ASSERT_FALSE(bool_value);
[email protected]f82fb4952009-01-20 21:05:3284
85 ASSERT_TRUE(mixed_list->GetBoolean(0, &bool_value));
[email protected]74e3af72010-10-03 21:44:3986 ASSERT_TRUE(bool_value);
[email protected]f82fb4952009-01-20 21:05:3287 ASSERT_TRUE(mixed_list->GetInteger(1, &int_value));
88 ASSERT_EQ(42, int_value);
[email protected]d3accda2011-05-02 01:59:2189 // implicit conversion from Integer to Double should be possible.
90 ASSERT_TRUE(mixed_list->GetDouble(1, &double_value));
91 ASSERT_EQ(42, double_value);
[email protected]fb534c92011-02-01 01:02:0792 ASSERT_TRUE(mixed_list->GetDouble(2, &double_value));
[email protected]f82fb4952009-01-20 21:05:3293 ASSERT_EQ(88.8, double_value);
94 ASSERT_TRUE(mixed_list->GetString(3, &string_value));
95 ASSERT_EQ("foo", string_value);
[email protected]5fb35372011-09-19 15:23:1096
97 // Try searching in the mixed list.
[email protected]7e3ec42c2012-12-16 05:13:2198 base::FundamentalValue sought_value(42);
99 base::FundamentalValue not_found_value(false);
[email protected]5fb35372011-09-19 15:23:10100
[email protected]7e3ec42c2012-12-16 05:13:21101 ASSERT_NE(mixed_list->end(), mixed_list->Find(sought_value));
102 ASSERT_TRUE((*mixed_list->Find(sought_value))->GetAsInteger(&int_value));
[email protected]5fb35372011-09-19 15:23:10103 ASSERT_EQ(42, int_value);
[email protected]7e3ec42c2012-12-16 05:13:21104 ASSERT_EQ(mixed_list->end(), mixed_list->Find(not_found_value));
[email protected]f82fb4952009-01-20 21:05:32105}
106
[email protected]58b916e2011-06-28 22:56:33107TEST(ValuesTest, BinaryValue) {
[email protected]0d0ed0c2012-05-20 02:34:57108 char* buffer = NULL;
109 // Passing a null buffer pointer doesn't yield a BinaryValue
110 scoped_ptr<BinaryValue> binary(BinaryValue::Create(buffer, 0));
111 ASSERT_FALSE(binary.get());
112
113 // If you want to represent an empty binary value, use a zero-length buffer.
114 buffer = new char[1];
115 ASSERT_TRUE(buffer);
116 binary.reset(BinaryValue::Create(buffer, 0));
[email protected]0a9a0fc2009-03-24 23:37:14117 ASSERT_TRUE(binary.get());
[email protected]0d0ed0c2012-05-20 02:34:57118 ASSERT_TRUE(binary->GetBuffer());
119 ASSERT_EQ(buffer, binary->GetBuffer());
[email protected]f297d182008-08-21 16:24:51120 ASSERT_EQ(0U, binary->GetSize());
initial.commitd7cae122008-07-26 21:49:38121
122 // Test the common case of a non-empty buffer
[email protected]0d0ed0c2012-05-20 02:34:57123 buffer = new char[15];
124 binary.reset(BinaryValue::Create(buffer, 15));
[email protected]0a9a0fc2009-03-24 23:37:14125 ASSERT_TRUE(binary.get());
initial.commitd7cae122008-07-26 21:49:38126 ASSERT_TRUE(binary->GetBuffer());
127 ASSERT_EQ(buffer, binary->GetBuffer());
[email protected]f297d182008-08-21 16:24:51128 ASSERT_EQ(15U, binary->GetSize());
initial.commitd7cae122008-07-26 21:49:38129
130 char stack_buffer[42];
131 memset(stack_buffer, '!', 42);
[email protected]0a9a0fc2009-03-24 23:37:14132 binary.reset(BinaryValue::CreateWithCopiedBuffer(stack_buffer, 42));
133 ASSERT_TRUE(binary.get());
initial.commitd7cae122008-07-26 21:49:38134 ASSERT_TRUE(binary->GetBuffer());
135 ASSERT_NE(stack_buffer, binary->GetBuffer());
[email protected]f297d182008-08-21 16:24:51136 ASSERT_EQ(42U, binary->GetSize());
initial.commitd7cae122008-07-26 21:49:38137 ASSERT_EQ(0, memcmp(stack_buffer, binary->GetBuffer(), binary->GetSize()));
initial.commitd7cae122008-07-26 21:49:38138}
139
[email protected]58b916e2011-06-28 22:56:33140TEST(ValuesTest, StringValue) {
[email protected]4cd5f6a2008-12-11 01:23:17141 // Test overloaded CreateStringValue.
[email protected]7e3ec42c2012-12-16 05:13:21142 scoped_ptr<Value> narrow_value(new StringValue("narrow"));
[email protected]0a9a0fc2009-03-24 23:37:14143 ASSERT_TRUE(narrow_value.get());
[email protected]4cd5f6a2008-12-11 01:23:17144 ASSERT_TRUE(narrow_value->IsType(Value::TYPE_STRING));
[email protected]7e3ec42c2012-12-16 05:13:21145 scoped_ptr<Value> utf16_value(new StringValue(ASCIIToUTF16("utf16")));
[email protected]e2e593d2010-08-03 15:42:58146 ASSERT_TRUE(utf16_value.get());
147 ASSERT_TRUE(utf16_value->IsType(Value::TYPE_STRING));
148
149 // Test overloaded GetString.
150 std::string narrow = "http://google.com";
151 string16 utf16 = ASCIIToUTF16("http://google.com");
152 ASSERT_TRUE(narrow_value->GetAsString(&narrow));
153 ASSERT_TRUE(narrow_value->GetAsString(&utf16));
154 ASSERT_EQ(std::string("narrow"), narrow);
155 ASSERT_EQ(ASCIIToUTF16("narrow"), utf16);
156
157 ASSERT_TRUE(utf16_value->GetAsString(&narrow));
158 ASSERT_TRUE(utf16_value->GetAsString(&utf16));
159 ASSERT_EQ(std::string("utf16"), narrow);
160 ASSERT_EQ(ASCIIToUTF16("utf16"), utf16);
161}
162
initial.commitd7cae122008-07-26 21:49:38163// This is a Value object that allows us to tell if it's been
164// properly deleted by modifying the value of external flag on destruction.
165class DeletionTestValue : public Value {
[email protected]8ab4809b2009-07-03 02:28:55166 public:
[email protected]2fdc86a2010-01-26 23:08:02167 explicit DeletionTestValue(bool* deletion_flag) : Value(TYPE_NULL) {
initial.commitd7cae122008-07-26 21:49:38168 Init(deletion_flag); // Separate function so that we can use ASSERT_*
169 }
170
171 void Init(bool* deletion_flag) {
172 ASSERT_TRUE(deletion_flag);
173 deletion_flag_ = deletion_flag;
174 *deletion_flag_ = false;
175 }
176
[email protected]44106182012-04-06 03:53:02177 virtual ~DeletionTestValue() {
initial.commitd7cae122008-07-26 21:49:38178 *deletion_flag_ = true;
179 }
180
[email protected]8ab4809b2009-07-03 02:28:55181 private:
initial.commitd7cae122008-07-26 21:49:38182 bool* deletion_flag_;
183};
184
[email protected]58b916e2011-06-28 22:56:33185TEST(ValuesTest, ListDeletion) {
initial.commitd7cae122008-07-26 21:49:38186 bool deletion_flag = true;
187
188 {
189 ListValue list;
190 list.Append(new DeletionTestValue(&deletion_flag));
191 EXPECT_FALSE(deletion_flag);
192 }
193 EXPECT_TRUE(deletion_flag);
194
195 {
196 ListValue list;
197 list.Append(new DeletionTestValue(&deletion_flag));
198 EXPECT_FALSE(deletion_flag);
199 list.Clear();
200 EXPECT_TRUE(deletion_flag);
201 }
202
203 {
204 ListValue list;
205 list.Append(new DeletionTestValue(&deletion_flag));
206 EXPECT_FALSE(deletion_flag);
207 EXPECT_TRUE(list.Set(0, Value::CreateNullValue()));
208 EXPECT_TRUE(deletion_flag);
209 }
210}
211
[email protected]58b916e2011-06-28 22:56:33212TEST(ValuesTest, ListRemoval) {
initial.commitd7cae122008-07-26 21:49:38213 bool deletion_flag = true;
214 Value* removed_item = NULL;
215
216 {
217 ListValue list;
218 list.Append(new DeletionTestValue(&deletion_flag));
219 EXPECT_FALSE(deletion_flag);
[email protected]f297d182008-08-21 16:24:51220 EXPECT_EQ(1U, list.GetSize());
[email protected]836061b2008-08-13 14:57:51221 EXPECT_FALSE(list.Remove(std::numeric_limits<size_t>::max(),
222 &removed_item));
initial.commitd7cae122008-07-26 21:49:38223 EXPECT_FALSE(list.Remove(1, &removed_item));
224 EXPECT_TRUE(list.Remove(0, &removed_item));
225 ASSERT_TRUE(removed_item);
[email protected]f297d182008-08-21 16:24:51226 EXPECT_EQ(0U, list.GetSize());
initial.commitd7cae122008-07-26 21:49:38227 }
228 EXPECT_FALSE(deletion_flag);
229 delete removed_item;
230 removed_item = NULL;
231 EXPECT_TRUE(deletion_flag);
232
233 {
234 ListValue list;
235 list.Append(new DeletionTestValue(&deletion_flag));
236 EXPECT_FALSE(deletion_flag);
237 EXPECT_TRUE(list.Remove(0, NULL));
238 EXPECT_TRUE(deletion_flag);
[email protected]f297d182008-08-21 16:24:51239 EXPECT_EQ(0U, list.GetSize());
initial.commitd7cae122008-07-26 21:49:38240 }
[email protected]6832cbe2009-11-30 19:59:11241
242 {
243 ListValue list;
244 DeletionTestValue* value = new DeletionTestValue(&deletion_flag);
245 list.Append(value);
246 EXPECT_FALSE(deletion_flag);
[email protected]4fc3c5642011-08-13 17:34:31247 size_t index = 0;
248 list.Remove(*value, &index);
249 EXPECT_EQ(0U, index);
[email protected]6832cbe2009-11-30 19:59:11250 EXPECT_TRUE(deletion_flag);
251 EXPECT_EQ(0U, list.GetSize());
252 }
initial.commitd7cae122008-07-26 21:49:38253}
254
[email protected]58b916e2011-06-28 22:56:33255TEST(ValuesTest, DictionaryDeletion) {
[email protected]9e4cda7332010-07-31 04:56:14256 std::string key = "test";
257 bool deletion_flag = true;
258
259 {
260 DictionaryValue dict;
261 dict.Set(key, new DeletionTestValue(&deletion_flag));
262 EXPECT_FALSE(deletion_flag);
263 }
264 EXPECT_TRUE(deletion_flag);
265
266 {
267 DictionaryValue dict;
268 dict.Set(key, new DeletionTestValue(&deletion_flag));
269 EXPECT_FALSE(deletion_flag);
270 dict.Clear();
271 EXPECT_TRUE(deletion_flag);
272 }
273
274 {
275 DictionaryValue dict;
276 dict.Set(key, new DeletionTestValue(&deletion_flag));
277 EXPECT_FALSE(deletion_flag);
278 dict.Set(key, Value::CreateNullValue());
279 EXPECT_TRUE(deletion_flag);
280 }
281}
282
[email protected]58b916e2011-06-28 22:56:33283TEST(ValuesTest, DictionaryRemoval) {
[email protected]9e4cda7332010-07-31 04:56:14284 std::string key = "test";
285 bool deletion_flag = true;
286 Value* removed_item = NULL;
287
288 {
289 DictionaryValue dict;
290 dict.Set(key, new DeletionTestValue(&deletion_flag));
291 EXPECT_FALSE(deletion_flag);
292 EXPECT_TRUE(dict.HasKey(key));
293 EXPECT_FALSE(dict.Remove("absent key", &removed_item));
294 EXPECT_TRUE(dict.Remove(key, &removed_item));
295 EXPECT_FALSE(dict.HasKey(key));
296 ASSERT_TRUE(removed_item);
297 }
298 EXPECT_FALSE(deletion_flag);
299 delete removed_item;
300 removed_item = NULL;
301 EXPECT_TRUE(deletion_flag);
302
303 {
304 DictionaryValue dict;
305 dict.Set(key, new DeletionTestValue(&deletion_flag));
306 EXPECT_FALSE(deletion_flag);
307 EXPECT_TRUE(dict.HasKey(key));
308 EXPECT_TRUE(dict.Remove(key, NULL));
309 EXPECT_TRUE(deletion_flag);
310 EXPECT_FALSE(dict.HasKey(key));
311 }
312}
313
[email protected]58b916e2011-06-28 22:56:33314TEST(ValuesTest, DictionaryWithoutPathExpansion) {
[email protected]4dad9ad82009-11-25 20:47:52315 DictionaryValue dict;
[email protected]9e4cda7332010-07-31 04:56:14316 dict.Set("this.is.expanded", Value::CreateNullValue());
317 dict.SetWithoutPathExpansion("this.isnt.expanded", Value::CreateNullValue());
318
319 EXPECT_FALSE(dict.HasKey("this.is.expanded"));
320 EXPECT_TRUE(dict.HasKey("this"));
321 Value* value1;
322 EXPECT_TRUE(dict.Get("this", &value1));
323 DictionaryValue* value2;
324 ASSERT_TRUE(dict.GetDictionaryWithoutPathExpansion("this", &value2));
325 EXPECT_EQ(value1, value2);
326 EXPECT_EQ(1U, value2->size());
327
328 EXPECT_TRUE(dict.HasKey("this.isnt.expanded"));
329 Value* value3;
330 EXPECT_FALSE(dict.Get("this.isnt.expanded", &value3));
331 Value* value4;
332 ASSERT_TRUE(dict.GetWithoutPathExpansion("this.isnt.expanded", &value4));
333 EXPECT_EQ(Value::TYPE_NULL, value4->GetType());
334}
335
[email protected]58b916e2011-06-28 22:56:33336TEST(ValuesTest, DeepCopy) {
initial.commitd7cae122008-07-26 21:49:38337 DictionaryValue original_dict;
338 Value* original_null = Value::CreateNullValue();
[email protected]9e4cda7332010-07-31 04:56:14339 original_dict.Set("null", original_null);
[email protected]7e3ec42c2012-12-16 05:13:21340 FundamentalValue* original_bool = new FundamentalValue(true);
[email protected]9e4cda7332010-07-31 04:56:14341 original_dict.Set("bool", original_bool);
[email protected]7e3ec42c2012-12-16 05:13:21342 FundamentalValue* original_int = new FundamentalValue(42);
[email protected]9e4cda7332010-07-31 04:56:14343 original_dict.Set("int", original_int);
[email protected]7e3ec42c2012-12-16 05:13:21344 FundamentalValue* original_double = new FundamentalValue(3.14);
[email protected]fb534c92011-02-01 01:02:07345 original_dict.Set("double", original_double);
[email protected]7e3ec42c2012-12-16 05:13:21346 StringValue* original_string = new StringValue("hello");
[email protected]9e4cda7332010-07-31 04:56:14347 original_dict.Set("string", original_string);
[email protected]7e3ec42c2012-12-16 05:13:21348 StringValue* original_string16 = new StringValue(ASCIIToUTF16("hello16"));
[email protected]e2e593d2010-08-03 15:42:58349 original_dict.Set("string16", original_string16);
[email protected]9e4cda7332010-07-31 04:56:14350
[email protected]0d0ed0c2012-05-20 02:34:57351 char* original_buffer = new char[42];
352 memset(original_buffer, '!', 42);
353 BinaryValue* original_binary = BinaryValue::Create(original_buffer, 42);
[email protected]9e4cda7332010-07-31 04:56:14354 original_dict.Set("binary", original_binary);
355
356 ListValue* original_list = new ListValue();
[email protected]7e3ec42c2012-12-16 05:13:21357 FundamentalValue* original_list_element_0 = new FundamentalValue(0);
[email protected]9e4cda7332010-07-31 04:56:14358 original_list->Append(original_list_element_0);
[email protected]7e3ec42c2012-12-16 05:13:21359 FundamentalValue* original_list_element_1 = new FundamentalValue(1);
[email protected]9e4cda7332010-07-31 04:56:14360 original_list->Append(original_list_element_1);
361 original_dict.Set("list", original_list);
362
[email protected]5cf906f82011-11-26 01:11:44363 DictionaryValue* original_nested_dictionary = new DictionaryValue();
[email protected]7e3ec42c2012-12-16 05:13:21364 original_nested_dictionary->Set("key", new StringValue("value"));
[email protected]5cf906f82011-11-26 01:11:44365 original_dict.Set("dictionary", original_nested_dictionary);
366
[email protected]16f47e082011-01-18 02:16:59367 scoped_ptr<DictionaryValue> copy_dict(original_dict.DeepCopy());
[email protected]9e4cda7332010-07-31 04:56:14368 ASSERT_TRUE(copy_dict.get());
369 ASSERT_NE(copy_dict.get(), &original_dict);
370
371 Value* copy_null = NULL;
372 ASSERT_TRUE(copy_dict->Get("null", &copy_null));
373 ASSERT_TRUE(copy_null);
374 ASSERT_NE(copy_null, original_null);
375 ASSERT_TRUE(copy_null->IsType(Value::TYPE_NULL));
376
377 Value* copy_bool = NULL;
378 ASSERT_TRUE(copy_dict->Get("bool", &copy_bool));
379 ASSERT_TRUE(copy_bool);
380 ASSERT_NE(copy_bool, original_bool);
381 ASSERT_TRUE(copy_bool->IsType(Value::TYPE_BOOLEAN));
382 bool copy_bool_value = false;
383 ASSERT_TRUE(copy_bool->GetAsBoolean(&copy_bool_value));
384 ASSERT_TRUE(copy_bool_value);
385
386 Value* copy_int = NULL;
387 ASSERT_TRUE(copy_dict->Get("int", &copy_int));
388 ASSERT_TRUE(copy_int);
389 ASSERT_NE(copy_int, original_int);
390 ASSERT_TRUE(copy_int->IsType(Value::TYPE_INTEGER));
391 int copy_int_value = 0;
392 ASSERT_TRUE(copy_int->GetAsInteger(&copy_int_value));
393 ASSERT_EQ(42, copy_int_value);
394
[email protected]fb534c92011-02-01 01:02:07395 Value* copy_double = NULL;
396 ASSERT_TRUE(copy_dict->Get("double", &copy_double));
397 ASSERT_TRUE(copy_double);
398 ASSERT_NE(copy_double, original_double);
399 ASSERT_TRUE(copy_double->IsType(Value::TYPE_DOUBLE));
400 double copy_double_value = 0;
401 ASSERT_TRUE(copy_double->GetAsDouble(&copy_double_value));
402 ASSERT_EQ(3.14, copy_double_value);
[email protected]9e4cda7332010-07-31 04:56:14403
404 Value* copy_string = NULL;
405 ASSERT_TRUE(copy_dict->Get("string", &copy_string));
406 ASSERT_TRUE(copy_string);
407 ASSERT_NE(copy_string, original_string);
408 ASSERT_TRUE(copy_string->IsType(Value::TYPE_STRING));
409 std::string copy_string_value;
[email protected]e2e593d2010-08-03 15:42:58410 string16 copy_string16_value;
[email protected]9e4cda7332010-07-31 04:56:14411 ASSERT_TRUE(copy_string->GetAsString(&copy_string_value));
[email protected]e2e593d2010-08-03 15:42:58412 ASSERT_TRUE(copy_string->GetAsString(&copy_string16_value));
[email protected]9e4cda7332010-07-31 04:56:14413 ASSERT_EQ(std::string("hello"), copy_string_value);
[email protected]e2e593d2010-08-03 15:42:58414 ASSERT_EQ(ASCIIToUTF16("hello"), copy_string16_value);
[email protected]9e4cda7332010-07-31 04:56:14415
[email protected]e2e593d2010-08-03 15:42:58416 Value* copy_string16 = NULL;
417 ASSERT_TRUE(copy_dict->Get("string16", &copy_string16));
418 ASSERT_TRUE(copy_string16);
419 ASSERT_NE(copy_string16, original_string16);
420 ASSERT_TRUE(copy_string16->IsType(Value::TYPE_STRING));
421 ASSERT_TRUE(copy_string16->GetAsString(&copy_string_value));
422 ASSERT_TRUE(copy_string16->GetAsString(&copy_string16_value));
[email protected]9e4cda7332010-07-31 04:56:14423 ASSERT_EQ(std::string("hello16"), copy_string_value);
[email protected]e2e593d2010-08-03 15:42:58424 ASSERT_EQ(ASCIIToUTF16("hello16"), copy_string16_value);
[email protected]9e4cda7332010-07-31 04:56:14425
426 Value* copy_binary = NULL;
427 ASSERT_TRUE(copy_dict->Get("binary", &copy_binary));
428 ASSERT_TRUE(copy_binary);
429 ASSERT_NE(copy_binary, original_binary);
[email protected]0de764e2011-08-26 01:54:00430 ASSERT_TRUE(copy_binary->IsType(Value::TYPE_BINARY));
431 ASSERT_NE(original_binary->GetBuffer(),
432 static_cast<BinaryValue*>(copy_binary)->GetBuffer());
433 ASSERT_EQ(original_binary->GetSize(),
434 static_cast<BinaryValue*>(copy_binary)->GetSize());
[email protected]9e4cda7332010-07-31 04:56:14435 ASSERT_EQ(0, memcmp(original_binary->GetBuffer(),
[email protected]0de764e2011-08-26 01:54:00436 static_cast<BinaryValue*>(copy_binary)->GetBuffer(),
437 original_binary->GetSize()));
[email protected]9e4cda7332010-07-31 04:56:14438
439 Value* copy_value = NULL;
440 ASSERT_TRUE(copy_dict->Get("list", &copy_value));
441 ASSERT_TRUE(copy_value);
442 ASSERT_NE(copy_value, original_list);
[email protected]0de764e2011-08-26 01:54:00443 ASSERT_TRUE(copy_value->IsType(Value::TYPE_LIST));
[email protected]5cf906f82011-11-26 01:11:44444 ListValue* copy_list = NULL;
445 ASSERT_TRUE(copy_value->GetAsList(&copy_list));
446 ASSERT_TRUE(copy_list);
[email protected]9e4cda7332010-07-31 04:56:14447 ASSERT_EQ(2U, copy_list->GetSize());
448
449 Value* copy_list_element_0;
450 ASSERT_TRUE(copy_list->Get(0, &copy_list_element_0));
451 ASSERT_TRUE(copy_list_element_0);
452 ASSERT_NE(copy_list_element_0, original_list_element_0);
453 int copy_list_element_0_value;
454 ASSERT_TRUE(copy_list_element_0->GetAsInteger(&copy_list_element_0_value));
455 ASSERT_EQ(0, copy_list_element_0_value);
456
457 Value* copy_list_element_1;
458 ASSERT_TRUE(copy_list->Get(1, &copy_list_element_1));
459 ASSERT_TRUE(copy_list_element_1);
460 ASSERT_NE(copy_list_element_1, original_list_element_1);
461 int copy_list_element_1_value;
462 ASSERT_TRUE(copy_list_element_1->GetAsInteger(&copy_list_element_1_value));
463 ASSERT_EQ(1, copy_list_element_1_value);
[email protected]5cf906f82011-11-26 01:11:44464
465 copy_value = NULL;
466 ASSERT_TRUE(copy_dict->Get("dictionary", &copy_value));
467 ASSERT_TRUE(copy_value);
468 ASSERT_NE(copy_value, original_nested_dictionary);
469 ASSERT_TRUE(copy_value->IsType(Value::TYPE_DICTIONARY));
470 DictionaryValue* copy_nested_dictionary = NULL;
471 ASSERT_TRUE(copy_value->GetAsDictionary(&copy_nested_dictionary));
472 ASSERT_TRUE(copy_nested_dictionary);
473 EXPECT_TRUE(copy_nested_dictionary->HasKey("key"));
[email protected]9e4cda7332010-07-31 04:56:14474}
475
[email protected]58b916e2011-06-28 22:56:33476TEST(ValuesTest, Equals) {
initial.commitd7cae122008-07-26 21:49:38477 Value* null1 = Value::CreateNullValue();
478 Value* null2 = Value::CreateNullValue();
479 EXPECT_NE(null1, null2);
480 EXPECT_TRUE(null1->Equals(null2));
481
[email protected]7e3ec42c2012-12-16 05:13:21482 Value* boolean = new FundamentalValue(false);
initial.commitd7cae122008-07-26 21:49:38483 EXPECT_FALSE(null1->Equals(boolean));
484 delete null1;
485 delete null2;
486 delete boolean;
487
488 DictionaryValue dv;
[email protected]9e4cda7332010-07-31 04:56:14489 dv.SetBoolean("a", false);
490 dv.SetInteger("b", 2);
[email protected]fb534c92011-02-01 01:02:07491 dv.SetDouble("c", 2.5);
[email protected]9e4cda7332010-07-31 04:56:14492 dv.SetString("d1", "string");
[email protected]ff4c1d82010-08-04 16:58:12493 dv.SetString("d2", ASCIIToUTF16("http://google.com"));
[email protected]9e4cda7332010-07-31 04:56:14494 dv.Set("e", Value::CreateNullValue());
495
[email protected]dc1f2442010-08-18 16:23:40496 scoped_ptr<DictionaryValue> copy;
[email protected]16f47e082011-01-18 02:16:59497 copy.reset(dv.DeepCopy());
[email protected]dc1f2442010-08-18 16:23:40498 EXPECT_TRUE(dv.Equals(copy.get()));
[email protected]9e4cda7332010-07-31 04:56:14499
500 ListValue* list = new ListValue;
501 list->Append(Value::CreateNullValue());
502 list->Append(new DictionaryValue);
503 dv.Set("f", list);
504
[email protected]dc1f2442010-08-18 16:23:40505 EXPECT_FALSE(dv.Equals(copy.get()));
[email protected]9e4cda7332010-07-31 04:56:14506 copy->Set("f", list->DeepCopy());
[email protected]dc1f2442010-08-18 16:23:40507 EXPECT_TRUE(dv.Equals(copy.get()));
[email protected]9e4cda7332010-07-31 04:56:14508
[email protected]7e3ec42c2012-12-16 05:13:21509 list->Append(new FundamentalValue(true));
[email protected]dc1f2442010-08-18 16:23:40510 EXPECT_FALSE(dv.Equals(copy.get()));
511
512 // Check if Equals detects differences in only the keys.
[email protected]16f47e082011-01-18 02:16:59513 copy.reset(dv.DeepCopy());
[email protected]dc1f2442010-08-18 16:23:40514 EXPECT_TRUE(dv.Equals(copy.get()));
515 copy->Remove("a", NULL);
516 copy->SetBoolean("aa", false);
517 EXPECT_FALSE(dv.Equals(copy.get()));
[email protected]9e4cda7332010-07-31 04:56:14518}
519
[email protected]58b916e2011-06-28 22:56:33520TEST(ValuesTest, StaticEquals) {
[email protected]73c47932010-12-06 18:13:43521 scoped_ptr<Value> null1(Value::CreateNullValue());
522 scoped_ptr<Value> null2(Value::CreateNullValue());
523 EXPECT_TRUE(Value::Equals(null1.get(), null2.get()));
524 EXPECT_TRUE(Value::Equals(NULL, NULL));
525
[email protected]7e3ec42c2012-12-16 05:13:21526 scoped_ptr<Value> i42(new FundamentalValue(42));
527 scoped_ptr<Value> j42(new FundamentalValue(42));
528 scoped_ptr<Value> i17(new FundamentalValue(17));
[email protected]73c47932010-12-06 18:13:43529 EXPECT_TRUE(Value::Equals(i42.get(), i42.get()));
530 EXPECT_TRUE(Value::Equals(j42.get(), i42.get()));
531 EXPECT_TRUE(Value::Equals(i42.get(), j42.get()));
532 EXPECT_FALSE(Value::Equals(i42.get(), i17.get()));
533 EXPECT_FALSE(Value::Equals(i42.get(), NULL));
534 EXPECT_FALSE(Value::Equals(NULL, i42.get()));
535
536 // NULL and Value::CreateNullValue() are intentionally different: We need
537 // support for NULL as a return value for "undefined" without caring for
538 // ownership of the pointer.
539 EXPECT_FALSE(Value::Equals(null1.get(), NULL));
540 EXPECT_FALSE(Value::Equals(NULL, null1.get()));
541}
542
[email protected]58b916e2011-06-28 22:56:33543TEST(ValuesTest, DeepCopyCovariantReturnTypes) {
[email protected]16f47e082011-01-18 02:16:59544 DictionaryValue original_dict;
545 Value* original_null = Value::CreateNullValue();
546 original_dict.Set("null", original_null);
[email protected]7e3ec42c2012-12-16 05:13:21547 FundamentalValue* original_bool = new FundamentalValue(true);
[email protected]16f47e082011-01-18 02:16:59548 original_dict.Set("bool", original_bool);
[email protected]7e3ec42c2012-12-16 05:13:21549 FundamentalValue* original_int = new FundamentalValue(42);
[email protected]16f47e082011-01-18 02:16:59550 original_dict.Set("int", original_int);
[email protected]7e3ec42c2012-12-16 05:13:21551 FundamentalValue* original_double = new FundamentalValue(3.14);
[email protected]fb534c92011-02-01 01:02:07552 original_dict.Set("double", original_double);
[email protected]7e3ec42c2012-12-16 05:13:21553 StringValue* original_string = new StringValue("hello");
[email protected]16f47e082011-01-18 02:16:59554 original_dict.Set("string", original_string);
[email protected]7e3ec42c2012-12-16 05:13:21555 StringValue* original_string16 = new StringValue(ASCIIToUTF16("hello16"));
[email protected]16f47e082011-01-18 02:16:59556 original_dict.Set("string16", original_string16);
557
[email protected]0d0ed0c2012-05-20 02:34:57558 char* original_buffer = new char[42];
559 memset(original_buffer, '!', 42);
560 BinaryValue* original_binary = BinaryValue::Create(original_buffer, 42);
[email protected]16f47e082011-01-18 02:16:59561 original_dict.Set("binary", original_binary);
562
563 ListValue* original_list = new ListValue();
[email protected]7e3ec42c2012-12-16 05:13:21564 FundamentalValue* original_list_element_0 = new FundamentalValue(0);
[email protected]16f47e082011-01-18 02:16:59565 original_list->Append(original_list_element_0);
[email protected]7e3ec42c2012-12-16 05:13:21566 FundamentalValue* original_list_element_1 = new FundamentalValue(1);
[email protected]16f47e082011-01-18 02:16:59567 original_list->Append(original_list_element_1);
568 original_dict.Set("list", original_list);
569
570 Value* original_dict_value = &original_dict;
571 Value* original_bool_value = original_bool;
572 Value* original_int_value = original_int;
[email protected]fb534c92011-02-01 01:02:07573 Value* original_double_value = original_double;
[email protected]16f47e082011-01-18 02:16:59574 Value* original_string_value = original_string;
575 Value* original_string16_value = original_string16;
576 Value* original_binary_value = original_binary;
577 Value* original_list_value = original_list;
578
579 scoped_ptr<Value> copy_dict_value(original_dict_value->DeepCopy());
580 scoped_ptr<Value> copy_bool_value(original_bool_value->DeepCopy());
581 scoped_ptr<Value> copy_int_value(original_int_value->DeepCopy());
[email protected]fb534c92011-02-01 01:02:07582 scoped_ptr<Value> copy_double_value(original_double_value->DeepCopy());
[email protected]16f47e082011-01-18 02:16:59583 scoped_ptr<Value> copy_string_value(original_string_value->DeepCopy());
584 scoped_ptr<Value> copy_string16_value(original_string16_value->DeepCopy());
585 scoped_ptr<Value> copy_binary_value(original_binary_value->DeepCopy());
586 scoped_ptr<Value> copy_list_value(original_list_value->DeepCopy());
587
588 EXPECT_TRUE(original_dict_value->Equals(copy_dict_value.get()));
589 EXPECT_TRUE(original_bool_value->Equals(copy_bool_value.get()));
590 EXPECT_TRUE(original_int_value->Equals(copy_int_value.get()));
[email protected]fb534c92011-02-01 01:02:07591 EXPECT_TRUE(original_double_value->Equals(copy_double_value.get()));
[email protected]16f47e082011-01-18 02:16:59592 EXPECT_TRUE(original_string_value->Equals(copy_string_value.get()));
593 EXPECT_TRUE(original_string16_value->Equals(copy_string16_value.get()));
594 EXPECT_TRUE(original_binary_value->Equals(copy_binary_value.get()));
595 EXPECT_TRUE(original_list_value->Equals(copy_list_value.get()));
596}
597
[email protected]58b916e2011-06-28 22:56:33598TEST(ValuesTest, RemoveEmptyChildren) {
[email protected]ec330b52009-12-02 00:20:32599 scoped_ptr<DictionaryValue> root(new DictionaryValue);
600 // Remove empty lists and dictionaries.
[email protected]9e4cda7332010-07-31 04:56:14601 root->Set("empty_dict", new DictionaryValue);
602 root->Set("empty_list", new ListValue);
603 root->SetWithoutPathExpansion("a.b.c.d.e", new DictionaryValue);
604 root.reset(root->DeepCopyWithoutEmptyChildren());
605 EXPECT_TRUE(root->empty());
606
607 // Make sure we don't prune too much.
608 root->SetBoolean("bool", true);
609 root->Set("empty_dict", new DictionaryValue);
610 root->SetString("empty_string", "");
611 root.reset(root->DeepCopyWithoutEmptyChildren());
612 EXPECT_EQ(2U, root->size());
613
614 // Should do nothing.
615 root.reset(root->DeepCopyWithoutEmptyChildren());
616 EXPECT_EQ(2U, root->size());
617
618 // Nested test cases. These should all reduce back to the bool and string
619 // set above.
620 {
621 root->Set("a.b.c.d.e", new DictionaryValue);
622 root.reset(root->DeepCopyWithoutEmptyChildren());
623 EXPECT_EQ(2U, root->size());
624 }
625 {
626 DictionaryValue* inner = new DictionaryValue;
627 root->Set("dict_with_emtpy_children", inner);
628 inner->Set("empty_dict", new DictionaryValue);
629 inner->Set("empty_list", new ListValue);
630 root.reset(root->DeepCopyWithoutEmptyChildren());
631 EXPECT_EQ(2U, root->size());
632 }
633 {
634 ListValue* inner = new ListValue;
635 root->Set("list_with_empty_children", inner);
636 inner->Append(new DictionaryValue);
637 inner->Append(new ListValue);
638 root.reset(root->DeepCopyWithoutEmptyChildren());
639 EXPECT_EQ(2U, root->size());
640 }
641
642 // Nested with siblings.
643 {
644 ListValue* inner = new ListValue;
645 root->Set("list_with_empty_children", inner);
646 inner->Append(new DictionaryValue);
647 inner->Append(new ListValue);
648 DictionaryValue* inner2 = new DictionaryValue;
649 root->Set("dict_with_empty_children", inner2);
650 inner2->Set("empty_dict", new DictionaryValue);
651 inner2->Set("empty_list", new ListValue);
652 root.reset(root->DeepCopyWithoutEmptyChildren());
653 EXPECT_EQ(2U, root->size());
654 }
655
656 // Make sure nested values don't get pruned.
657 {
658 ListValue* inner = new ListValue;
659 root->Set("list_with_empty_children", inner);
660 ListValue* inner2 = new ListValue;
661 inner->Append(new DictionaryValue);
662 inner->Append(inner2);
[email protected]7e3ec42c2012-12-16 05:13:21663 inner2->Append(new StringValue("hello"));
[email protected]9e4cda7332010-07-31 04:56:14664 root.reset(root->DeepCopyWithoutEmptyChildren());
665 EXPECT_EQ(3U, root->size());
666 EXPECT_TRUE(root->GetList("list_with_empty_children", &inner));
667 EXPECT_EQ(1U, inner->GetSize()); // Dictionary was pruned.
668 EXPECT_TRUE(inner->GetList(0, &inner2));
669 EXPECT_EQ(1U, inner2->GetSize());
670 }
671}
672
[email protected]58b916e2011-06-28 22:56:33673TEST(ValuesTest, MergeDictionary) {
[email protected]c378cca2010-05-14 13:17:40674 scoped_ptr<DictionaryValue> base(new DictionaryValue);
[email protected]9e4cda7332010-07-31 04:56:14675 base->SetString("base_key", "base_key_value_base");
676 base->SetString("collide_key", "collide_key_value_base");
677 DictionaryValue* base_sub_dict = new DictionaryValue;
678 base_sub_dict->SetString("sub_base_key", "sub_base_key_value_base");
679 base_sub_dict->SetString("sub_collide_key", "sub_collide_key_value_base");
680 base->Set("sub_dict_key", base_sub_dict);
681
682 scoped_ptr<DictionaryValue> merge(new DictionaryValue);
683 merge->SetString("merge_key", "merge_key_value_merge");
684 merge->SetString("collide_key", "collide_key_value_merge");
685 DictionaryValue* merge_sub_dict = new DictionaryValue;
686 merge_sub_dict->SetString("sub_merge_key", "sub_merge_key_value_merge");
687 merge_sub_dict->SetString("sub_collide_key", "sub_collide_key_value_merge");
688 merge->Set("sub_dict_key", merge_sub_dict);
689
690 base->MergeDictionary(merge.get());
691
692 EXPECT_EQ(4U, base->size());
693 std::string base_key_value;
694 EXPECT_TRUE(base->GetString("base_key", &base_key_value));
695 EXPECT_EQ("base_key_value_base", base_key_value); // Base value preserved.
696 std::string collide_key_value;
697 EXPECT_TRUE(base->GetString("collide_key", &collide_key_value));
698 EXPECT_EQ("collide_key_value_merge", collide_key_value); // Replaced.
699 std::string merge_key_value;
700 EXPECT_TRUE(base->GetString("merge_key", &merge_key_value));
701 EXPECT_EQ("merge_key_value_merge", merge_key_value); // Merged in.
702
703 DictionaryValue* res_sub_dict;
704 EXPECT_TRUE(base->GetDictionary("sub_dict_key", &res_sub_dict));
705 EXPECT_EQ(3U, res_sub_dict->size());
706 std::string sub_base_key_value;
707 EXPECT_TRUE(res_sub_dict->GetString("sub_base_key", &sub_base_key_value));
708 EXPECT_EQ("sub_base_key_value_base", sub_base_key_value); // Preserved.
709 std::string sub_collide_key_value;
710 EXPECT_TRUE(res_sub_dict->GetString("sub_collide_key",
711 &sub_collide_key_value));
712 EXPECT_EQ("sub_collide_key_value_merge", sub_collide_key_value); // Replaced.
713 std::string sub_merge_key_value;
714 EXPECT_TRUE(res_sub_dict->GetString("sub_merge_key", &sub_merge_key_value));
715 EXPECT_EQ("sub_merge_key_value_merge", sub_merge_key_value); // Merged in.
716}
[email protected]58b916e2011-06-28 22:56:33717
[email protected]13502562012-05-09 21:54:27718TEST(ValuesTest, MergeDictionaryDeepCopy) {
719 DictionaryValue* child = new DictionaryValue;
720 child->SetString("test", "value");
721 EXPECT_EQ(1U, child->size());
722
723 std::string value;
724 EXPECT_TRUE(child->GetString("test", &value));
725 EXPECT_EQ("value", value);
726
727 scoped_ptr<DictionaryValue> base(new DictionaryValue);
728 base->Set("dict", child);
729 EXPECT_EQ(1U, base->size());
730
731 DictionaryValue* ptr;
732 EXPECT_TRUE(base->GetDictionary("dict", &ptr));
733 EXPECT_EQ(child, ptr);
734
735 scoped_ptr<DictionaryValue> merged(new DictionaryValue);
736 merged->MergeDictionary(base.get());
737 EXPECT_EQ(1U, merged->size());
738 EXPECT_TRUE(merged->GetDictionary("dict", &ptr));
739 EXPECT_NE(child, ptr);
740 EXPECT_TRUE(ptr->GetString("test", &value));
741 EXPECT_EQ("value", value);
742
743 child->SetString("test", "overwrite");
744 base.reset();
745 EXPECT_TRUE(ptr->GetString("test", &value));
746 EXPECT_EQ("value", value);
747}
748
[email protected]32c0e002011-11-08 21:26:41749TEST(ValuesTest, DictionaryIterator) {
750 DictionaryValue dict;
751 for (DictionaryValue::Iterator it(dict); it.HasNext(); it.Advance()) {
752 ADD_FAILURE();
753 }
754
755 StringValue value1("value1");
756 dict.Set("key1", value1.DeepCopy());
757 bool seen1 = false;
758 for (DictionaryValue::Iterator it(dict); it.HasNext(); it.Advance()) {
759 EXPECT_FALSE(seen1);
760 EXPECT_EQ("key1", it.key());
761 EXPECT_TRUE(value1.Equals(&it.value()));
762 seen1 = true;
763 }
764 EXPECT_TRUE(seen1);
765
766 StringValue value2("value2");
767 dict.Set("key2", value2.DeepCopy());
768 bool seen2 = seen1 = false;
769 for (DictionaryValue::Iterator it(dict); it.HasNext(); it.Advance()) {
770 if (it.key() == "key1") {
771 EXPECT_FALSE(seen1);
772 EXPECT_TRUE(value1.Equals(&it.value()));
773 seen1 = true;
774 } else if (it.key() == "key2") {
775 EXPECT_FALSE(seen2);
776 EXPECT_TRUE(value2.Equals(&it.value()));
777 seen2 = true;
778 } else {
779 ADD_FAILURE();
780 }
781 }
782 EXPECT_TRUE(seen1);
783 EXPECT_TRUE(seen2);
784}
785
[email protected]58b916e2011-06-28 22:56:33786} // namespace base