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 | |
dcheng | cc8e4d8 | 2016-04-05 06:25:51 +0900 | [diff] [blame] | 5 | #include "base/values.h" |
| 6 | |
avi | a6a6a68 | 2015-12-27 07:15:14 +0900 | [diff] [blame] | 7 | #include <stddef.h> |
| 8 | |
deanm@google.com | 19650de | 2008-08-13 23:57:51 +0900 | [diff] [blame] | 9 | #include <limits> |
dcheng | cc8e4d8 | 2016-04-05 06:25:51 +0900 | [diff] [blame] | 10 | #include <memory> |
jdoerrie | 74f7680 | 2017-03-30 15:40:29 +0900 | [diff] [blame] | 11 | #include <string> |
| 12 | #include <type_traits> |
danakj | 800d2ea | 2015-11-25 14:29:58 +0900 | [diff] [blame] | 13 | #include <utility> |
jdoerrie | 58325a4 | 2017-02-15 17:42:14 +0900 | [diff] [blame] | 14 | #include <vector> |
deanm@google.com | 19650de | 2008-08-13 23:57:51 +0900 | [diff] [blame] | 15 | |
dcheng | cc8e4d8 | 2016-04-05 06:25:51 +0900 | [diff] [blame] | 16 | #include "base/memory/ptr_util.h" |
avi@chromium.org | 68a745c | 2013-06-11 05:11:14 +0900 | [diff] [blame] | 17 | #include "base/strings/string16.h" |
avi@chromium.org | 17f6062 | 2013-06-08 03:37:07 +0900 | [diff] [blame] | 18 | #include "base/strings/utf_string_conversions.h" |
initial.commit | 3f4a732 | 2008-07-27 06:49:38 +0900 | [diff] [blame] | 19 | #include "testing/gtest/include/gtest/gtest.h" |
| 20 | |
tfarina@chromium.org | 4cdd38e | 2011-06-29 07:56:33 +0900 | [diff] [blame] | 21 | namespace base { |
initial.commit | 3f4a732 | 2008-07-27 06:49:38 +0900 | [diff] [blame] | 22 | |
jdoerrie | 74f7680 | 2017-03-30 15:40:29 +0900 | [diff] [blame] | 23 | TEST(ValuesTest, TestNothrow) { |
jdoerrie | d4796f0 | 2017-04-04 17:54:21 +0900 | [diff] [blame] | 24 | static_assert(std::is_nothrow_move_constructible<Value>::value, |
jdoerrie | 74f7680 | 2017-03-30 15:40:29 +0900 | [diff] [blame] | 25 | "IsNothrowMoveConstructible"); |
jdoerrie | d4796f0 | 2017-04-04 17:54:21 +0900 | [diff] [blame] | 26 | static_assert(std::is_nothrow_default_constructible<Value>::value, |
jdoerrie | 74f7680 | 2017-03-30 15:40:29 +0900 | [diff] [blame] | 27 | "IsNothrowDefaultConstructible"); |
| 28 | static_assert(std::is_nothrow_constructible<Value, std::string&&>::value, |
| 29 | "IsNothrowMoveConstructibleFromString"); |
| 30 | static_assert( |
| 31 | std::is_nothrow_constructible<Value, std::vector<char>&&>::value, |
| 32 | "IsNothrowMoveConstructibleFromBlob"); |
jdoerrie | d4796f0 | 2017-04-04 17:54:21 +0900 | [diff] [blame] | 33 | static_assert(std::is_nothrow_move_assignable<Value>::value, |
| 34 | "IsNothrowMoveAssignable"); |
jdoerrie | 74f7680 | 2017-03-30 15:40:29 +0900 | [diff] [blame] | 35 | } |
| 36 | |
jdoerrie | 93a0cf3 | 2017-02-01 19:36:56 +0900 | [diff] [blame] | 37 | // Group of tests for the value constructors. |
| 38 | TEST(ValuesTest, ConstructBool) { |
jdoerrie | bfe825e | 2017-03-02 21:09:19 +0900 | [diff] [blame] | 39 | Value true_value(true); |
jdoerrie | 93a0cf3 | 2017-02-01 19:36:56 +0900 | [diff] [blame] | 40 | EXPECT_EQ(Value::Type::BOOLEAN, true_value.type()); |
| 41 | EXPECT_TRUE(true_value.GetBool()); |
| 42 | |
jdoerrie | bfe825e | 2017-03-02 21:09:19 +0900 | [diff] [blame] | 43 | Value false_value(false); |
jdoerrie | 93a0cf3 | 2017-02-01 19:36:56 +0900 | [diff] [blame] | 44 | EXPECT_EQ(Value::Type::BOOLEAN, false_value.type()); |
| 45 | EXPECT_FALSE(false_value.GetBool()); |
| 46 | } |
| 47 | |
| 48 | TEST(ValuesTest, ConstructInt) { |
jdoerrie | bfe825e | 2017-03-02 21:09:19 +0900 | [diff] [blame] | 49 | Value value(-37); |
jdoerrie | 93a0cf3 | 2017-02-01 19:36:56 +0900 | [diff] [blame] | 50 | EXPECT_EQ(Value::Type::INTEGER, value.type()); |
| 51 | EXPECT_EQ(-37, value.GetInt()); |
| 52 | } |
| 53 | |
| 54 | TEST(ValuesTest, ConstructDouble) { |
jdoerrie | bfe825e | 2017-03-02 21:09:19 +0900 | [diff] [blame] | 55 | Value value(-4.655); |
jdoerrie | 93a0cf3 | 2017-02-01 19:36:56 +0900 | [diff] [blame] | 56 | EXPECT_EQ(Value::Type::DOUBLE, value.type()); |
| 57 | EXPECT_EQ(-4.655, value.GetDouble()); |
| 58 | } |
| 59 | |
jdoerrie | 3129913 | 2017-02-01 23:38:32 +0900 | [diff] [blame] | 60 | TEST(ValuesTest, ConstructStringFromConstCharPtr) { |
| 61 | const char* str = "foobar"; |
jdoerrie | 0d1295b | 2017-03-06 20:12:04 +0900 | [diff] [blame] | 62 | Value value(str); |
jdoerrie | 3129913 | 2017-02-01 23:38:32 +0900 | [diff] [blame] | 63 | EXPECT_EQ(Value::Type::STRING, value.type()); |
| 64 | EXPECT_EQ("foobar", value.GetString()); |
| 65 | } |
| 66 | |
| 67 | TEST(ValuesTest, ConstructStringFromStdStringConstRef) { |
| 68 | std::string str = "foobar"; |
jdoerrie | 0d1295b | 2017-03-06 20:12:04 +0900 | [diff] [blame] | 69 | Value value(str); |
jdoerrie | 3129913 | 2017-02-01 23:38:32 +0900 | [diff] [blame] | 70 | EXPECT_EQ(Value::Type::STRING, value.type()); |
| 71 | EXPECT_EQ("foobar", value.GetString()); |
| 72 | } |
| 73 | |
| 74 | TEST(ValuesTest, ConstructStringFromStdStringRefRef) { |
| 75 | std::string str = "foobar"; |
jdoerrie | 0d1295b | 2017-03-06 20:12:04 +0900 | [diff] [blame] | 76 | Value value(std::move(str)); |
jdoerrie | 3129913 | 2017-02-01 23:38:32 +0900 | [diff] [blame] | 77 | EXPECT_EQ(Value::Type::STRING, value.type()); |
| 78 | EXPECT_EQ("foobar", value.GetString()); |
| 79 | } |
| 80 | |
| 81 | TEST(ValuesTest, ConstructStringFromConstChar16Ptr) { |
| 82 | string16 str = ASCIIToUTF16("foobar"); |
jdoerrie | 0d1295b | 2017-03-06 20:12:04 +0900 | [diff] [blame] | 83 | Value value(str.c_str()); |
jdoerrie | 3129913 | 2017-02-01 23:38:32 +0900 | [diff] [blame] | 84 | EXPECT_EQ(Value::Type::STRING, value.type()); |
| 85 | EXPECT_EQ("foobar", value.GetString()); |
| 86 | } |
| 87 | |
| 88 | TEST(ValuesTest, ConstructStringFromString16) { |
| 89 | string16 str = ASCIIToUTF16("foobar"); |
jdoerrie | 0d1295b | 2017-03-06 20:12:04 +0900 | [diff] [blame] | 90 | Value value(str); |
jdoerrie | 3129913 | 2017-02-01 23:38:32 +0900 | [diff] [blame] | 91 | EXPECT_EQ(Value::Type::STRING, value.type()); |
| 92 | EXPECT_EQ("foobar", value.GetString()); |
| 93 | } |
| 94 | |
| 95 | TEST(ValuesTest, ConstructStringFromStringPiece) { |
| 96 | StringPiece str = "foobar"; |
jdoerrie | 0d1295b | 2017-03-06 20:12:04 +0900 | [diff] [blame] | 97 | Value value(str); |
jdoerrie | 3129913 | 2017-02-01 23:38:32 +0900 | [diff] [blame] | 98 | EXPECT_EQ(Value::Type::STRING, value.type()); |
| 99 | EXPECT_EQ("foobar", value.GetString()); |
| 100 | } |
| 101 | |
jdoerrie | 58325a4 | 2017-02-15 17:42:14 +0900 | [diff] [blame] | 102 | TEST(ValuesTest, ConstructBinary) { |
jdoerrie | c56cc7f | 2017-04-11 16:45:50 +0900 | [diff] [blame] | 103 | Value value(std::vector<char>({0xF, 0x0, 0x0, 0xB, 0xA, 0x2})); |
jdoerrie | 58325a4 | 2017-02-15 17:42:14 +0900 | [diff] [blame] | 104 | EXPECT_EQ(Value::Type::BINARY, value.type()); |
| 105 | EXPECT_EQ(std::vector<char>({0xF, 0x0, 0x0, 0xB, 0xA, 0x2}), value.GetBlob()); |
| 106 | } |
| 107 | |
jdoerrie | 1d5b348 | 2017-02-17 22:54:49 +0900 | [diff] [blame] | 108 | TEST(ValuesTest, ConstructDict) { |
| 109 | DictionaryValue value; |
| 110 | EXPECT_EQ(Value::Type::DICTIONARY, value.type()); |
| 111 | } |
| 112 | |
| 113 | TEST(ValuesTest, ConstructList) { |
| 114 | ListValue value; |
| 115 | EXPECT_EQ(Value::Type::LIST, value.type()); |
| 116 | } |
| 117 | |
jdoerrie | 93a0cf3 | 2017-02-01 19:36:56 +0900 | [diff] [blame] | 118 | // Group of tests for the copy constructors and copy-assigmnent. For equality |
| 119 | // checks comparisons of the interesting fields are done instead of relying on |
| 120 | // Equals being correct. |
| 121 | TEST(ValuesTest, CopyBool) { |
jdoerrie | bfe825e | 2017-03-02 21:09:19 +0900 | [diff] [blame] | 122 | Value true_value(true); |
| 123 | Value copied_true_value(true_value); |
jdoerrie | 93a0cf3 | 2017-02-01 19:36:56 +0900 | [diff] [blame] | 124 | EXPECT_EQ(true_value.type(), copied_true_value.type()); |
| 125 | EXPECT_EQ(true_value.GetBool(), copied_true_value.GetBool()); |
| 126 | |
jdoerrie | bfe825e | 2017-03-02 21:09:19 +0900 | [diff] [blame] | 127 | Value false_value(false); |
| 128 | Value copied_false_value(false_value); |
jdoerrie | 93a0cf3 | 2017-02-01 19:36:56 +0900 | [diff] [blame] | 129 | EXPECT_EQ(false_value.type(), copied_false_value.type()); |
| 130 | EXPECT_EQ(false_value.GetBool(), copied_false_value.GetBool()); |
| 131 | |
| 132 | Value blank; |
| 133 | |
| 134 | blank = true_value; |
| 135 | EXPECT_EQ(true_value.type(), blank.type()); |
| 136 | EXPECT_EQ(true_value.GetBool(), blank.GetBool()); |
| 137 | |
| 138 | blank = false_value; |
| 139 | EXPECT_EQ(false_value.type(), blank.type()); |
| 140 | EXPECT_EQ(false_value.GetBool(), blank.GetBool()); |
| 141 | } |
| 142 | |
| 143 | TEST(ValuesTest, CopyInt) { |
jdoerrie | bfe825e | 2017-03-02 21:09:19 +0900 | [diff] [blame] | 144 | Value value(74); |
| 145 | Value copied_value(value); |
jdoerrie | 93a0cf3 | 2017-02-01 19:36:56 +0900 | [diff] [blame] | 146 | EXPECT_EQ(value.type(), copied_value.type()); |
| 147 | EXPECT_EQ(value.GetInt(), copied_value.GetInt()); |
| 148 | |
| 149 | Value blank; |
| 150 | |
| 151 | blank = value; |
| 152 | EXPECT_EQ(value.type(), blank.type()); |
| 153 | EXPECT_EQ(value.GetInt(), blank.GetInt()); |
| 154 | } |
| 155 | |
| 156 | TEST(ValuesTest, CopyDouble) { |
jdoerrie | bfe825e | 2017-03-02 21:09:19 +0900 | [diff] [blame] | 157 | Value value(74.896); |
| 158 | Value copied_value(value); |
jdoerrie | 93a0cf3 | 2017-02-01 19:36:56 +0900 | [diff] [blame] | 159 | EXPECT_EQ(value.type(), copied_value.type()); |
| 160 | EXPECT_EQ(value.GetDouble(), copied_value.GetDouble()); |
| 161 | |
| 162 | Value blank; |
| 163 | |
| 164 | blank = value; |
| 165 | EXPECT_EQ(value.type(), blank.type()); |
| 166 | EXPECT_EQ(value.GetDouble(), blank.GetDouble()); |
| 167 | } |
| 168 | |
jdoerrie | 3129913 | 2017-02-01 23:38:32 +0900 | [diff] [blame] | 169 | TEST(ValuesTest, CopyString) { |
jdoerrie | 0d1295b | 2017-03-06 20:12:04 +0900 | [diff] [blame] | 170 | Value value("foobar"); |
| 171 | Value copied_value(value); |
jdoerrie | 3129913 | 2017-02-01 23:38:32 +0900 | [diff] [blame] | 172 | EXPECT_EQ(value.type(), copied_value.type()); |
| 173 | EXPECT_EQ(value.GetString(), copied_value.GetString()); |
| 174 | |
| 175 | Value blank; |
| 176 | |
| 177 | blank = value; |
| 178 | EXPECT_EQ(value.type(), blank.type()); |
| 179 | EXPECT_EQ(value.GetString(), blank.GetString()); |
| 180 | } |
| 181 | |
jdoerrie | 58325a4 | 2017-02-15 17:42:14 +0900 | [diff] [blame] | 182 | TEST(ValuesTest, CopyBinary) { |
jdoerrie | c56cc7f | 2017-04-11 16:45:50 +0900 | [diff] [blame] | 183 | Value value(std::vector<char>({0xF, 0x0, 0x0, 0xB, 0xA, 0x2})); |
| 184 | Value copied_value(value); |
jdoerrie | 58325a4 | 2017-02-15 17:42:14 +0900 | [diff] [blame] | 185 | EXPECT_EQ(value.type(), copied_value.type()); |
| 186 | EXPECT_EQ(value.GetBlob(), copied_value.GetBlob()); |
| 187 | |
| 188 | Value blank; |
| 189 | |
| 190 | blank = value; |
| 191 | EXPECT_EQ(value.type(), blank.type()); |
| 192 | EXPECT_EQ(value.GetBlob(), blank.GetBlob()); |
| 193 | } |
| 194 | |
jdoerrie | 1d5b348 | 2017-02-17 22:54:49 +0900 | [diff] [blame] | 195 | TEST(ValuesTest, CopyDictionary) { |
| 196 | // TODO(crbug.com/646113): Clean this up once DictionaryValue switched to |
| 197 | // value semantics. |
| 198 | int copy; |
| 199 | DictionaryValue value; |
| 200 | value.SetInteger("Int", 123); |
| 201 | |
| 202 | DictionaryValue copied_value(value); |
| 203 | copied_value.GetInteger("Int", ©); |
| 204 | |
| 205 | EXPECT_EQ(value.type(), copied_value.type()); |
| 206 | EXPECT_EQ(123, copy); |
| 207 | |
| 208 | auto blank = MakeUnique<Value>(); |
| 209 | |
| 210 | *blank = value; |
| 211 | EXPECT_EQ(Value::Type::DICTIONARY, blank->type()); |
| 212 | |
| 213 | static_cast<DictionaryValue*>(blank.get())->GetInteger("Int", ©); |
| 214 | EXPECT_EQ(123, copy); |
| 215 | } |
| 216 | |
| 217 | TEST(ValuesTest, CopyList) { |
| 218 | // TODO(crbug.com/646113): Clean this up once ListValue switched to |
| 219 | // value semantics. |
| 220 | int copy; |
| 221 | ListValue value; |
| 222 | value.AppendInteger(123); |
| 223 | |
| 224 | ListValue copied_value(value); |
| 225 | copied_value.GetInteger(0, ©); |
| 226 | |
| 227 | EXPECT_EQ(value.type(), copied_value.type()); |
| 228 | EXPECT_EQ(123, copy); |
| 229 | |
| 230 | auto blank = MakeUnique<Value>(); |
| 231 | |
| 232 | *blank = value; |
| 233 | EXPECT_EQ(Value::Type::LIST, blank->type()); |
| 234 | |
| 235 | static_cast<ListValue*>(blank.get())->GetInteger(0, ©); |
| 236 | EXPECT_EQ(123, copy); |
| 237 | } |
| 238 | |
jdoerrie | 93a0cf3 | 2017-02-01 19:36:56 +0900 | [diff] [blame] | 239 | // Group of tests for the move constructors and move-assigmnent. |
| 240 | TEST(ValuesTest, MoveBool) { |
jdoerrie | bfe825e | 2017-03-02 21:09:19 +0900 | [diff] [blame] | 241 | Value true_value(true); |
| 242 | Value moved_true_value(std::move(true_value)); |
jdoerrie | 93a0cf3 | 2017-02-01 19:36:56 +0900 | [diff] [blame] | 243 | EXPECT_EQ(Value::Type::BOOLEAN, moved_true_value.type()); |
| 244 | EXPECT_TRUE(moved_true_value.GetBool()); |
| 245 | |
jdoerrie | bfe825e | 2017-03-02 21:09:19 +0900 | [diff] [blame] | 246 | Value false_value(false); |
| 247 | Value moved_false_value(std::move(false_value)); |
jdoerrie | 93a0cf3 | 2017-02-01 19:36:56 +0900 | [diff] [blame] | 248 | EXPECT_EQ(Value::Type::BOOLEAN, moved_false_value.type()); |
| 249 | EXPECT_FALSE(moved_false_value.GetBool()); |
| 250 | |
| 251 | Value blank; |
| 252 | |
jdoerrie | bfe825e | 2017-03-02 21:09:19 +0900 | [diff] [blame] | 253 | blank = Value(true); |
jdoerrie | 93a0cf3 | 2017-02-01 19:36:56 +0900 | [diff] [blame] | 254 | EXPECT_EQ(Value::Type::BOOLEAN, blank.type()); |
| 255 | EXPECT_TRUE(blank.GetBool()); |
| 256 | |
jdoerrie | bfe825e | 2017-03-02 21:09:19 +0900 | [diff] [blame] | 257 | blank = Value(false); |
jdoerrie | 93a0cf3 | 2017-02-01 19:36:56 +0900 | [diff] [blame] | 258 | EXPECT_EQ(Value::Type::BOOLEAN, blank.type()); |
| 259 | EXPECT_FALSE(blank.GetBool()); |
| 260 | } |
| 261 | |
| 262 | TEST(ValuesTest, MoveInt) { |
jdoerrie | bfe825e | 2017-03-02 21:09:19 +0900 | [diff] [blame] | 263 | Value value(74); |
| 264 | Value moved_value(std::move(value)); |
jdoerrie | 93a0cf3 | 2017-02-01 19:36:56 +0900 | [diff] [blame] | 265 | EXPECT_EQ(Value::Type::INTEGER, moved_value.type()); |
| 266 | EXPECT_EQ(74, moved_value.GetInt()); |
| 267 | |
| 268 | Value blank; |
| 269 | |
jdoerrie | bfe825e | 2017-03-02 21:09:19 +0900 | [diff] [blame] | 270 | blank = Value(47); |
jdoerrie | 93a0cf3 | 2017-02-01 19:36:56 +0900 | [diff] [blame] | 271 | EXPECT_EQ(Value::Type::INTEGER, blank.type()); |
| 272 | EXPECT_EQ(47, blank.GetInt()); |
| 273 | } |
| 274 | |
| 275 | TEST(ValuesTest, MoveDouble) { |
jdoerrie | bfe825e | 2017-03-02 21:09:19 +0900 | [diff] [blame] | 276 | Value value(74.896); |
| 277 | Value moved_value(std::move(value)); |
jdoerrie | 93a0cf3 | 2017-02-01 19:36:56 +0900 | [diff] [blame] | 278 | EXPECT_EQ(Value::Type::DOUBLE, moved_value.type()); |
| 279 | EXPECT_EQ(74.896, moved_value.GetDouble()); |
| 280 | |
| 281 | Value blank; |
| 282 | |
jdoerrie | bfe825e | 2017-03-02 21:09:19 +0900 | [diff] [blame] | 283 | blank = Value(654.38); |
jdoerrie | 93a0cf3 | 2017-02-01 19:36:56 +0900 | [diff] [blame] | 284 | EXPECT_EQ(Value::Type::DOUBLE, blank.type()); |
| 285 | EXPECT_EQ(654.38, blank.GetDouble()); |
| 286 | } |
| 287 | |
jdoerrie | 3129913 | 2017-02-01 23:38:32 +0900 | [diff] [blame] | 288 | TEST(ValuesTest, MoveString) { |
jdoerrie | 0d1295b | 2017-03-06 20:12:04 +0900 | [diff] [blame] | 289 | Value value("foobar"); |
| 290 | Value moved_value(std::move(value)); |
jdoerrie | 3129913 | 2017-02-01 23:38:32 +0900 | [diff] [blame] | 291 | EXPECT_EQ(Value::Type::STRING, moved_value.type()); |
| 292 | EXPECT_EQ("foobar", moved_value.GetString()); |
| 293 | |
| 294 | Value blank; |
| 295 | |
jdoerrie | 0d1295b | 2017-03-06 20:12:04 +0900 | [diff] [blame] | 296 | blank = Value("foobar"); |
jdoerrie | 3129913 | 2017-02-01 23:38:32 +0900 | [diff] [blame] | 297 | EXPECT_EQ(Value::Type::STRING, blank.type()); |
| 298 | EXPECT_EQ("foobar", blank.GetString()); |
| 299 | } |
| 300 | |
jdoerrie | 58325a4 | 2017-02-15 17:42:14 +0900 | [diff] [blame] | 301 | TEST(ValuesTest, MoveBinary) { |
| 302 | const std::vector<char> buffer = {0xF, 0x0, 0x0, 0xB, 0xA, 0x2}; |
jdoerrie | c56cc7f | 2017-04-11 16:45:50 +0900 | [diff] [blame] | 303 | Value value(buffer); |
| 304 | Value moved_value(std::move(value)); |
jdoerrie | 58325a4 | 2017-02-15 17:42:14 +0900 | [diff] [blame] | 305 | EXPECT_EQ(Value::Type::BINARY, moved_value.type()); |
| 306 | EXPECT_EQ(buffer, moved_value.GetBlob()); |
| 307 | |
| 308 | Value blank; |
| 309 | |
jdoerrie | c56cc7f | 2017-04-11 16:45:50 +0900 | [diff] [blame] | 310 | blank = Value(buffer); |
jdoerrie | 58325a4 | 2017-02-15 17:42:14 +0900 | [diff] [blame] | 311 | EXPECT_EQ(Value::Type::BINARY, blank.type()); |
| 312 | EXPECT_EQ(buffer, blank.GetBlob()); |
| 313 | } |
| 314 | |
jdoerrie | 1d5b348 | 2017-02-17 22:54:49 +0900 | [diff] [blame] | 315 | TEST(ValuesTest, MoveDictionary) { |
| 316 | // TODO(crbug.com/646113): Clean this up once DictionaryValue switched to |
| 317 | // value semantics. |
| 318 | int move; |
| 319 | DictionaryValue value; |
| 320 | value.SetInteger("Int", 123); |
| 321 | |
| 322 | DictionaryValue moved_value(std::move(value)); |
| 323 | moved_value.GetInteger("Int", &move); |
| 324 | |
| 325 | EXPECT_EQ(Value::Type::DICTIONARY, moved_value.type()); |
| 326 | EXPECT_EQ(123, move); |
| 327 | |
| 328 | Value blank; |
| 329 | |
| 330 | blank = DictionaryValue(); |
| 331 | EXPECT_EQ(Value::Type::DICTIONARY, blank.type()); |
| 332 | } |
| 333 | |
| 334 | TEST(ValuesTest, MoveList) { |
| 335 | // TODO(crbug.com/646113): Clean this up once ListValue switched to |
| 336 | // value semantics. |
| 337 | int move; |
| 338 | ListValue value; |
| 339 | value.AppendInteger(123); |
| 340 | |
| 341 | ListValue moved_value(std::move(value)); |
| 342 | moved_value.GetInteger(0, &move); |
| 343 | |
| 344 | EXPECT_EQ(Value::Type::LIST, moved_value.type()); |
| 345 | EXPECT_EQ(123, move); |
| 346 | |
| 347 | Value blank; |
| 348 | |
| 349 | blank = ListValue(); |
| 350 | EXPECT_EQ(Value::Type::LIST, blank.type()); |
| 351 | } |
| 352 | |
tfarina@chromium.org | 4cdd38e | 2011-06-29 07:56:33 +0900 | [diff] [blame] | 353 | TEST(ValuesTest, Basic) { |
initial.commit | 3f4a732 | 2008-07-27 06:49:38 +0900 | [diff] [blame] | 354 | // Test basic dictionary getting/setting |
| 355 | DictionaryValue settings; |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 356 | std::string homepage = "http://google.com"; |
| 357 | ASSERT_FALSE(settings.GetString("global.homepage", &homepage)); |
| 358 | ASSERT_EQ(std::string("http://google.com"), homepage); |
| 359 | |
| 360 | ASSERT_FALSE(settings.Get("global", NULL)); |
estade | 77a018f | 2015-05-07 10:53:08 +0900 | [diff] [blame] | 361 | settings.SetBoolean("global", true); |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 362 | ASSERT_TRUE(settings.Get("global", NULL)); |
| 363 | settings.SetString("global.homepage", "http://scurvy.com"); |
| 364 | ASSERT_TRUE(settings.Get("global", NULL)); |
| 365 | homepage = "http://google.com"; |
| 366 | ASSERT_TRUE(settings.GetString("global.homepage", &homepage)); |
| 367 | ASSERT_EQ(std::string("http://scurvy.com"), homepage); |
| 368 | |
| 369 | // Test storing a dictionary in a list. |
| 370 | ListValue* toolbar_bookmarks; |
| 371 | ASSERT_FALSE( |
| 372 | settings.GetList("global.toolbar.bookmarks", &toolbar_bookmarks)); |
| 373 | |
dcheng | cc8e4d8 | 2016-04-05 06:25:51 +0900 | [diff] [blame] | 374 | std::unique_ptr<ListValue> new_toolbar_bookmarks(new ListValue); |
danakj | 800d2ea | 2015-11-25 14:29:58 +0900 | [diff] [blame] | 375 | settings.Set("global.toolbar.bookmarks", std::move(new_toolbar_bookmarks)); |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 376 | ASSERT_TRUE(settings.GetList("global.toolbar.bookmarks", &toolbar_bookmarks)); |
| 377 | |
dcheng | cc8e4d8 | 2016-04-05 06:25:51 +0900 | [diff] [blame] | 378 | std::unique_ptr<DictionaryValue> new_bookmark(new DictionaryValue); |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 379 | new_bookmark->SetString("name", "Froogle"); |
| 380 | new_bookmark->SetString("url", "http://froogle.com"); |
danakj | 800d2ea | 2015-11-25 14:29:58 +0900 | [diff] [blame] | 381 | toolbar_bookmarks->Append(std::move(new_bookmark)); |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 382 | |
| 383 | ListValue* bookmark_list; |
| 384 | ASSERT_TRUE(settings.GetList("global.toolbar.bookmarks", &bookmark_list)); |
| 385 | DictionaryValue* bookmark; |
| 386 | ASSERT_EQ(1U, bookmark_list->GetSize()); |
| 387 | ASSERT_TRUE(bookmark_list->GetDictionary(0, &bookmark)); |
| 388 | std::string bookmark_name = "Unnamed"; |
| 389 | ASSERT_TRUE(bookmark->GetString("name", &bookmark_name)); |
| 390 | ASSERT_EQ(std::string("Froogle"), bookmark_name); |
| 391 | std::string bookmark_url; |
| 392 | ASSERT_TRUE(bookmark->GetString("url", &bookmark_url)); |
| 393 | ASSERT_EQ(std::string("http://froogle.com"), bookmark_url); |
| 394 | } |
| 395 | |
tfarina@chromium.org | 4cdd38e | 2011-06-29 07:56:33 +0900 | [diff] [blame] | 396 | TEST(ValuesTest, List) { |
dcheng | cc8e4d8 | 2016-04-05 06:25:51 +0900 | [diff] [blame] | 397 | std::unique_ptr<ListValue> mixed_list(new ListValue()); |
jdoerrie | bfe825e | 2017-03-02 21:09:19 +0900 | [diff] [blame] | 398 | mixed_list->Set(0, MakeUnique<Value>(true)); |
| 399 | mixed_list->Set(1, MakeUnique<Value>(42)); |
| 400 | mixed_list->Set(2, MakeUnique<Value>(88.8)); |
jdoerrie | 0d1295b | 2017-03-06 20:12:04 +0900 | [diff] [blame] | 401 | mixed_list->Set(3, MakeUnique<Value>("foo")); |
aa@chromium.org | c93b02f | 2009-01-21 06:05:32 +0900 | [diff] [blame] | 402 | ASSERT_EQ(4u, mixed_list->GetSize()); |
maruel@chromium.org | 8fe7adc | 2009-03-04 00:01:12 +0900 | [diff] [blame] | 403 | |
aa@chromium.org | c93b02f | 2009-01-21 06:05:32 +0900 | [diff] [blame] | 404 | Value *value = NULL; |
| 405 | bool bool_value = false; |
| 406 | int int_value = 0; |
| 407 | double double_value = 0.0; |
| 408 | std::string string_value; |
| 409 | |
| 410 | ASSERT_FALSE(mixed_list->Get(4, &value)); |
| 411 | |
| 412 | ASSERT_FALSE(mixed_list->GetInteger(0, &int_value)); |
| 413 | ASSERT_EQ(0, int_value); |
yusukes@google.com | 0b18b53 | 2011-05-02 10:59:21 +0900 | [diff] [blame] | 414 | ASSERT_FALSE(mixed_list->GetBoolean(1, &bool_value)); |
| 415 | ASSERT_FALSE(bool_value); |
aa@chromium.org | c93b02f | 2009-01-21 06:05:32 +0900 | [diff] [blame] | 416 | ASSERT_FALSE(mixed_list->GetString(2, &string_value)); |
| 417 | ASSERT_EQ("", string_value); |
yusukes@google.com | 0b18b53 | 2011-05-02 10:59:21 +0900 | [diff] [blame] | 418 | ASSERT_FALSE(mixed_list->GetInteger(2, &int_value)); |
| 419 | ASSERT_EQ(0, int_value); |
aa@chromium.org | c93b02f | 2009-01-21 06:05:32 +0900 | [diff] [blame] | 420 | ASSERT_FALSE(mixed_list->GetBoolean(3, &bool_value)); |
thakis@chromium.org | c753303 | 2010-10-04 06:44:39 +0900 | [diff] [blame] | 421 | ASSERT_FALSE(bool_value); |
aa@chromium.org | c93b02f | 2009-01-21 06:05:32 +0900 | [diff] [blame] | 422 | |
| 423 | ASSERT_TRUE(mixed_list->GetBoolean(0, &bool_value)); |
thakis@chromium.org | c753303 | 2010-10-04 06:44:39 +0900 | [diff] [blame] | 424 | ASSERT_TRUE(bool_value); |
aa@chromium.org | c93b02f | 2009-01-21 06:05:32 +0900 | [diff] [blame] | 425 | ASSERT_TRUE(mixed_list->GetInteger(1, &int_value)); |
| 426 | ASSERT_EQ(42, int_value); |
yusukes@google.com | 0b18b53 | 2011-05-02 10:59:21 +0900 | [diff] [blame] | 427 | // implicit conversion from Integer to Double should be possible. |
| 428 | ASSERT_TRUE(mixed_list->GetDouble(1, &double_value)); |
| 429 | ASSERT_EQ(42, double_value); |
arv@chromium.org | 13413eb | 2011-02-01 10:02:07 +0900 | [diff] [blame] | 430 | ASSERT_TRUE(mixed_list->GetDouble(2, &double_value)); |
aa@chromium.org | c93b02f | 2009-01-21 06:05:32 +0900 | [diff] [blame] | 431 | ASSERT_EQ(88.8, double_value); |
| 432 | ASSERT_TRUE(mixed_list->GetString(3, &string_value)); |
| 433 | ASSERT_EQ("foo", string_value); |
pastarmovj@chromium.org | 1602a47 | 2011-09-20 00:23:10 +0900 | [diff] [blame] | 434 | |
| 435 | // Try searching in the mixed list. |
jdoerrie | bfe825e | 2017-03-02 21:09:19 +0900 | [diff] [blame] | 436 | base::Value sought_value(42); |
| 437 | base::Value not_found_value(false); |
pastarmovj@chromium.org | 1602a47 | 2011-09-20 00:23:10 +0900 | [diff] [blame] | 438 | |
tfarina@chromium.org | 50be576 | 2012-12-16 14:13:21 +0900 | [diff] [blame] | 439 | ASSERT_NE(mixed_list->end(), mixed_list->Find(sought_value)); |
jdoerrie | 0143ef0 | 2017-04-11 23:20:20 +0900 | [diff] [blame^] | 440 | ASSERT_TRUE((*mixed_list->Find(sought_value)).GetAsInteger(&int_value)); |
pastarmovj@chromium.org | 1602a47 | 2011-09-20 00:23:10 +0900 | [diff] [blame] | 441 | ASSERT_EQ(42, int_value); |
tfarina@chromium.org | 50be576 | 2012-12-16 14:13:21 +0900 | [diff] [blame] | 442 | ASSERT_EQ(mixed_list->end(), mixed_list->Find(not_found_value)); |
aa@chromium.org | c93b02f | 2009-01-21 06:05:32 +0900 | [diff] [blame] | 443 | } |
| 444 | |
tfarina@chromium.org | 4cdd38e | 2011-06-29 07:56:33 +0900 | [diff] [blame] | 445 | TEST(ValuesTest, BinaryValue) { |
jdoerrie | 58325a4 | 2017-02-15 17:42:14 +0900 | [diff] [blame] | 446 | // Default constructor creates a BinaryValue with a buffer of size 0. |
| 447 | auto binary = MakeUnique<Value>(Value::Type::BINARY); |
patrick@chromium.org | c658546 | 2009-03-25 08:37:14 +0900 | [diff] [blame] | 448 | ASSERT_TRUE(binary.get()); |
mmentovai@google.com | 691ecef | 2008-08-22 01:24:51 +0900 | [diff] [blame] | 449 | ASSERT_EQ(0U, binary->GetSize()); |
initial.commit | 3f4a732 | 2008-07-27 06:49:38 +0900 | [diff] [blame] | 450 | |
| 451 | // Test the common case of a non-empty buffer |
jdoerrie | 58325a4 | 2017-02-15 17:42:14 +0900 | [diff] [blame] | 452 | std::vector<char> buffer(15); |
| 453 | char* original_buffer = buffer.data(); |
jdoerrie | c56cc7f | 2017-04-11 16:45:50 +0900 | [diff] [blame] | 454 | binary.reset(new Value(std::move(buffer))); |
patrick@chromium.org | c658546 | 2009-03-25 08:37:14 +0900 | [diff] [blame] | 455 | ASSERT_TRUE(binary.get()); |
initial.commit | 3f4a732 | 2008-07-27 06:49:38 +0900 | [diff] [blame] | 456 | ASSERT_TRUE(binary->GetBuffer()); |
danakj | 4d4eaf0 | 2015-05-12 06:24:09 +0900 | [diff] [blame] | 457 | ASSERT_EQ(original_buffer, binary->GetBuffer()); |
mmentovai@google.com | 691ecef | 2008-08-22 01:24:51 +0900 | [diff] [blame] | 458 | ASSERT_EQ(15U, binary->GetSize()); |
initial.commit | 3f4a732 | 2008-07-27 06:49:38 +0900 | [diff] [blame] | 459 | |
| 460 | char stack_buffer[42]; |
| 461 | memset(stack_buffer, '!', 42); |
jdoerrie | c56cc7f | 2017-04-11 16:45:50 +0900 | [diff] [blame] | 462 | binary = Value::CreateWithCopiedBuffer(stack_buffer, 42); |
patrick@chromium.org | c658546 | 2009-03-25 08:37:14 +0900 | [diff] [blame] | 463 | ASSERT_TRUE(binary.get()); |
initial.commit | 3f4a732 | 2008-07-27 06:49:38 +0900 | [diff] [blame] | 464 | ASSERT_TRUE(binary->GetBuffer()); |
| 465 | ASSERT_NE(stack_buffer, binary->GetBuffer()); |
mmentovai@google.com | 691ecef | 2008-08-22 01:24:51 +0900 | [diff] [blame] | 466 | ASSERT_EQ(42U, binary->GetSize()); |
initial.commit | 3f4a732 | 2008-07-27 06:49:38 +0900 | [diff] [blame] | 467 | ASSERT_EQ(0, memcmp(stack_buffer, binary->GetBuffer(), binary->GetSize())); |
pneubeck | b57f3f5 | 2015-01-20 20:26:36 +0900 | [diff] [blame] | 468 | |
| 469 | // Test overloaded GetAsBinary. |
| 470 | Value* narrow_value = binary.get(); |
jdoerrie | c56cc7f | 2017-04-11 16:45:50 +0900 | [diff] [blame] | 471 | const Value* narrow_binary = NULL; |
pneubeck | b57f3f5 | 2015-01-20 20:26:36 +0900 | [diff] [blame] | 472 | ASSERT_TRUE(narrow_value->GetAsBinary(&narrow_binary)); |
| 473 | EXPECT_EQ(binary.get(), narrow_binary); |
initial.commit | 3f4a732 | 2008-07-27 06:49:38 +0900 | [diff] [blame] | 474 | } |
| 475 | |
tfarina@chromium.org | 4cdd38e | 2011-06-29 07:56:33 +0900 | [diff] [blame] | 476 | TEST(ValuesTest, StringValue) { |
estade@chromium.org | fe74951 | 2014-01-30 19:32:41 +0900 | [diff] [blame] | 477 | // Test overloaded StringValue constructor. |
jdoerrie | 0d1295b | 2017-03-06 20:12:04 +0900 | [diff] [blame] | 478 | std::unique_ptr<Value> narrow_value(new Value("narrow")); |
patrick@chromium.org | c658546 | 2009-03-25 08:37:14 +0900 | [diff] [blame] | 479 | ASSERT_TRUE(narrow_value.get()); |
jdoerrie | 89ee31a | 2016-12-08 00:43:28 +0900 | [diff] [blame] | 480 | ASSERT_TRUE(narrow_value->IsType(Value::Type::STRING)); |
jdoerrie | 0d1295b | 2017-03-06 20:12:04 +0900 | [diff] [blame] | 481 | std::unique_ptr<Value> utf16_value(new Value(ASCIIToUTF16("utf16"))); |
viettrungluu@chromium.org | 31b80ba | 2010-08-04 00:42:58 +0900 | [diff] [blame] | 482 | ASSERT_TRUE(utf16_value.get()); |
jdoerrie | 89ee31a | 2016-12-08 00:43:28 +0900 | [diff] [blame] | 483 | ASSERT_TRUE(utf16_value->IsType(Value::Type::STRING)); |
viettrungluu@chromium.org | 31b80ba | 2010-08-04 00:42:58 +0900 | [diff] [blame] | 484 | |
estade@chromium.org | 6ebcd52 | 2014-02-12 07:57:34 +0900 | [diff] [blame] | 485 | // Test overloaded GetAsString. |
viettrungluu@chromium.org | 31b80ba | 2010-08-04 00:42:58 +0900 | [diff] [blame] | 486 | std::string narrow = "http://google.com"; |
| 487 | string16 utf16 = ASCIIToUTF16("http://google.com"); |
jdoerrie | 0d1295b | 2017-03-06 20:12:04 +0900 | [diff] [blame] | 488 | const Value* string_value = NULL; |
viettrungluu@chromium.org | 31b80ba | 2010-08-04 00:42:58 +0900 | [diff] [blame] | 489 | ASSERT_TRUE(narrow_value->GetAsString(&narrow)); |
| 490 | ASSERT_TRUE(narrow_value->GetAsString(&utf16)); |
estade@chromium.org | 6ebcd52 | 2014-02-12 07:57:34 +0900 | [diff] [blame] | 491 | ASSERT_TRUE(narrow_value->GetAsString(&string_value)); |
viettrungluu@chromium.org | 31b80ba | 2010-08-04 00:42:58 +0900 | [diff] [blame] | 492 | ASSERT_EQ(std::string("narrow"), narrow); |
| 493 | ASSERT_EQ(ASCIIToUTF16("narrow"), utf16); |
estade@chromium.org | 6ebcd52 | 2014-02-12 07:57:34 +0900 | [diff] [blame] | 494 | ASSERT_EQ(string_value->GetString(), narrow); |
viettrungluu@chromium.org | 31b80ba | 2010-08-04 00:42:58 +0900 | [diff] [blame] | 495 | |
| 496 | ASSERT_TRUE(utf16_value->GetAsString(&narrow)); |
| 497 | ASSERT_TRUE(utf16_value->GetAsString(&utf16)); |
estade@chromium.org | 6ebcd52 | 2014-02-12 07:57:34 +0900 | [diff] [blame] | 498 | ASSERT_TRUE(utf16_value->GetAsString(&string_value)); |
viettrungluu@chromium.org | 31b80ba | 2010-08-04 00:42:58 +0900 | [diff] [blame] | 499 | ASSERT_EQ(std::string("utf16"), narrow); |
| 500 | ASSERT_EQ(ASCIIToUTF16("utf16"), utf16); |
estade@chromium.org | 6ebcd52 | 2014-02-12 07:57:34 +0900 | [diff] [blame] | 501 | ASSERT_EQ(string_value->GetString(), narrow); |
| 502 | |
| 503 | // Don't choke on NULL values. |
| 504 | ASSERT_TRUE(narrow_value->GetAsString(static_cast<string16*>(NULL))); |
| 505 | ASSERT_TRUE(narrow_value->GetAsString(static_cast<std::string*>(NULL))); |
jdoerrie | 0d1295b | 2017-03-06 20:12:04 +0900 | [diff] [blame] | 506 | ASSERT_TRUE(narrow_value->GetAsString(static_cast<const Value**>(NULL))); |
viettrungluu@chromium.org | 31b80ba | 2010-08-04 00:42:58 +0900 | [diff] [blame] | 507 | } |
| 508 | |
tfarina@chromium.org | 4cdd38e | 2011-06-29 07:56:33 +0900 | [diff] [blame] | 509 | TEST(ValuesTest, ListDeletion) { |
jdoerrie | 1d5b348 | 2017-02-17 22:54:49 +0900 | [diff] [blame] | 510 | ListValue list; |
| 511 | list.Append(MakeUnique<Value>()); |
| 512 | EXPECT_FALSE(list.empty()); |
| 513 | list.Clear(); |
| 514 | EXPECT_TRUE(list.empty()); |
initial.commit | 3f4a732 | 2008-07-27 06:49:38 +0900 | [diff] [blame] | 515 | } |
| 516 | |
tfarina@chromium.org | 4cdd38e | 2011-06-29 07:56:33 +0900 | [diff] [blame] | 517 | TEST(ValuesTest, ListRemoval) { |
dcheng | cc8e4d8 | 2016-04-05 06:25:51 +0900 | [diff] [blame] | 518 | std::unique_ptr<Value> removed_item; |
initial.commit | 3f4a732 | 2008-07-27 06:49:38 +0900 | [diff] [blame] | 519 | |
| 520 | { |
| 521 | ListValue list; |
jdoerrie | 1d5b348 | 2017-02-17 22:54:49 +0900 | [diff] [blame] | 522 | list.Append(MakeUnique<Value>()); |
mmentovai@google.com | 691ecef | 2008-08-22 01:24:51 +0900 | [diff] [blame] | 523 | EXPECT_EQ(1U, list.GetSize()); |
deanm@google.com | 19650de | 2008-08-13 23:57:51 +0900 | [diff] [blame] | 524 | EXPECT_FALSE(list.Remove(std::numeric_limits<size_t>::max(), |
| 525 | &removed_item)); |
initial.commit | 3f4a732 | 2008-07-27 06:49:38 +0900 | [diff] [blame] | 526 | EXPECT_FALSE(list.Remove(1, &removed_item)); |
| 527 | EXPECT_TRUE(list.Remove(0, &removed_item)); |
| 528 | ASSERT_TRUE(removed_item); |
mmentovai@google.com | 691ecef | 2008-08-22 01:24:51 +0900 | [diff] [blame] | 529 | EXPECT_EQ(0U, list.GetSize()); |
initial.commit | 3f4a732 | 2008-07-27 06:49:38 +0900 | [diff] [blame] | 530 | } |
bauerb@chromium.org | ae43e0a | 2013-08-06 22:33:04 +0900 | [diff] [blame] | 531 | removed_item.reset(); |
initial.commit | 3f4a732 | 2008-07-27 06:49:38 +0900 | [diff] [blame] | 532 | |
| 533 | { |
| 534 | ListValue list; |
jdoerrie | 1d5b348 | 2017-02-17 22:54:49 +0900 | [diff] [blame] | 535 | list.Append(MakeUnique<Value>()); |
initial.commit | 3f4a732 | 2008-07-27 06:49:38 +0900 | [diff] [blame] | 536 | EXPECT_TRUE(list.Remove(0, NULL)); |
mmentovai@google.com | 691ecef | 2008-08-22 01:24:51 +0900 | [diff] [blame] | 537 | EXPECT_EQ(0U, list.GetSize()); |
initial.commit | 3f4a732 | 2008-07-27 06:49:38 +0900 | [diff] [blame] | 538 | } |
pkasting@chromium.org | dfe6a69 | 2009-12-01 04:59:11 +0900 | [diff] [blame] | 539 | |
| 540 | { |
| 541 | ListValue list; |
jdoerrie | 1d5b348 | 2017-02-17 22:54:49 +0900 | [diff] [blame] | 542 | auto value = MakeUnique<Value>(); |
jdoerrie | 0143ef0 | 2017-04-11 23:20:20 +0900 | [diff] [blame^] | 543 | Value original_value = *value; |
danakj | 800d2ea | 2015-11-25 14:29:58 +0900 | [diff] [blame] | 544 | list.Append(std::move(value)); |
tfarina@chromium.org | 09cf434 | 2011-08-14 02:34:31 +0900 | [diff] [blame] | 545 | size_t index = 0; |
jdoerrie | 0143ef0 | 2017-04-11 23:20:20 +0900 | [diff] [blame^] | 546 | list.Remove(original_value, &index); |
tfarina@chromium.org | 09cf434 | 2011-08-14 02:34:31 +0900 | [diff] [blame] | 547 | EXPECT_EQ(0U, index); |
pkasting@chromium.org | dfe6a69 | 2009-12-01 04:59:11 +0900 | [diff] [blame] | 548 | EXPECT_EQ(0U, list.GetSize()); |
| 549 | } |
initial.commit | 3f4a732 | 2008-07-27 06:49:38 +0900 | [diff] [blame] | 550 | } |
| 551 | |
tfarina@chromium.org | 4cdd38e | 2011-06-29 07:56:33 +0900 | [diff] [blame] | 552 | TEST(ValuesTest, DictionaryDeletion) { |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 553 | std::string key = "test"; |
jdoerrie | 1d5b348 | 2017-02-17 22:54:49 +0900 | [diff] [blame] | 554 | DictionaryValue dict; |
| 555 | dict.Set(key, MakeUnique<Value>()); |
| 556 | EXPECT_FALSE(dict.empty()); |
| 557 | dict.Clear(); |
| 558 | EXPECT_TRUE(dict.empty()); |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 559 | } |
| 560 | |
tfarina@chromium.org | 4cdd38e | 2011-06-29 07:56:33 +0900 | [diff] [blame] | 561 | TEST(ValuesTest, DictionaryRemoval) { |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 562 | std::string key = "test"; |
dcheng | cc8e4d8 | 2016-04-05 06:25:51 +0900 | [diff] [blame] | 563 | std::unique_ptr<Value> removed_item; |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 564 | |
| 565 | { |
| 566 | DictionaryValue dict; |
jdoerrie | 1d5b348 | 2017-02-17 22:54:49 +0900 | [diff] [blame] | 567 | dict.Set(key, MakeUnique<Value>()); |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 568 | EXPECT_TRUE(dict.HasKey(key)); |
| 569 | EXPECT_FALSE(dict.Remove("absent key", &removed_item)); |
| 570 | EXPECT_TRUE(dict.Remove(key, &removed_item)); |
| 571 | EXPECT_FALSE(dict.HasKey(key)); |
| 572 | ASSERT_TRUE(removed_item); |
| 573 | } |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 574 | |
| 575 | { |
| 576 | DictionaryValue dict; |
jdoerrie | 1d5b348 | 2017-02-17 22:54:49 +0900 | [diff] [blame] | 577 | dict.Set(key, MakeUnique<Value>()); |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 578 | EXPECT_TRUE(dict.HasKey(key)); |
| 579 | EXPECT_TRUE(dict.Remove(key, NULL)); |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 580 | EXPECT_FALSE(dict.HasKey(key)); |
| 581 | } |
| 582 | } |
| 583 | |
tfarina@chromium.org | 4cdd38e | 2011-06-29 07:56:33 +0900 | [diff] [blame] | 584 | TEST(ValuesTest, DictionaryWithoutPathExpansion) { |
pkasting@chromium.org | 36515db | 2009-11-26 05:47:52 +0900 | [diff] [blame] | 585 | DictionaryValue dict; |
jdoerrie | fcdbae7 | 2017-04-07 15:39:00 +0900 | [diff] [blame] | 586 | dict.Set("this.is.expanded", MakeUnique<Value>()); |
| 587 | dict.SetWithoutPathExpansion("this.isnt.expanded", MakeUnique<Value>()); |
estade | 948395d | 2015-01-07 05:06:50 +0900 | [diff] [blame] | 588 | |
| 589 | EXPECT_FALSE(dict.HasKey("this.is.expanded")); |
| 590 | EXPECT_TRUE(dict.HasKey("this")); |
| 591 | Value* value1; |
| 592 | EXPECT_TRUE(dict.Get("this", &value1)); |
| 593 | DictionaryValue* value2; |
| 594 | ASSERT_TRUE(dict.GetDictionaryWithoutPathExpansion("this", &value2)); |
| 595 | EXPECT_EQ(value1, value2); |
| 596 | EXPECT_EQ(1U, value2->size()); |
| 597 | |
| 598 | EXPECT_TRUE(dict.HasKey("this.isnt.expanded")); |
| 599 | Value* value3; |
| 600 | EXPECT_FALSE(dict.Get("this.isnt.expanded", &value3)); |
| 601 | Value* value4; |
| 602 | ASSERT_TRUE(dict.GetWithoutPathExpansion("this.isnt.expanded", &value4)); |
jdoerrie | 89ee31a | 2016-12-08 00:43:28 +0900 | [diff] [blame] | 603 | EXPECT_EQ(Value::Type::NONE, value4->GetType()); |
estade | 948395d | 2015-01-07 05:06:50 +0900 | [diff] [blame] | 604 | } |
| 605 | |
| 606 | // Tests the deprecated version of SetWithoutPathExpansion. |
| 607 | // TODO(estade): remove. |
| 608 | TEST(ValuesTest, DictionaryWithoutPathExpansionDeprecated) { |
| 609 | DictionaryValue dict; |
jdoerrie | fcdbae7 | 2017-04-07 15:39:00 +0900 | [diff] [blame] | 610 | dict.Set("this.is.expanded", MakeUnique<Value>()); |
| 611 | dict.SetWithoutPathExpansion("this.isnt.expanded", MakeUnique<Value>()); |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 612 | |
| 613 | EXPECT_FALSE(dict.HasKey("this.is.expanded")); |
| 614 | EXPECT_TRUE(dict.HasKey("this")); |
| 615 | Value* value1; |
| 616 | EXPECT_TRUE(dict.Get("this", &value1)); |
| 617 | DictionaryValue* value2; |
| 618 | ASSERT_TRUE(dict.GetDictionaryWithoutPathExpansion("this", &value2)); |
| 619 | EXPECT_EQ(value1, value2); |
| 620 | EXPECT_EQ(1U, value2->size()); |
| 621 | |
| 622 | EXPECT_TRUE(dict.HasKey("this.isnt.expanded")); |
| 623 | Value* value3; |
| 624 | EXPECT_FALSE(dict.Get("this.isnt.expanded", &value3)); |
| 625 | Value* value4; |
| 626 | ASSERT_TRUE(dict.GetWithoutPathExpansion("this.isnt.expanded", &value4)); |
jdoerrie | 89ee31a | 2016-12-08 00:43:28 +0900 | [diff] [blame] | 627 | EXPECT_EQ(Value::Type::NONE, value4->GetType()); |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 628 | } |
| 629 | |
gab@chromium.org | 903d5c9 | 2013-11-27 10:38:24 +0900 | [diff] [blame] | 630 | TEST(ValuesTest, DictionaryRemovePath) { |
| 631 | DictionaryValue dict; |
estade | 948395d | 2015-01-07 05:06:50 +0900 | [diff] [blame] | 632 | dict.SetInteger("a.long.way.down", 1); |
| 633 | dict.SetBoolean("a.long.key.path", true); |
gab@chromium.org | 903d5c9 | 2013-11-27 10:38:24 +0900 | [diff] [blame] | 634 | |
dcheng | cc8e4d8 | 2016-04-05 06:25:51 +0900 | [diff] [blame] | 635 | std::unique_ptr<Value> removed_item; |
gab@chromium.org | 903d5c9 | 2013-11-27 10:38:24 +0900 | [diff] [blame] | 636 | EXPECT_TRUE(dict.RemovePath("a.long.way.down", &removed_item)); |
| 637 | ASSERT_TRUE(removed_item); |
jdoerrie | 89ee31a | 2016-12-08 00:43:28 +0900 | [diff] [blame] | 638 | EXPECT_TRUE(removed_item->IsType(base::Value::Type::INTEGER)); |
gab@chromium.org | 903d5c9 | 2013-11-27 10:38:24 +0900 | [diff] [blame] | 639 | EXPECT_FALSE(dict.HasKey("a.long.way.down")); |
| 640 | EXPECT_FALSE(dict.HasKey("a.long.way")); |
| 641 | EXPECT_TRUE(dict.Get("a.long.key.path", NULL)); |
| 642 | |
| 643 | removed_item.reset(); |
| 644 | EXPECT_FALSE(dict.RemovePath("a.long.way.down", &removed_item)); |
| 645 | EXPECT_FALSE(removed_item); |
| 646 | EXPECT_TRUE(dict.Get("a.long.key.path", NULL)); |
| 647 | |
| 648 | removed_item.reset(); |
| 649 | EXPECT_TRUE(dict.RemovePath("a.long.key.path", &removed_item)); |
| 650 | ASSERT_TRUE(removed_item); |
jdoerrie | 89ee31a | 2016-12-08 00:43:28 +0900 | [diff] [blame] | 651 | EXPECT_TRUE(removed_item->IsType(base::Value::Type::BOOLEAN)); |
gab@chromium.org | 903d5c9 | 2013-11-27 10:38:24 +0900 | [diff] [blame] | 652 | EXPECT_TRUE(dict.empty()); |
| 653 | } |
| 654 | |
tfarina@chromium.org | 4cdd38e | 2011-06-29 07:56:33 +0900 | [diff] [blame] | 655 | TEST(ValuesTest, DeepCopy) { |
initial.commit | 3f4a732 | 2008-07-27 06:49:38 +0900 | [diff] [blame] | 656 | DictionaryValue original_dict; |
jdoerrie | fcdbae7 | 2017-04-07 15:39:00 +0900 | [diff] [blame] | 657 | auto scoped_null = MakeUnique<Value>(); |
danakj | 4d4eaf0 | 2015-05-12 06:24:09 +0900 | [diff] [blame] | 658 | Value* original_null = scoped_null.get(); |
danakj | 800d2ea | 2015-11-25 14:29:58 +0900 | [diff] [blame] | 659 | original_dict.Set("null", std::move(scoped_null)); |
jdoerrie | bfe825e | 2017-03-02 21:09:19 +0900 | [diff] [blame] | 660 | std::unique_ptr<Value> scoped_bool(new Value(true)); |
| 661 | Value* original_bool = scoped_bool.get(); |
danakj | 800d2ea | 2015-11-25 14:29:58 +0900 | [diff] [blame] | 662 | original_dict.Set("bool", std::move(scoped_bool)); |
jdoerrie | bfe825e | 2017-03-02 21:09:19 +0900 | [diff] [blame] | 663 | std::unique_ptr<Value> scoped_int(new Value(42)); |
| 664 | Value* original_int = scoped_int.get(); |
danakj | 800d2ea | 2015-11-25 14:29:58 +0900 | [diff] [blame] | 665 | original_dict.Set("int", std::move(scoped_int)); |
jdoerrie | bfe825e | 2017-03-02 21:09:19 +0900 | [diff] [blame] | 666 | std::unique_ptr<Value> scoped_double(new Value(3.14)); |
| 667 | Value* original_double = scoped_double.get(); |
danakj | 800d2ea | 2015-11-25 14:29:58 +0900 | [diff] [blame] | 668 | original_dict.Set("double", std::move(scoped_double)); |
jdoerrie | 0d1295b | 2017-03-06 20:12:04 +0900 | [diff] [blame] | 669 | std::unique_ptr<Value> scoped_string(new Value("hello")); |
| 670 | Value* original_string = scoped_string.get(); |
danakj | 800d2ea | 2015-11-25 14:29:58 +0900 | [diff] [blame] | 671 | original_dict.Set("string", std::move(scoped_string)); |
jdoerrie | 0d1295b | 2017-03-06 20:12:04 +0900 | [diff] [blame] | 672 | std::unique_ptr<Value> scoped_string16(new Value(ASCIIToUTF16("hello16"))); |
| 673 | Value* original_string16 = scoped_string16.get(); |
danakj | 800d2ea | 2015-11-25 14:29:58 +0900 | [diff] [blame] | 674 | original_dict.Set("string16", std::move(scoped_string16)); |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 675 | |
jdoerrie | 58325a4 | 2017-02-15 17:42:14 +0900 | [diff] [blame] | 676 | std::vector<char> original_buffer(42, '!'); |
jdoerrie | c56cc7f | 2017-04-11 16:45:50 +0900 | [diff] [blame] | 677 | std::unique_ptr<Value> scoped_binary(new Value(std::move(original_buffer))); |
| 678 | Value* original_binary = scoped_binary.get(); |
danakj | 800d2ea | 2015-11-25 14:29:58 +0900 | [diff] [blame] | 679 | original_dict.Set("binary", std::move(scoped_binary)); |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 680 | |
dcheng | cc8e4d8 | 2016-04-05 06:25:51 +0900 | [diff] [blame] | 681 | std::unique_ptr<ListValue> scoped_list(new ListValue()); |
danakj | 4d4eaf0 | 2015-05-12 06:24:09 +0900 | [diff] [blame] | 682 | Value* original_list = scoped_list.get(); |
jdoerrie | bfe825e | 2017-03-02 21:09:19 +0900 | [diff] [blame] | 683 | std::unique_ptr<Value> scoped_list_element_0(new Value(0)); |
danakj | 4d4eaf0 | 2015-05-12 06:24:09 +0900 | [diff] [blame] | 684 | Value* original_list_element_0 = scoped_list_element_0.get(); |
danakj | 800d2ea | 2015-11-25 14:29:58 +0900 | [diff] [blame] | 685 | scoped_list->Append(std::move(scoped_list_element_0)); |
jdoerrie | bfe825e | 2017-03-02 21:09:19 +0900 | [diff] [blame] | 686 | std::unique_ptr<Value> scoped_list_element_1(new Value(1)); |
danakj | 4d4eaf0 | 2015-05-12 06:24:09 +0900 | [diff] [blame] | 687 | Value* original_list_element_1 = scoped_list_element_1.get(); |
danakj | 800d2ea | 2015-11-25 14:29:58 +0900 | [diff] [blame] | 688 | scoped_list->Append(std::move(scoped_list_element_1)); |
| 689 | original_dict.Set("list", std::move(scoped_list)); |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 690 | |
dcheng | cc8e4d8 | 2016-04-05 06:25:51 +0900 | [diff] [blame] | 691 | std::unique_ptr<DictionaryValue> scoped_nested_dictionary( |
| 692 | new DictionaryValue()); |
danakj | 4d4eaf0 | 2015-05-12 06:24:09 +0900 | [diff] [blame] | 693 | Value* original_nested_dictionary = scoped_nested_dictionary.get(); |
| 694 | scoped_nested_dictionary->SetString("key", "value"); |
danakj | 800d2ea | 2015-11-25 14:29:58 +0900 | [diff] [blame] | 695 | original_dict.Set("dictionary", std::move(scoped_nested_dictionary)); |
battre@chromium.org | 29eaa25 | 2011-11-26 10:11:44 +0900 | [diff] [blame] | 696 | |
jdoerrie | 751d7d7 | 2017-04-05 15:44:17 +0900 | [diff] [blame] | 697 | auto copy_dict = MakeUnique<DictionaryValue>(original_dict); |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 698 | ASSERT_TRUE(copy_dict.get()); |
| 699 | ASSERT_NE(copy_dict.get(), &original_dict); |
| 700 | |
| 701 | Value* copy_null = NULL; |
| 702 | ASSERT_TRUE(copy_dict->Get("null", ©_null)); |
| 703 | ASSERT_TRUE(copy_null); |
| 704 | ASSERT_NE(copy_null, original_null); |
jdoerrie | 89ee31a | 2016-12-08 00:43:28 +0900 | [diff] [blame] | 705 | ASSERT_TRUE(copy_null->IsType(Value::Type::NONE)); |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 706 | |
| 707 | Value* copy_bool = NULL; |
| 708 | ASSERT_TRUE(copy_dict->Get("bool", ©_bool)); |
| 709 | ASSERT_TRUE(copy_bool); |
| 710 | ASSERT_NE(copy_bool, original_bool); |
jdoerrie | 89ee31a | 2016-12-08 00:43:28 +0900 | [diff] [blame] | 711 | ASSERT_TRUE(copy_bool->IsType(Value::Type::BOOLEAN)); |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 712 | bool copy_bool_value = false; |
| 713 | ASSERT_TRUE(copy_bool->GetAsBoolean(©_bool_value)); |
| 714 | ASSERT_TRUE(copy_bool_value); |
| 715 | |
| 716 | Value* copy_int = NULL; |
| 717 | ASSERT_TRUE(copy_dict->Get("int", ©_int)); |
| 718 | ASSERT_TRUE(copy_int); |
| 719 | ASSERT_NE(copy_int, original_int); |
jdoerrie | 89ee31a | 2016-12-08 00:43:28 +0900 | [diff] [blame] | 720 | ASSERT_TRUE(copy_int->IsType(Value::Type::INTEGER)); |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 721 | int copy_int_value = 0; |
| 722 | ASSERT_TRUE(copy_int->GetAsInteger(©_int_value)); |
| 723 | ASSERT_EQ(42, copy_int_value); |
| 724 | |
arv@chromium.org | 13413eb | 2011-02-01 10:02:07 +0900 | [diff] [blame] | 725 | Value* copy_double = NULL; |
| 726 | ASSERT_TRUE(copy_dict->Get("double", ©_double)); |
| 727 | ASSERT_TRUE(copy_double); |
| 728 | ASSERT_NE(copy_double, original_double); |
jdoerrie | 89ee31a | 2016-12-08 00:43:28 +0900 | [diff] [blame] | 729 | ASSERT_TRUE(copy_double->IsType(Value::Type::DOUBLE)); |
arv@chromium.org | 13413eb | 2011-02-01 10:02:07 +0900 | [diff] [blame] | 730 | double copy_double_value = 0; |
| 731 | ASSERT_TRUE(copy_double->GetAsDouble(©_double_value)); |
| 732 | ASSERT_EQ(3.14, copy_double_value); |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 733 | |
| 734 | Value* copy_string = NULL; |
| 735 | ASSERT_TRUE(copy_dict->Get("string", ©_string)); |
| 736 | ASSERT_TRUE(copy_string); |
| 737 | ASSERT_NE(copy_string, original_string); |
jdoerrie | 89ee31a | 2016-12-08 00:43:28 +0900 | [diff] [blame] | 738 | ASSERT_TRUE(copy_string->IsType(Value::Type::STRING)); |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 739 | std::string copy_string_value; |
viettrungluu@chromium.org | 31b80ba | 2010-08-04 00:42:58 +0900 | [diff] [blame] | 740 | string16 copy_string16_value; |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 741 | ASSERT_TRUE(copy_string->GetAsString(©_string_value)); |
viettrungluu@chromium.org | 31b80ba | 2010-08-04 00:42:58 +0900 | [diff] [blame] | 742 | ASSERT_TRUE(copy_string->GetAsString(©_string16_value)); |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 743 | ASSERT_EQ(std::string("hello"), copy_string_value); |
viettrungluu@chromium.org | 31b80ba | 2010-08-04 00:42:58 +0900 | [diff] [blame] | 744 | ASSERT_EQ(ASCIIToUTF16("hello"), copy_string16_value); |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 745 | |
viettrungluu@chromium.org | 31b80ba | 2010-08-04 00:42:58 +0900 | [diff] [blame] | 746 | Value* copy_string16 = NULL; |
| 747 | ASSERT_TRUE(copy_dict->Get("string16", ©_string16)); |
| 748 | ASSERT_TRUE(copy_string16); |
| 749 | ASSERT_NE(copy_string16, original_string16); |
jdoerrie | 89ee31a | 2016-12-08 00:43:28 +0900 | [diff] [blame] | 750 | ASSERT_TRUE(copy_string16->IsType(Value::Type::STRING)); |
viettrungluu@chromium.org | 31b80ba | 2010-08-04 00:42:58 +0900 | [diff] [blame] | 751 | ASSERT_TRUE(copy_string16->GetAsString(©_string_value)); |
| 752 | ASSERT_TRUE(copy_string16->GetAsString(©_string16_value)); |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 753 | ASSERT_EQ(std::string("hello16"), copy_string_value); |
viettrungluu@chromium.org | 31b80ba | 2010-08-04 00:42:58 +0900 | [diff] [blame] | 754 | ASSERT_EQ(ASCIIToUTF16("hello16"), copy_string16_value); |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 755 | |
| 756 | Value* copy_binary = NULL; |
| 757 | ASSERT_TRUE(copy_dict->Get("binary", ©_binary)); |
| 758 | ASSERT_TRUE(copy_binary); |
| 759 | ASSERT_NE(copy_binary, original_binary); |
jdoerrie | 89ee31a | 2016-12-08 00:43:28 +0900 | [diff] [blame] | 760 | ASSERT_TRUE(copy_binary->IsType(Value::Type::BINARY)); |
jdoerrie | 58325a4 | 2017-02-15 17:42:14 +0900 | [diff] [blame] | 761 | ASSERT_NE(original_binary->GetBuffer(), copy_binary->GetBuffer()); |
| 762 | ASSERT_EQ(original_binary->GetSize(), copy_binary->GetSize()); |
| 763 | ASSERT_EQ(0, memcmp(original_binary->GetBuffer(), copy_binary->GetBuffer(), |
| 764 | original_binary->GetSize())); |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 765 | |
| 766 | Value* copy_value = NULL; |
| 767 | ASSERT_TRUE(copy_dict->Get("list", ©_value)); |
| 768 | ASSERT_TRUE(copy_value); |
| 769 | ASSERT_NE(copy_value, original_list); |
jdoerrie | 89ee31a | 2016-12-08 00:43:28 +0900 | [diff] [blame] | 770 | ASSERT_TRUE(copy_value->IsType(Value::Type::LIST)); |
battre@chromium.org | 29eaa25 | 2011-11-26 10:11:44 +0900 | [diff] [blame] | 771 | ListValue* copy_list = NULL; |
| 772 | ASSERT_TRUE(copy_value->GetAsList(©_list)); |
| 773 | ASSERT_TRUE(copy_list); |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 774 | ASSERT_EQ(2U, copy_list->GetSize()); |
| 775 | |
| 776 | Value* copy_list_element_0; |
| 777 | ASSERT_TRUE(copy_list->Get(0, ©_list_element_0)); |
| 778 | ASSERT_TRUE(copy_list_element_0); |
| 779 | ASSERT_NE(copy_list_element_0, original_list_element_0); |
| 780 | int copy_list_element_0_value; |
| 781 | ASSERT_TRUE(copy_list_element_0->GetAsInteger(©_list_element_0_value)); |
| 782 | ASSERT_EQ(0, copy_list_element_0_value); |
| 783 | |
| 784 | Value* copy_list_element_1; |
| 785 | ASSERT_TRUE(copy_list->Get(1, ©_list_element_1)); |
| 786 | ASSERT_TRUE(copy_list_element_1); |
| 787 | ASSERT_NE(copy_list_element_1, original_list_element_1); |
| 788 | int copy_list_element_1_value; |
| 789 | ASSERT_TRUE(copy_list_element_1->GetAsInteger(©_list_element_1_value)); |
| 790 | ASSERT_EQ(1, copy_list_element_1_value); |
battre@chromium.org | 29eaa25 | 2011-11-26 10:11:44 +0900 | [diff] [blame] | 791 | |
| 792 | copy_value = NULL; |
| 793 | ASSERT_TRUE(copy_dict->Get("dictionary", ©_value)); |
| 794 | ASSERT_TRUE(copy_value); |
| 795 | ASSERT_NE(copy_value, original_nested_dictionary); |
jdoerrie | 89ee31a | 2016-12-08 00:43:28 +0900 | [diff] [blame] | 796 | ASSERT_TRUE(copy_value->IsType(Value::Type::DICTIONARY)); |
battre@chromium.org | 29eaa25 | 2011-11-26 10:11:44 +0900 | [diff] [blame] | 797 | DictionaryValue* copy_nested_dictionary = NULL; |
| 798 | ASSERT_TRUE(copy_value->GetAsDictionary(©_nested_dictionary)); |
| 799 | ASSERT_TRUE(copy_nested_dictionary); |
| 800 | EXPECT_TRUE(copy_nested_dictionary->HasKey("key")); |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 801 | } |
| 802 | |
tfarina@chromium.org | 4cdd38e | 2011-06-29 07:56:33 +0900 | [diff] [blame] | 803 | TEST(ValuesTest, Equals) { |
jdoerrie | fcdbae7 | 2017-04-07 15:39:00 +0900 | [diff] [blame] | 804 | auto null1 = MakeUnique<Value>(); |
| 805 | auto null2 = MakeUnique<Value>(); |
danakj | 4d4eaf0 | 2015-05-12 06:24:09 +0900 | [diff] [blame] | 806 | EXPECT_NE(null1.get(), null2.get()); |
jdoerrie | 046caee | 2017-03-29 02:52:00 +0900 | [diff] [blame] | 807 | EXPECT_EQ(*null1, *null2); |
initial.commit | 3f4a732 | 2008-07-27 06:49:38 +0900 | [diff] [blame] | 808 | |
jdoerrie | bfe825e | 2017-03-02 21:09:19 +0900 | [diff] [blame] | 809 | Value boolean(false); |
jdoerrie | 046caee | 2017-03-29 02:52:00 +0900 | [diff] [blame] | 810 | EXPECT_NE(*null1, boolean); |
initial.commit | 3f4a732 | 2008-07-27 06:49:38 +0900 | [diff] [blame] | 811 | |
| 812 | DictionaryValue dv; |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 813 | dv.SetBoolean("a", false); |
| 814 | dv.SetInteger("b", 2); |
arv@chromium.org | 13413eb | 2011-02-01 10:02:07 +0900 | [diff] [blame] | 815 | dv.SetDouble("c", 2.5); |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 816 | dv.SetString("d1", "string"); |
viettrungluu@chromium.org | b7b6aa0 | 2010-08-05 01:58:12 +0900 | [diff] [blame] | 817 | dv.SetString("d2", ASCIIToUTF16("http://google.com")); |
jdoerrie | fcdbae7 | 2017-04-07 15:39:00 +0900 | [diff] [blame] | 818 | dv.Set("e", MakeUnique<Value>()); |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 819 | |
jdoerrie | 751d7d7 | 2017-04-05 15:44:17 +0900 | [diff] [blame] | 820 | auto copy = MakeUnique<DictionaryValue>(dv); |
jdoerrie | 046caee | 2017-03-29 02:52:00 +0900 | [diff] [blame] | 821 | EXPECT_EQ(dv, *copy); |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 822 | |
dcheng | cc8e4d8 | 2016-04-05 06:25:51 +0900 | [diff] [blame] | 823 | std::unique_ptr<ListValue> list(new ListValue); |
danakj | 4d4eaf0 | 2015-05-12 06:24:09 +0900 | [diff] [blame] | 824 | ListValue* original_list = list.get(); |
jdoerrie | fcdbae7 | 2017-04-07 15:39:00 +0900 | [diff] [blame] | 825 | list->Append(MakeUnique<Value>()); |
dcheng | cc8e4d8 | 2016-04-05 06:25:51 +0900 | [diff] [blame] | 826 | list->Append(WrapUnique(new DictionaryValue)); |
jdoerrie | 751d7d7 | 2017-04-05 15:44:17 +0900 | [diff] [blame] | 827 | auto list_copy = MakeUnique<Value>(*list); |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 828 | |
danakj | 800d2ea | 2015-11-25 14:29:58 +0900 | [diff] [blame] | 829 | dv.Set("f", std::move(list)); |
jdoerrie | 046caee | 2017-03-29 02:52:00 +0900 | [diff] [blame] | 830 | EXPECT_NE(dv, *copy); |
danakj | 800d2ea | 2015-11-25 14:29:58 +0900 | [diff] [blame] | 831 | copy->Set("f", std::move(list_copy)); |
jdoerrie | 046caee | 2017-03-29 02:52:00 +0900 | [diff] [blame] | 832 | EXPECT_EQ(dv, *copy); |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 833 | |
jdoerrie | bfe825e | 2017-03-02 21:09:19 +0900 | [diff] [blame] | 834 | original_list->Append(MakeUnique<Value>(true)); |
jdoerrie | 046caee | 2017-03-29 02:52:00 +0900 | [diff] [blame] | 835 | EXPECT_NE(dv, *copy); |
mnissler@chromium.org | fd5fde9 | 2010-08-19 01:23:40 +0900 | [diff] [blame] | 836 | |
| 837 | // Check if Equals detects differences in only the keys. |
jdoerrie | 751d7d7 | 2017-04-05 15:44:17 +0900 | [diff] [blame] | 838 | copy = MakeUnique<DictionaryValue>(dv); |
jdoerrie | 046caee | 2017-03-29 02:52:00 +0900 | [diff] [blame] | 839 | EXPECT_EQ(dv, *copy); |
mnissler@chromium.org | fd5fde9 | 2010-08-19 01:23:40 +0900 | [diff] [blame] | 840 | copy->Remove("a", NULL); |
| 841 | copy->SetBoolean("aa", false); |
jdoerrie | 046caee | 2017-03-29 02:52:00 +0900 | [diff] [blame] | 842 | EXPECT_NE(dv, *copy); |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 843 | } |
| 844 | |
tfarina@chromium.org | 4cdd38e | 2011-06-29 07:56:33 +0900 | [diff] [blame] | 845 | TEST(ValuesTest, StaticEquals) { |
jdoerrie | fcdbae7 | 2017-04-07 15:39:00 +0900 | [diff] [blame] | 846 | auto null1 = MakeUnique<Value>(); |
| 847 | auto null2 = MakeUnique<Value>(); |
bauerb@chromium.org | fbd55e1 | 2010-12-07 03:13:43 +0900 | [diff] [blame] | 848 | EXPECT_TRUE(Value::Equals(null1.get(), null2.get())); |
| 849 | EXPECT_TRUE(Value::Equals(NULL, NULL)); |
| 850 | |
jdoerrie | bfe825e | 2017-03-02 21:09:19 +0900 | [diff] [blame] | 851 | std::unique_ptr<Value> i42(new Value(42)); |
| 852 | std::unique_ptr<Value> j42(new Value(42)); |
| 853 | std::unique_ptr<Value> i17(new Value(17)); |
bauerb@chromium.org | fbd55e1 | 2010-12-07 03:13:43 +0900 | [diff] [blame] | 854 | EXPECT_TRUE(Value::Equals(i42.get(), i42.get())); |
| 855 | EXPECT_TRUE(Value::Equals(j42.get(), i42.get())); |
| 856 | EXPECT_TRUE(Value::Equals(i42.get(), j42.get())); |
| 857 | EXPECT_FALSE(Value::Equals(i42.get(), i17.get())); |
| 858 | EXPECT_FALSE(Value::Equals(i42.get(), NULL)); |
| 859 | EXPECT_FALSE(Value::Equals(NULL, i42.get())); |
| 860 | |
jdoerrie | fcdbae7 | 2017-04-07 15:39:00 +0900 | [diff] [blame] | 861 | // NULL and MakeUnique<Value>() are intentionally different: We need |
bauerb@chromium.org | fbd55e1 | 2010-12-07 03:13:43 +0900 | [diff] [blame] | 862 | // support for NULL as a return value for "undefined" without caring for |
| 863 | // ownership of the pointer. |
| 864 | EXPECT_FALSE(Value::Equals(null1.get(), NULL)); |
| 865 | EXPECT_FALSE(Value::Equals(NULL, null1.get())); |
| 866 | } |
| 867 | |
jdoerrie | 046caee | 2017-03-29 02:52:00 +0900 | [diff] [blame] | 868 | TEST(ValuesTest, Comparisons) { |
| 869 | // Test None Values. |
| 870 | Value null1; |
| 871 | Value null2; |
| 872 | EXPECT_EQ(null1, null2); |
| 873 | EXPECT_FALSE(null1 != null2); |
| 874 | EXPECT_FALSE(null1 < null2); |
| 875 | EXPECT_FALSE(null1 > null2); |
| 876 | EXPECT_LE(null1, null2); |
| 877 | EXPECT_GE(null1, null2); |
| 878 | |
| 879 | // Test Bool Values. |
| 880 | Value bool1(false); |
| 881 | Value bool2(true); |
| 882 | EXPECT_FALSE(bool1 == bool2); |
| 883 | EXPECT_NE(bool1, bool2); |
| 884 | EXPECT_LT(bool1, bool2); |
| 885 | EXPECT_FALSE(bool1 > bool2); |
| 886 | EXPECT_LE(bool1, bool2); |
| 887 | EXPECT_FALSE(bool1 >= bool2); |
| 888 | |
| 889 | // Test Int Values. |
| 890 | Value int1(1); |
| 891 | Value int2(2); |
| 892 | EXPECT_FALSE(int1 == int2); |
| 893 | EXPECT_NE(int1, int2); |
| 894 | EXPECT_LT(int1, int2); |
| 895 | EXPECT_FALSE(int1 > int2); |
| 896 | EXPECT_LE(int1, int2); |
| 897 | EXPECT_FALSE(int1 >= int2); |
| 898 | |
| 899 | // Test Double Values. |
| 900 | Value double1(1.0); |
| 901 | Value double2(2.0); |
| 902 | EXPECT_FALSE(double1 == double2); |
| 903 | EXPECT_NE(double1, double2); |
| 904 | EXPECT_LT(double1, double2); |
| 905 | EXPECT_FALSE(double1 > double2); |
| 906 | EXPECT_LE(double1, double2); |
| 907 | EXPECT_FALSE(double1 >= double2); |
| 908 | |
| 909 | // Test String Values. |
| 910 | Value string1("1"); |
| 911 | Value string2("2"); |
| 912 | EXPECT_FALSE(string1 == string2); |
| 913 | EXPECT_NE(string1, string2); |
| 914 | EXPECT_LT(string1, string2); |
| 915 | EXPECT_FALSE(string1 > string2); |
| 916 | EXPECT_LE(string1, string2); |
| 917 | EXPECT_FALSE(string1 >= string2); |
| 918 | |
| 919 | // Test Binary Values. |
| 920 | Value binary1(std::vector<char>{0x01}); |
| 921 | Value binary2(std::vector<char>{0x02}); |
| 922 | EXPECT_FALSE(binary1 == binary2); |
| 923 | EXPECT_NE(binary1, binary2); |
| 924 | EXPECT_LT(binary1, binary2); |
| 925 | EXPECT_FALSE(binary1 > binary2); |
| 926 | EXPECT_LE(binary1, binary2); |
| 927 | EXPECT_FALSE(binary1 >= binary2); |
| 928 | |
| 929 | // Test Empty List Values. |
| 930 | ListValue null_list1; |
| 931 | ListValue null_list2; |
| 932 | EXPECT_EQ(null_list1, null_list2); |
| 933 | EXPECT_FALSE(null_list1 != null_list2); |
| 934 | EXPECT_FALSE(null_list1 < null_list2); |
| 935 | EXPECT_FALSE(null_list1 > null_list2); |
| 936 | EXPECT_LE(null_list1, null_list2); |
| 937 | EXPECT_GE(null_list1, null_list2); |
| 938 | |
| 939 | // Test Non Empty List Values. |
| 940 | ListValue int_list1; |
| 941 | ListValue int_list2; |
| 942 | int_list1.AppendInteger(1); |
| 943 | int_list2.AppendInteger(2); |
| 944 | EXPECT_FALSE(int_list1 == int_list2); |
| 945 | EXPECT_NE(int_list1, int_list2); |
| 946 | EXPECT_LT(int_list1, int_list2); |
| 947 | EXPECT_FALSE(int_list1 > int_list2); |
| 948 | EXPECT_LE(int_list1, int_list2); |
| 949 | EXPECT_FALSE(int_list1 >= int_list2); |
| 950 | |
| 951 | // Test Empty Dict Values. |
| 952 | DictionaryValue null_dict1; |
| 953 | DictionaryValue null_dict2; |
| 954 | EXPECT_EQ(null_dict1, null_dict2); |
| 955 | EXPECT_FALSE(null_dict1 != null_dict2); |
| 956 | EXPECT_FALSE(null_dict1 < null_dict2); |
| 957 | EXPECT_FALSE(null_dict1 > null_dict2); |
| 958 | EXPECT_LE(null_dict1, null_dict2); |
| 959 | EXPECT_GE(null_dict1, null_dict2); |
| 960 | |
| 961 | // Test Non Empty Dict Values. |
| 962 | DictionaryValue int_dict1; |
| 963 | DictionaryValue int_dict2; |
| 964 | int_dict1.SetInteger("key", 1); |
| 965 | int_dict2.SetInteger("key", 2); |
| 966 | EXPECT_FALSE(int_dict1 == int_dict2); |
| 967 | EXPECT_NE(int_dict1, int_dict2); |
| 968 | EXPECT_LT(int_dict1, int_dict2); |
| 969 | EXPECT_FALSE(int_dict1 > int_dict2); |
| 970 | EXPECT_LE(int_dict1, int_dict2); |
| 971 | EXPECT_FALSE(int_dict1 >= int_dict2); |
| 972 | |
| 973 | // Test Values of different types. |
| 974 | std::vector<Value> values = {null1, bool1, int1, double1, |
| 975 | string1, binary1, int_dict1, int_list1}; |
| 976 | for (size_t i = 0; i < values.size(); ++i) { |
| 977 | for (size_t j = i + 1; j < values.size(); ++j) { |
| 978 | EXPECT_FALSE(values[i] == values[j]); |
| 979 | EXPECT_NE(values[i], values[j]); |
| 980 | EXPECT_LT(values[i], values[j]); |
| 981 | EXPECT_FALSE(values[i] > values[j]); |
| 982 | EXPECT_LE(values[i], values[j]); |
| 983 | EXPECT_FALSE(values[i] >= values[j]); |
| 984 | } |
| 985 | } |
| 986 | } |
| 987 | |
tfarina@chromium.org | 4cdd38e | 2011-06-29 07:56:33 +0900 | [diff] [blame] | 988 | TEST(ValuesTest, DeepCopyCovariantReturnTypes) { |
akalin@chromium.org | 810f92f | 2011-01-18 11:16:59 +0900 | [diff] [blame] | 989 | DictionaryValue original_dict; |
jdoerrie | fcdbae7 | 2017-04-07 15:39:00 +0900 | [diff] [blame] | 990 | auto scoped_null = MakeUnique<Value>(); |
danakj | 4d4eaf0 | 2015-05-12 06:24:09 +0900 | [diff] [blame] | 991 | Value* original_null = scoped_null.get(); |
danakj | 800d2ea | 2015-11-25 14:29:58 +0900 | [diff] [blame] | 992 | original_dict.Set("null", std::move(scoped_null)); |
jdoerrie | bfe825e | 2017-03-02 21:09:19 +0900 | [diff] [blame] | 993 | std::unique_ptr<Value> scoped_bool(new Value(true)); |
danakj | 4d4eaf0 | 2015-05-12 06:24:09 +0900 | [diff] [blame] | 994 | Value* original_bool = scoped_bool.get(); |
danakj | 800d2ea | 2015-11-25 14:29:58 +0900 | [diff] [blame] | 995 | original_dict.Set("bool", std::move(scoped_bool)); |
jdoerrie | bfe825e | 2017-03-02 21:09:19 +0900 | [diff] [blame] | 996 | std::unique_ptr<Value> scoped_int(new Value(42)); |
danakj | 4d4eaf0 | 2015-05-12 06:24:09 +0900 | [diff] [blame] | 997 | Value* original_int = scoped_int.get(); |
danakj | 800d2ea | 2015-11-25 14:29:58 +0900 | [diff] [blame] | 998 | original_dict.Set("int", std::move(scoped_int)); |
jdoerrie | bfe825e | 2017-03-02 21:09:19 +0900 | [diff] [blame] | 999 | std::unique_ptr<Value> scoped_double(new Value(3.14)); |
danakj | 4d4eaf0 | 2015-05-12 06:24:09 +0900 | [diff] [blame] | 1000 | Value* original_double = scoped_double.get(); |
danakj | 800d2ea | 2015-11-25 14:29:58 +0900 | [diff] [blame] | 1001 | original_dict.Set("double", std::move(scoped_double)); |
jdoerrie | 0d1295b | 2017-03-06 20:12:04 +0900 | [diff] [blame] | 1002 | std::unique_ptr<Value> scoped_string(new Value("hello")); |
danakj | 4d4eaf0 | 2015-05-12 06:24:09 +0900 | [diff] [blame] | 1003 | Value* original_string = scoped_string.get(); |
danakj | 800d2ea | 2015-11-25 14:29:58 +0900 | [diff] [blame] | 1004 | original_dict.Set("string", std::move(scoped_string)); |
jdoerrie | 0d1295b | 2017-03-06 20:12:04 +0900 | [diff] [blame] | 1005 | std::unique_ptr<Value> scoped_string16(new Value(ASCIIToUTF16("hello16"))); |
danakj | 4d4eaf0 | 2015-05-12 06:24:09 +0900 | [diff] [blame] | 1006 | Value* original_string16 = scoped_string16.get(); |
danakj | 800d2ea | 2015-11-25 14:29:58 +0900 | [diff] [blame] | 1007 | original_dict.Set("string16", std::move(scoped_string16)); |
akalin@chromium.org | 810f92f | 2011-01-18 11:16:59 +0900 | [diff] [blame] | 1008 | |
jdoerrie | 58325a4 | 2017-02-15 17:42:14 +0900 | [diff] [blame] | 1009 | std::vector<char> original_buffer(42, '!'); |
jdoerrie | c56cc7f | 2017-04-11 16:45:50 +0900 | [diff] [blame] | 1010 | std::unique_ptr<Value> scoped_binary(new Value(std::move(original_buffer))); |
danakj | 4d4eaf0 | 2015-05-12 06:24:09 +0900 | [diff] [blame] | 1011 | Value* original_binary = scoped_binary.get(); |
danakj | 800d2ea | 2015-11-25 14:29:58 +0900 | [diff] [blame] | 1012 | original_dict.Set("binary", std::move(scoped_binary)); |
akalin@chromium.org | 810f92f | 2011-01-18 11:16:59 +0900 | [diff] [blame] | 1013 | |
dcheng | cc8e4d8 | 2016-04-05 06:25:51 +0900 | [diff] [blame] | 1014 | std::unique_ptr<ListValue> scoped_list(new ListValue()); |
danakj | 4d4eaf0 | 2015-05-12 06:24:09 +0900 | [diff] [blame] | 1015 | Value* original_list = scoped_list.get(); |
jdoerrie | bfe825e | 2017-03-02 21:09:19 +0900 | [diff] [blame] | 1016 | std::unique_ptr<Value> scoped_list_element_0(new Value(0)); |
danakj | 800d2ea | 2015-11-25 14:29:58 +0900 | [diff] [blame] | 1017 | scoped_list->Append(std::move(scoped_list_element_0)); |
jdoerrie | bfe825e | 2017-03-02 21:09:19 +0900 | [diff] [blame] | 1018 | std::unique_ptr<Value> scoped_list_element_1(new Value(1)); |
danakj | 800d2ea | 2015-11-25 14:29:58 +0900 | [diff] [blame] | 1019 | scoped_list->Append(std::move(scoped_list_element_1)); |
| 1020 | original_dict.Set("list", std::move(scoped_list)); |
akalin@chromium.org | 810f92f | 2011-01-18 11:16:59 +0900 | [diff] [blame] | 1021 | |
jdoerrie | 751d7d7 | 2017-04-05 15:44:17 +0900 | [diff] [blame] | 1022 | auto copy_dict = MakeUnique<Value>(original_dict); |
| 1023 | auto copy_null = MakeUnique<Value>(*original_null); |
| 1024 | auto copy_bool = MakeUnique<Value>(*original_bool); |
| 1025 | auto copy_int = MakeUnique<Value>(*original_int); |
| 1026 | auto copy_double = MakeUnique<Value>(*original_double); |
| 1027 | auto copy_string = MakeUnique<Value>(*original_string); |
| 1028 | auto copy_string16 = MakeUnique<Value>(*original_string16); |
| 1029 | auto copy_binary = MakeUnique<Value>(*original_binary); |
| 1030 | auto copy_list = MakeUnique<Value>(*original_list); |
akalin@chromium.org | 810f92f | 2011-01-18 11:16:59 +0900 | [diff] [blame] | 1031 | |
jdoerrie | 046caee | 2017-03-29 02:52:00 +0900 | [diff] [blame] | 1032 | EXPECT_EQ(original_dict, *copy_dict); |
| 1033 | EXPECT_EQ(*original_null, *copy_null); |
| 1034 | EXPECT_EQ(*original_bool, *copy_bool); |
| 1035 | EXPECT_EQ(*original_int, *copy_int); |
| 1036 | EXPECT_EQ(*original_double, *copy_double); |
| 1037 | EXPECT_EQ(*original_string, *copy_string); |
| 1038 | EXPECT_EQ(*original_string16, *copy_string16); |
| 1039 | EXPECT_EQ(*original_binary, *copy_binary); |
| 1040 | EXPECT_EQ(*original_list, *copy_list); |
akalin@chromium.org | 810f92f | 2011-01-18 11:16:59 +0900 | [diff] [blame] | 1041 | } |
| 1042 | |
tfarina@chromium.org | 4cdd38e | 2011-06-29 07:56:33 +0900 | [diff] [blame] | 1043 | TEST(ValuesTest, RemoveEmptyChildren) { |
dcheng | cc8e4d8 | 2016-04-05 06:25:51 +0900 | [diff] [blame] | 1044 | std::unique_ptr<DictionaryValue> root(new DictionaryValue); |
tony@chromium.org | e4948ab | 2009-12-02 09:20:32 +0900 | [diff] [blame] | 1045 | // Remove empty lists and dictionaries. |
dcheng | cc8e4d8 | 2016-04-05 06:25:51 +0900 | [diff] [blame] | 1046 | root->Set("empty_dict", WrapUnique(new DictionaryValue)); |
| 1047 | root->Set("empty_list", WrapUnique(new ListValue)); |
estade | 948395d | 2015-01-07 05:06:50 +0900 | [diff] [blame] | 1048 | root->SetWithoutPathExpansion("a.b.c.d.e", |
dcheng | cc8e4d8 | 2016-04-05 06:25:51 +0900 | [diff] [blame] | 1049 | WrapUnique(new DictionaryValue)); |
estade | 51a57ab | 2015-05-23 11:42:09 +0900 | [diff] [blame] | 1050 | root = root->DeepCopyWithoutEmptyChildren(); |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 1051 | EXPECT_TRUE(root->empty()); |
| 1052 | |
| 1053 | // Make sure we don't prune too much. |
| 1054 | root->SetBoolean("bool", true); |
dcheng | cc8e4d8 | 2016-04-05 06:25:51 +0900 | [diff] [blame] | 1055 | root->Set("empty_dict", WrapUnique(new DictionaryValue)); |
dcheng@chromium.org | 8164c2c | 2013-04-09 17:46:45 +0900 | [diff] [blame] | 1056 | root->SetString("empty_string", std::string()); |
estade | 51a57ab | 2015-05-23 11:42:09 +0900 | [diff] [blame] | 1057 | root = root->DeepCopyWithoutEmptyChildren(); |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 1058 | EXPECT_EQ(2U, root->size()); |
| 1059 | |
| 1060 | // Should do nothing. |
estade | 51a57ab | 2015-05-23 11:42:09 +0900 | [diff] [blame] | 1061 | root = root->DeepCopyWithoutEmptyChildren(); |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 1062 | EXPECT_EQ(2U, root->size()); |
| 1063 | |
| 1064 | // Nested test cases. These should all reduce back to the bool and string |
| 1065 | // set above. |
| 1066 | { |
dcheng | cc8e4d8 | 2016-04-05 06:25:51 +0900 | [diff] [blame] | 1067 | root->Set("a.b.c.d.e", WrapUnique(new DictionaryValue)); |
estade | 51a57ab | 2015-05-23 11:42:09 +0900 | [diff] [blame] | 1068 | root = root->DeepCopyWithoutEmptyChildren(); |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 1069 | EXPECT_EQ(2U, root->size()); |
| 1070 | } |
| 1071 | { |
dcheng | cc8e4d8 | 2016-04-05 06:25:51 +0900 | [diff] [blame] | 1072 | std::unique_ptr<DictionaryValue> inner(new DictionaryValue); |
| 1073 | inner->Set("empty_dict", WrapUnique(new DictionaryValue)); |
| 1074 | inner->Set("empty_list", WrapUnique(new ListValue)); |
danakj | 800d2ea | 2015-11-25 14:29:58 +0900 | [diff] [blame] | 1075 | root->Set("dict_with_empty_children", std::move(inner)); |
estade | 51a57ab | 2015-05-23 11:42:09 +0900 | [diff] [blame] | 1076 | root = root->DeepCopyWithoutEmptyChildren(); |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 1077 | EXPECT_EQ(2U, root->size()); |
| 1078 | } |
| 1079 | { |
dcheng | cc8e4d8 | 2016-04-05 06:25:51 +0900 | [diff] [blame] | 1080 | std::unique_ptr<ListValue> inner(new ListValue); |
| 1081 | inner->Append(WrapUnique(new DictionaryValue)); |
| 1082 | inner->Append(WrapUnique(new ListValue)); |
danakj | 800d2ea | 2015-11-25 14:29:58 +0900 | [diff] [blame] | 1083 | root->Set("list_with_empty_children", std::move(inner)); |
estade | 51a57ab | 2015-05-23 11:42:09 +0900 | [diff] [blame] | 1084 | root = root->DeepCopyWithoutEmptyChildren(); |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 1085 | EXPECT_EQ(2U, root->size()); |
| 1086 | } |
| 1087 | |
| 1088 | // Nested with siblings. |
| 1089 | { |
dcheng | cc8e4d8 | 2016-04-05 06:25:51 +0900 | [diff] [blame] | 1090 | std::unique_ptr<ListValue> inner(new ListValue()); |
| 1091 | inner->Append(WrapUnique(new DictionaryValue)); |
| 1092 | inner->Append(WrapUnique(new ListValue)); |
danakj | 800d2ea | 2015-11-25 14:29:58 +0900 | [diff] [blame] | 1093 | root->Set("list_with_empty_children", std::move(inner)); |
dcheng | cc8e4d8 | 2016-04-05 06:25:51 +0900 | [diff] [blame] | 1094 | std::unique_ptr<DictionaryValue> inner2(new DictionaryValue); |
| 1095 | inner2->Set("empty_dict", WrapUnique(new DictionaryValue)); |
| 1096 | inner2->Set("empty_list", WrapUnique(new ListValue)); |
danakj | 800d2ea | 2015-11-25 14:29:58 +0900 | [diff] [blame] | 1097 | root->Set("dict_with_empty_children", std::move(inner2)); |
estade | 51a57ab | 2015-05-23 11:42:09 +0900 | [diff] [blame] | 1098 | root = root->DeepCopyWithoutEmptyChildren(); |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 1099 | EXPECT_EQ(2U, root->size()); |
| 1100 | } |
| 1101 | |
| 1102 | // Make sure nested values don't get pruned. |
| 1103 | { |
dcheng | cc8e4d8 | 2016-04-05 06:25:51 +0900 | [diff] [blame] | 1104 | std::unique_ptr<ListValue> inner(new ListValue); |
| 1105 | std::unique_ptr<ListValue> inner2(new ListValue); |
jdoerrie | 0d1295b | 2017-03-06 20:12:04 +0900 | [diff] [blame] | 1106 | inner2->Append(MakeUnique<Value>("hello")); |
dcheng | cc8e4d8 | 2016-04-05 06:25:51 +0900 | [diff] [blame] | 1107 | inner->Append(WrapUnique(new DictionaryValue)); |
danakj | 800d2ea | 2015-11-25 14:29:58 +0900 | [diff] [blame] | 1108 | inner->Append(std::move(inner2)); |
| 1109 | root->Set("list_with_empty_children", std::move(inner)); |
estade | 51a57ab | 2015-05-23 11:42:09 +0900 | [diff] [blame] | 1110 | root = root->DeepCopyWithoutEmptyChildren(); |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 1111 | EXPECT_EQ(3U, root->size()); |
estade | 77a018f | 2015-05-07 10:53:08 +0900 | [diff] [blame] | 1112 | |
| 1113 | ListValue* inner_value, *inner_value2; |
| 1114 | EXPECT_TRUE(root->GetList("list_with_empty_children", &inner_value)); |
| 1115 | EXPECT_EQ(1U, inner_value->GetSize()); // Dictionary was pruned. |
| 1116 | EXPECT_TRUE(inner_value->GetList(0, &inner_value2)); |
| 1117 | EXPECT_EQ(1U, inner_value2->GetSize()); |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 1118 | } |
| 1119 | } |
| 1120 | |
tfarina@chromium.org | 4cdd38e | 2011-06-29 07:56:33 +0900 | [diff] [blame] | 1121 | TEST(ValuesTest, MergeDictionary) { |
dcheng | cc8e4d8 | 2016-04-05 06:25:51 +0900 | [diff] [blame] | 1122 | std::unique_ptr<DictionaryValue> base(new DictionaryValue); |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 1123 | base->SetString("base_key", "base_key_value_base"); |
| 1124 | base->SetString("collide_key", "collide_key_value_base"); |
dcheng | cc8e4d8 | 2016-04-05 06:25:51 +0900 | [diff] [blame] | 1125 | std::unique_ptr<DictionaryValue> base_sub_dict(new DictionaryValue); |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 1126 | base_sub_dict->SetString("sub_base_key", "sub_base_key_value_base"); |
| 1127 | base_sub_dict->SetString("sub_collide_key", "sub_collide_key_value_base"); |
danakj | 800d2ea | 2015-11-25 14:29:58 +0900 | [diff] [blame] | 1128 | base->Set("sub_dict_key", std::move(base_sub_dict)); |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 1129 | |
dcheng | cc8e4d8 | 2016-04-05 06:25:51 +0900 | [diff] [blame] | 1130 | std::unique_ptr<DictionaryValue> merge(new DictionaryValue); |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 1131 | merge->SetString("merge_key", "merge_key_value_merge"); |
| 1132 | merge->SetString("collide_key", "collide_key_value_merge"); |
dcheng | cc8e4d8 | 2016-04-05 06:25:51 +0900 | [diff] [blame] | 1133 | std::unique_ptr<DictionaryValue> merge_sub_dict(new DictionaryValue); |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 1134 | merge_sub_dict->SetString("sub_merge_key", "sub_merge_key_value_merge"); |
| 1135 | merge_sub_dict->SetString("sub_collide_key", "sub_collide_key_value_merge"); |
danakj | 800d2ea | 2015-11-25 14:29:58 +0900 | [diff] [blame] | 1136 | merge->Set("sub_dict_key", std::move(merge_sub_dict)); |
viettrungluu@chromium.org | 496dec2 | 2010-07-31 13:56:14 +0900 | [diff] [blame] | 1137 | |
| 1138 | base->MergeDictionary(merge.get()); |
| 1139 | |
| 1140 | EXPECT_EQ(4U, base->size()); |
| 1141 | std::string base_key_value; |
| 1142 | EXPECT_TRUE(base->GetString("base_key", &base_key_value)); |
| 1143 | EXPECT_EQ("base_key_value_base", base_key_value); // Base value preserved. |
| 1144 | std::string collide_key_value; |
| 1145 | EXPECT_TRUE(base->GetString("collide_key", &collide_key_value)); |
| 1146 | EXPECT_EQ("collide_key_value_merge", collide_key_value); // Replaced. |
| 1147 | std::string merge_key_value; |
| 1148 | EXPECT_TRUE(base->GetString("merge_key", &merge_key_value)); |
| 1149 | EXPECT_EQ("merge_key_value_merge", merge_key_value); // Merged in. |
| 1150 | |
| 1151 | DictionaryValue* res_sub_dict; |
| 1152 | EXPECT_TRUE(base->GetDictionary("sub_dict_key", &res_sub_dict)); |
| 1153 | EXPECT_EQ(3U, res_sub_dict->size()); |
| 1154 | std::string sub_base_key_value; |
| 1155 | EXPECT_TRUE(res_sub_dict->GetString("sub_base_key", &sub_base_key_value)); |
| 1156 | EXPECT_EQ("sub_base_key_value_base", sub_base_key_value); // Preserved. |
| 1157 | std::string sub_collide_key_value; |
| 1158 | EXPECT_TRUE(res_sub_dict->GetString("sub_collide_key", |
| 1159 | &sub_collide_key_value)); |
| 1160 | EXPECT_EQ("sub_collide_key_value_merge", sub_collide_key_value); // Replaced. |
| 1161 | std::string sub_merge_key_value; |
| 1162 | EXPECT_TRUE(res_sub_dict->GetString("sub_merge_key", &sub_merge_key_value)); |
| 1163 | EXPECT_EQ("sub_merge_key_value_merge", sub_merge_key_value); // Merged in. |
| 1164 | } |
tfarina@chromium.org | 4cdd38e | 2011-06-29 07:56:33 +0900 | [diff] [blame] | 1165 | |
jhawkins@chromium.org | cbb2239 | 2012-05-10 06:54:27 +0900 | [diff] [blame] | 1166 | TEST(ValuesTest, MergeDictionaryDeepCopy) { |
dcheng | cc8e4d8 | 2016-04-05 06:25:51 +0900 | [diff] [blame] | 1167 | std::unique_ptr<DictionaryValue> child(new DictionaryValue); |
danakj | 4d4eaf0 | 2015-05-12 06:24:09 +0900 | [diff] [blame] | 1168 | DictionaryValue* original_child = child.get(); |
jhawkins@chromium.org | cbb2239 | 2012-05-10 06:54:27 +0900 | [diff] [blame] | 1169 | child->SetString("test", "value"); |
| 1170 | EXPECT_EQ(1U, child->size()); |
| 1171 | |
| 1172 | std::string value; |
| 1173 | EXPECT_TRUE(child->GetString("test", &value)); |
| 1174 | EXPECT_EQ("value", value); |
| 1175 | |
dcheng | cc8e4d8 | 2016-04-05 06:25:51 +0900 | [diff] [blame] | 1176 | std::unique_ptr<DictionaryValue> base(new DictionaryValue); |
danakj | 800d2ea | 2015-11-25 14:29:58 +0900 | [diff] [blame] | 1177 | base->Set("dict", std::move(child)); |
jhawkins@chromium.org | cbb2239 | 2012-05-10 06:54:27 +0900 | [diff] [blame] | 1178 | EXPECT_EQ(1U, base->size()); |
| 1179 | |
| 1180 | DictionaryValue* ptr; |
| 1181 | EXPECT_TRUE(base->GetDictionary("dict", &ptr)); |
danakj | 4d4eaf0 | 2015-05-12 06:24:09 +0900 | [diff] [blame] | 1182 | EXPECT_EQ(original_child, ptr); |
jhawkins@chromium.org | cbb2239 | 2012-05-10 06:54:27 +0900 | [diff] [blame] | 1183 | |
dcheng | cc8e4d8 | 2016-04-05 06:25:51 +0900 | [diff] [blame] | 1184 | std::unique_ptr<DictionaryValue> merged(new DictionaryValue); |
jhawkins@chromium.org | cbb2239 | 2012-05-10 06:54:27 +0900 | [diff] [blame] | 1185 | merged->MergeDictionary(base.get()); |
| 1186 | EXPECT_EQ(1U, merged->size()); |
| 1187 | EXPECT_TRUE(merged->GetDictionary("dict", &ptr)); |
danakj | 4d4eaf0 | 2015-05-12 06:24:09 +0900 | [diff] [blame] | 1188 | EXPECT_NE(original_child, ptr); |
jhawkins@chromium.org | cbb2239 | 2012-05-10 06:54:27 +0900 | [diff] [blame] | 1189 | EXPECT_TRUE(ptr->GetString("test", &value)); |
| 1190 | EXPECT_EQ("value", value); |
| 1191 | |
danakj | 4d4eaf0 | 2015-05-12 06:24:09 +0900 | [diff] [blame] | 1192 | original_child->SetString("test", "overwrite"); |
jhawkins@chromium.org | cbb2239 | 2012-05-10 06:54:27 +0900 | [diff] [blame] | 1193 | base.reset(); |
| 1194 | EXPECT_TRUE(ptr->GetString("test", &value)); |
| 1195 | EXPECT_EQ("value", value); |
| 1196 | } |
| 1197 | |
kalman@chromium.org | 1604ad6 | 2011-11-09 06:26:41 +0900 | [diff] [blame] | 1198 | TEST(ValuesTest, DictionaryIterator) { |
| 1199 | DictionaryValue dict; |
pneubeck@chromium.org | d6c6d24 | 2013-04-12 18:25:23 +0900 | [diff] [blame] | 1200 | for (DictionaryValue::Iterator it(dict); !it.IsAtEnd(); it.Advance()) { |
kalman@chromium.org | 1604ad6 | 2011-11-09 06:26:41 +0900 | [diff] [blame] | 1201 | ADD_FAILURE(); |
| 1202 | } |
| 1203 | |
jdoerrie | 0d1295b | 2017-03-06 20:12:04 +0900 | [diff] [blame] | 1204 | Value value1("value1"); |
jdoerrie | 751d7d7 | 2017-04-05 15:44:17 +0900 | [diff] [blame] | 1205 | dict.Set("key1", MakeUnique<Value>(value1)); |
kalman@chromium.org | 1604ad6 | 2011-11-09 06:26:41 +0900 | [diff] [blame] | 1206 | bool seen1 = false; |
pneubeck@chromium.org | d6c6d24 | 2013-04-12 18:25:23 +0900 | [diff] [blame] | 1207 | for (DictionaryValue::Iterator it(dict); !it.IsAtEnd(); it.Advance()) { |
kalman@chromium.org | 1604ad6 | 2011-11-09 06:26:41 +0900 | [diff] [blame] | 1208 | EXPECT_FALSE(seen1); |
| 1209 | EXPECT_EQ("key1", it.key()); |
jdoerrie | 046caee | 2017-03-29 02:52:00 +0900 | [diff] [blame] | 1210 | EXPECT_EQ(value1, it.value()); |
kalman@chromium.org | 1604ad6 | 2011-11-09 06:26:41 +0900 | [diff] [blame] | 1211 | seen1 = true; |
| 1212 | } |
| 1213 | EXPECT_TRUE(seen1); |
| 1214 | |
jdoerrie | 0d1295b | 2017-03-06 20:12:04 +0900 | [diff] [blame] | 1215 | Value value2("value2"); |
jdoerrie | 751d7d7 | 2017-04-05 15:44:17 +0900 | [diff] [blame] | 1216 | dict.Set("key2", MakeUnique<Value>(value2)); |
kalman@chromium.org | 1604ad6 | 2011-11-09 06:26:41 +0900 | [diff] [blame] | 1217 | bool seen2 = seen1 = false; |
pneubeck@chromium.org | d6c6d24 | 2013-04-12 18:25:23 +0900 | [diff] [blame] | 1218 | for (DictionaryValue::Iterator it(dict); !it.IsAtEnd(); it.Advance()) { |
kalman@chromium.org | 1604ad6 | 2011-11-09 06:26:41 +0900 | [diff] [blame] | 1219 | if (it.key() == "key1") { |
| 1220 | EXPECT_FALSE(seen1); |
jdoerrie | 046caee | 2017-03-29 02:52:00 +0900 | [diff] [blame] | 1221 | EXPECT_EQ(value1, it.value()); |
kalman@chromium.org | 1604ad6 | 2011-11-09 06:26:41 +0900 | [diff] [blame] | 1222 | seen1 = true; |
| 1223 | } else if (it.key() == "key2") { |
| 1224 | EXPECT_FALSE(seen2); |
jdoerrie | 046caee | 2017-03-29 02:52:00 +0900 | [diff] [blame] | 1225 | EXPECT_EQ(value2, it.value()); |
kalman@chromium.org | 1604ad6 | 2011-11-09 06:26:41 +0900 | [diff] [blame] | 1226 | seen2 = true; |
| 1227 | } else { |
| 1228 | ADD_FAILURE(); |
| 1229 | } |
| 1230 | } |
| 1231 | EXPECT_TRUE(seen1); |
| 1232 | EXPECT_TRUE(seen2); |
| 1233 | } |
| 1234 | |
gab@chromium.org | b3fa814 | 2014-03-09 16:13:23 +0900 | [diff] [blame] | 1235 | // DictionaryValue/ListValue's Get*() methods should accept NULL as an out-value |
| 1236 | // and still return true/false based on success. |
| 1237 | TEST(ValuesTest, GetWithNullOutValue) { |
| 1238 | DictionaryValue main_dict; |
| 1239 | ListValue main_list; |
| 1240 | |
jdoerrie | bfe825e | 2017-03-02 21:09:19 +0900 | [diff] [blame] | 1241 | Value bool_value(false); |
| 1242 | Value int_value(1234); |
| 1243 | Value double_value(12.34567); |
jdoerrie | 0d1295b | 2017-03-06 20:12:04 +0900 | [diff] [blame] | 1244 | Value string_value("foo"); |
jdoerrie | c56cc7f | 2017-04-11 16:45:50 +0900 | [diff] [blame] | 1245 | Value binary_value(Value::Type::BINARY); |
gab@chromium.org | b3fa814 | 2014-03-09 16:13:23 +0900 | [diff] [blame] | 1246 | DictionaryValue dict_value; |
| 1247 | ListValue list_value; |
| 1248 | |
jdoerrie | 751d7d7 | 2017-04-05 15:44:17 +0900 | [diff] [blame] | 1249 | main_dict.Set("bool", MakeUnique<Value>(bool_value)); |
| 1250 | main_dict.Set("int", MakeUnique<Value>(int_value)); |
| 1251 | main_dict.Set("double", MakeUnique<Value>(double_value)); |
| 1252 | main_dict.Set("string", MakeUnique<Value>(string_value)); |
| 1253 | main_dict.Set("binary", MakeUnique<Value>(binary_value)); |
| 1254 | main_dict.Set("dict", MakeUnique<Value>(dict_value)); |
| 1255 | main_dict.Set("list", MakeUnique<Value>(list_value)); |
gab@chromium.org | b3fa814 | 2014-03-09 16:13:23 +0900 | [diff] [blame] | 1256 | |
jdoerrie | 751d7d7 | 2017-04-05 15:44:17 +0900 | [diff] [blame] | 1257 | main_list.Append(MakeUnique<Value>(bool_value)); |
| 1258 | main_list.Append(MakeUnique<Value>(int_value)); |
| 1259 | main_list.Append(MakeUnique<Value>(double_value)); |
| 1260 | main_list.Append(MakeUnique<Value>(string_value)); |
| 1261 | main_list.Append(MakeUnique<Value>(binary_value)); |
| 1262 | main_list.Append(MakeUnique<Value>(dict_value)); |
| 1263 | main_list.Append(MakeUnique<Value>(list_value)); |
gab@chromium.org | b3fa814 | 2014-03-09 16:13:23 +0900 | [diff] [blame] | 1264 | |
| 1265 | EXPECT_TRUE(main_dict.Get("bool", NULL)); |
| 1266 | EXPECT_TRUE(main_dict.Get("int", NULL)); |
| 1267 | EXPECT_TRUE(main_dict.Get("double", NULL)); |
| 1268 | EXPECT_TRUE(main_dict.Get("string", NULL)); |
| 1269 | EXPECT_TRUE(main_dict.Get("binary", NULL)); |
| 1270 | EXPECT_TRUE(main_dict.Get("dict", NULL)); |
| 1271 | EXPECT_TRUE(main_dict.Get("list", NULL)); |
| 1272 | EXPECT_FALSE(main_dict.Get("DNE", NULL)); |
| 1273 | |
| 1274 | EXPECT_TRUE(main_dict.GetBoolean("bool", NULL)); |
| 1275 | EXPECT_FALSE(main_dict.GetBoolean("int", NULL)); |
| 1276 | EXPECT_FALSE(main_dict.GetBoolean("double", NULL)); |
| 1277 | EXPECT_FALSE(main_dict.GetBoolean("string", NULL)); |
| 1278 | EXPECT_FALSE(main_dict.GetBoolean("binary", NULL)); |
| 1279 | EXPECT_FALSE(main_dict.GetBoolean("dict", NULL)); |
| 1280 | EXPECT_FALSE(main_dict.GetBoolean("list", NULL)); |
| 1281 | EXPECT_FALSE(main_dict.GetBoolean("DNE", NULL)); |
| 1282 | |
| 1283 | EXPECT_FALSE(main_dict.GetInteger("bool", NULL)); |
| 1284 | EXPECT_TRUE(main_dict.GetInteger("int", NULL)); |
| 1285 | EXPECT_FALSE(main_dict.GetInteger("double", NULL)); |
| 1286 | EXPECT_FALSE(main_dict.GetInteger("string", NULL)); |
| 1287 | EXPECT_FALSE(main_dict.GetInteger("binary", NULL)); |
| 1288 | EXPECT_FALSE(main_dict.GetInteger("dict", NULL)); |
| 1289 | EXPECT_FALSE(main_dict.GetInteger("list", NULL)); |
| 1290 | EXPECT_FALSE(main_dict.GetInteger("DNE", NULL)); |
| 1291 | |
| 1292 | // Both int and double values can be obtained from GetDouble. |
| 1293 | EXPECT_FALSE(main_dict.GetDouble("bool", NULL)); |
| 1294 | EXPECT_TRUE(main_dict.GetDouble("int", NULL)); |
| 1295 | EXPECT_TRUE(main_dict.GetDouble("double", NULL)); |
| 1296 | EXPECT_FALSE(main_dict.GetDouble("string", NULL)); |
| 1297 | EXPECT_FALSE(main_dict.GetDouble("binary", NULL)); |
| 1298 | EXPECT_FALSE(main_dict.GetDouble("dict", NULL)); |
| 1299 | EXPECT_FALSE(main_dict.GetDouble("list", NULL)); |
| 1300 | EXPECT_FALSE(main_dict.GetDouble("DNE", NULL)); |
| 1301 | |
| 1302 | EXPECT_FALSE(main_dict.GetString("bool", static_cast<std::string*>(NULL))); |
| 1303 | EXPECT_FALSE(main_dict.GetString("int", static_cast<std::string*>(NULL))); |
| 1304 | EXPECT_FALSE(main_dict.GetString("double", static_cast<std::string*>(NULL))); |
| 1305 | EXPECT_TRUE(main_dict.GetString("string", static_cast<std::string*>(NULL))); |
| 1306 | EXPECT_FALSE(main_dict.GetString("binary", static_cast<std::string*>(NULL))); |
| 1307 | EXPECT_FALSE(main_dict.GetString("dict", static_cast<std::string*>(NULL))); |
| 1308 | EXPECT_FALSE(main_dict.GetString("list", static_cast<std::string*>(NULL))); |
| 1309 | EXPECT_FALSE(main_dict.GetString("DNE", static_cast<std::string*>(NULL))); |
| 1310 | |
| 1311 | EXPECT_FALSE(main_dict.GetString("bool", static_cast<string16*>(NULL))); |
| 1312 | EXPECT_FALSE(main_dict.GetString("int", static_cast<string16*>(NULL))); |
| 1313 | EXPECT_FALSE(main_dict.GetString("double", static_cast<string16*>(NULL))); |
| 1314 | EXPECT_TRUE(main_dict.GetString("string", static_cast<string16*>(NULL))); |
| 1315 | EXPECT_FALSE(main_dict.GetString("binary", static_cast<string16*>(NULL))); |
| 1316 | EXPECT_FALSE(main_dict.GetString("dict", static_cast<string16*>(NULL))); |
| 1317 | EXPECT_FALSE(main_dict.GetString("list", static_cast<string16*>(NULL))); |
| 1318 | EXPECT_FALSE(main_dict.GetString("DNE", static_cast<string16*>(NULL))); |
| 1319 | |
| 1320 | EXPECT_FALSE(main_dict.GetBinary("bool", NULL)); |
| 1321 | EXPECT_FALSE(main_dict.GetBinary("int", NULL)); |
| 1322 | EXPECT_FALSE(main_dict.GetBinary("double", NULL)); |
| 1323 | EXPECT_FALSE(main_dict.GetBinary("string", NULL)); |
| 1324 | EXPECT_TRUE(main_dict.GetBinary("binary", NULL)); |
| 1325 | EXPECT_FALSE(main_dict.GetBinary("dict", NULL)); |
| 1326 | EXPECT_FALSE(main_dict.GetBinary("list", NULL)); |
| 1327 | EXPECT_FALSE(main_dict.GetBinary("DNE", NULL)); |
| 1328 | |
| 1329 | EXPECT_FALSE(main_dict.GetDictionary("bool", NULL)); |
| 1330 | EXPECT_FALSE(main_dict.GetDictionary("int", NULL)); |
| 1331 | EXPECT_FALSE(main_dict.GetDictionary("double", NULL)); |
| 1332 | EXPECT_FALSE(main_dict.GetDictionary("string", NULL)); |
| 1333 | EXPECT_FALSE(main_dict.GetDictionary("binary", NULL)); |
| 1334 | EXPECT_TRUE(main_dict.GetDictionary("dict", NULL)); |
| 1335 | EXPECT_FALSE(main_dict.GetDictionary("list", NULL)); |
| 1336 | EXPECT_FALSE(main_dict.GetDictionary("DNE", NULL)); |
| 1337 | |
| 1338 | EXPECT_FALSE(main_dict.GetList("bool", NULL)); |
| 1339 | EXPECT_FALSE(main_dict.GetList("int", NULL)); |
| 1340 | EXPECT_FALSE(main_dict.GetList("double", NULL)); |
| 1341 | EXPECT_FALSE(main_dict.GetList("string", NULL)); |
| 1342 | EXPECT_FALSE(main_dict.GetList("binary", NULL)); |
| 1343 | EXPECT_FALSE(main_dict.GetList("dict", NULL)); |
| 1344 | EXPECT_TRUE(main_dict.GetList("list", NULL)); |
| 1345 | EXPECT_FALSE(main_dict.GetList("DNE", NULL)); |
| 1346 | |
| 1347 | EXPECT_TRUE(main_dict.GetWithoutPathExpansion("bool", NULL)); |
| 1348 | EXPECT_TRUE(main_dict.GetWithoutPathExpansion("int", NULL)); |
| 1349 | EXPECT_TRUE(main_dict.GetWithoutPathExpansion("double", NULL)); |
| 1350 | EXPECT_TRUE(main_dict.GetWithoutPathExpansion("string", NULL)); |
| 1351 | EXPECT_TRUE(main_dict.GetWithoutPathExpansion("binary", NULL)); |
| 1352 | EXPECT_TRUE(main_dict.GetWithoutPathExpansion("dict", NULL)); |
| 1353 | EXPECT_TRUE(main_dict.GetWithoutPathExpansion("list", NULL)); |
| 1354 | EXPECT_FALSE(main_dict.GetWithoutPathExpansion("DNE", NULL)); |
| 1355 | |
| 1356 | EXPECT_TRUE(main_dict.GetBooleanWithoutPathExpansion("bool", NULL)); |
| 1357 | EXPECT_FALSE(main_dict.GetBooleanWithoutPathExpansion("int", NULL)); |
| 1358 | EXPECT_FALSE(main_dict.GetBooleanWithoutPathExpansion("double", NULL)); |
| 1359 | EXPECT_FALSE(main_dict.GetBooleanWithoutPathExpansion("string", NULL)); |
| 1360 | EXPECT_FALSE(main_dict.GetBooleanWithoutPathExpansion("binary", NULL)); |
| 1361 | EXPECT_FALSE(main_dict.GetBooleanWithoutPathExpansion("dict", NULL)); |
| 1362 | EXPECT_FALSE(main_dict.GetBooleanWithoutPathExpansion("list", NULL)); |
| 1363 | EXPECT_FALSE(main_dict.GetBooleanWithoutPathExpansion("DNE", NULL)); |
| 1364 | |
| 1365 | EXPECT_FALSE(main_dict.GetIntegerWithoutPathExpansion("bool", NULL)); |
| 1366 | EXPECT_TRUE(main_dict.GetIntegerWithoutPathExpansion("int", NULL)); |
| 1367 | EXPECT_FALSE(main_dict.GetIntegerWithoutPathExpansion("double", NULL)); |
| 1368 | EXPECT_FALSE(main_dict.GetIntegerWithoutPathExpansion("string", NULL)); |
| 1369 | EXPECT_FALSE(main_dict.GetIntegerWithoutPathExpansion("binary", NULL)); |
| 1370 | EXPECT_FALSE(main_dict.GetIntegerWithoutPathExpansion("dict", NULL)); |
| 1371 | EXPECT_FALSE(main_dict.GetIntegerWithoutPathExpansion("list", NULL)); |
| 1372 | EXPECT_FALSE(main_dict.GetIntegerWithoutPathExpansion("DNE", NULL)); |
| 1373 | |
| 1374 | EXPECT_FALSE(main_dict.GetDoubleWithoutPathExpansion("bool", NULL)); |
| 1375 | EXPECT_TRUE(main_dict.GetDoubleWithoutPathExpansion("int", NULL)); |
| 1376 | EXPECT_TRUE(main_dict.GetDoubleWithoutPathExpansion("double", NULL)); |
| 1377 | EXPECT_FALSE(main_dict.GetDoubleWithoutPathExpansion("string", NULL)); |
| 1378 | EXPECT_FALSE(main_dict.GetDoubleWithoutPathExpansion("binary", NULL)); |
| 1379 | EXPECT_FALSE(main_dict.GetDoubleWithoutPathExpansion("dict", NULL)); |
| 1380 | EXPECT_FALSE(main_dict.GetDoubleWithoutPathExpansion("list", NULL)); |
| 1381 | EXPECT_FALSE(main_dict.GetDoubleWithoutPathExpansion("DNE", NULL)); |
| 1382 | |
| 1383 | EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion( |
| 1384 | "bool", static_cast<std::string*>(NULL))); |
| 1385 | EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion( |
| 1386 | "int", static_cast<std::string*>(NULL))); |
| 1387 | EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion( |
| 1388 | "double", static_cast<std::string*>(NULL))); |
| 1389 | EXPECT_TRUE(main_dict.GetStringWithoutPathExpansion( |
| 1390 | "string", static_cast<std::string*>(NULL))); |
| 1391 | EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion( |
| 1392 | "binary", static_cast<std::string*>(NULL))); |
| 1393 | EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion( |
| 1394 | "dict", static_cast<std::string*>(NULL))); |
| 1395 | EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion( |
| 1396 | "list", static_cast<std::string*>(NULL))); |
| 1397 | EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion( |
| 1398 | "DNE", static_cast<std::string*>(NULL))); |
| 1399 | |
| 1400 | EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion( |
| 1401 | "bool", static_cast<string16*>(NULL))); |
| 1402 | EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion( |
| 1403 | "int", static_cast<string16*>(NULL))); |
| 1404 | EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion( |
| 1405 | "double", static_cast<string16*>(NULL))); |
| 1406 | EXPECT_TRUE(main_dict.GetStringWithoutPathExpansion( |
| 1407 | "string", static_cast<string16*>(NULL))); |
| 1408 | EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion( |
| 1409 | "binary", static_cast<string16*>(NULL))); |
| 1410 | EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion( |
| 1411 | "dict", static_cast<string16*>(NULL))); |
| 1412 | EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion( |
| 1413 | "list", static_cast<string16*>(NULL))); |
| 1414 | EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion( |
| 1415 | "DNE", static_cast<string16*>(NULL))); |
| 1416 | |
| 1417 | // There is no GetBinaryWithoutPathExpansion for some reason, but if there |
| 1418 | // were it should be tested here... |
| 1419 | |
| 1420 | EXPECT_FALSE(main_dict.GetDictionaryWithoutPathExpansion("bool", NULL)); |
| 1421 | EXPECT_FALSE(main_dict.GetDictionaryWithoutPathExpansion("int", NULL)); |
| 1422 | EXPECT_FALSE(main_dict.GetDictionaryWithoutPathExpansion("double", NULL)); |
| 1423 | EXPECT_FALSE(main_dict.GetDictionaryWithoutPathExpansion("string", NULL)); |
| 1424 | EXPECT_FALSE(main_dict.GetDictionaryWithoutPathExpansion("binary", NULL)); |
| 1425 | EXPECT_TRUE(main_dict.GetDictionaryWithoutPathExpansion("dict", NULL)); |
| 1426 | EXPECT_FALSE(main_dict.GetDictionaryWithoutPathExpansion("list", NULL)); |
| 1427 | EXPECT_FALSE(main_dict.GetDictionaryWithoutPathExpansion("DNE", NULL)); |
| 1428 | |
| 1429 | EXPECT_FALSE(main_dict.GetListWithoutPathExpansion("bool", NULL)); |
| 1430 | EXPECT_FALSE(main_dict.GetListWithoutPathExpansion("int", NULL)); |
| 1431 | EXPECT_FALSE(main_dict.GetListWithoutPathExpansion("double", NULL)); |
| 1432 | EXPECT_FALSE(main_dict.GetListWithoutPathExpansion("string", NULL)); |
| 1433 | EXPECT_FALSE(main_dict.GetListWithoutPathExpansion("binary", NULL)); |
| 1434 | EXPECT_FALSE(main_dict.GetListWithoutPathExpansion("dict", NULL)); |
| 1435 | EXPECT_TRUE(main_dict.GetListWithoutPathExpansion("list", NULL)); |
| 1436 | EXPECT_FALSE(main_dict.GetListWithoutPathExpansion("DNE", NULL)); |
| 1437 | |
| 1438 | EXPECT_TRUE(main_list.Get(0, NULL)); |
| 1439 | EXPECT_TRUE(main_list.Get(1, NULL)); |
| 1440 | EXPECT_TRUE(main_list.Get(2, NULL)); |
| 1441 | EXPECT_TRUE(main_list.Get(3, NULL)); |
| 1442 | EXPECT_TRUE(main_list.Get(4, NULL)); |
| 1443 | EXPECT_TRUE(main_list.Get(5, NULL)); |
| 1444 | EXPECT_TRUE(main_list.Get(6, NULL)); |
| 1445 | EXPECT_FALSE(main_list.Get(7, NULL)); |
| 1446 | |
| 1447 | EXPECT_TRUE(main_list.GetBoolean(0, NULL)); |
| 1448 | EXPECT_FALSE(main_list.GetBoolean(1, NULL)); |
| 1449 | EXPECT_FALSE(main_list.GetBoolean(2, NULL)); |
| 1450 | EXPECT_FALSE(main_list.GetBoolean(3, NULL)); |
| 1451 | EXPECT_FALSE(main_list.GetBoolean(4, NULL)); |
| 1452 | EXPECT_FALSE(main_list.GetBoolean(5, NULL)); |
| 1453 | EXPECT_FALSE(main_list.GetBoolean(6, NULL)); |
| 1454 | EXPECT_FALSE(main_list.GetBoolean(7, NULL)); |
| 1455 | |
| 1456 | EXPECT_FALSE(main_list.GetInteger(0, NULL)); |
| 1457 | EXPECT_TRUE(main_list.GetInteger(1, NULL)); |
| 1458 | EXPECT_FALSE(main_list.GetInteger(2, NULL)); |
| 1459 | EXPECT_FALSE(main_list.GetInteger(3, NULL)); |
| 1460 | EXPECT_FALSE(main_list.GetInteger(4, NULL)); |
| 1461 | EXPECT_FALSE(main_list.GetInteger(5, NULL)); |
| 1462 | EXPECT_FALSE(main_list.GetInteger(6, NULL)); |
| 1463 | EXPECT_FALSE(main_list.GetInteger(7, NULL)); |
| 1464 | |
| 1465 | EXPECT_FALSE(main_list.GetDouble(0, NULL)); |
| 1466 | EXPECT_TRUE(main_list.GetDouble(1, NULL)); |
| 1467 | EXPECT_TRUE(main_list.GetDouble(2, NULL)); |
| 1468 | EXPECT_FALSE(main_list.GetDouble(3, NULL)); |
| 1469 | EXPECT_FALSE(main_list.GetDouble(4, NULL)); |
| 1470 | EXPECT_FALSE(main_list.GetDouble(5, NULL)); |
| 1471 | EXPECT_FALSE(main_list.GetDouble(6, NULL)); |
| 1472 | EXPECT_FALSE(main_list.GetDouble(7, NULL)); |
| 1473 | |
| 1474 | EXPECT_FALSE(main_list.GetString(0, static_cast<std::string*>(NULL))); |
| 1475 | EXPECT_FALSE(main_list.GetString(1, static_cast<std::string*>(NULL))); |
| 1476 | EXPECT_FALSE(main_list.GetString(2, static_cast<std::string*>(NULL))); |
| 1477 | EXPECT_TRUE(main_list.GetString(3, static_cast<std::string*>(NULL))); |
| 1478 | EXPECT_FALSE(main_list.GetString(4, static_cast<std::string*>(NULL))); |
| 1479 | EXPECT_FALSE(main_list.GetString(5, static_cast<std::string*>(NULL))); |
| 1480 | EXPECT_FALSE(main_list.GetString(6, static_cast<std::string*>(NULL))); |
| 1481 | EXPECT_FALSE(main_list.GetString(7, static_cast<std::string*>(NULL))); |
| 1482 | |
| 1483 | EXPECT_FALSE(main_list.GetString(0, static_cast<string16*>(NULL))); |
| 1484 | EXPECT_FALSE(main_list.GetString(1, static_cast<string16*>(NULL))); |
| 1485 | EXPECT_FALSE(main_list.GetString(2, static_cast<string16*>(NULL))); |
| 1486 | EXPECT_TRUE(main_list.GetString(3, static_cast<string16*>(NULL))); |
| 1487 | EXPECT_FALSE(main_list.GetString(4, static_cast<string16*>(NULL))); |
| 1488 | EXPECT_FALSE(main_list.GetString(5, static_cast<string16*>(NULL))); |
| 1489 | EXPECT_FALSE(main_list.GetString(6, static_cast<string16*>(NULL))); |
| 1490 | EXPECT_FALSE(main_list.GetString(7, static_cast<string16*>(NULL))); |
| 1491 | |
| 1492 | EXPECT_FALSE(main_list.GetBinary(0, NULL)); |
| 1493 | EXPECT_FALSE(main_list.GetBinary(1, NULL)); |
| 1494 | EXPECT_FALSE(main_list.GetBinary(2, NULL)); |
| 1495 | EXPECT_FALSE(main_list.GetBinary(3, NULL)); |
| 1496 | EXPECT_TRUE(main_list.GetBinary(4, NULL)); |
| 1497 | EXPECT_FALSE(main_list.GetBinary(5, NULL)); |
| 1498 | EXPECT_FALSE(main_list.GetBinary(6, NULL)); |
| 1499 | EXPECT_FALSE(main_list.GetBinary(7, NULL)); |
| 1500 | |
| 1501 | EXPECT_FALSE(main_list.GetDictionary(0, NULL)); |
| 1502 | EXPECT_FALSE(main_list.GetDictionary(1, NULL)); |
| 1503 | EXPECT_FALSE(main_list.GetDictionary(2, NULL)); |
| 1504 | EXPECT_FALSE(main_list.GetDictionary(3, NULL)); |
| 1505 | EXPECT_FALSE(main_list.GetDictionary(4, NULL)); |
| 1506 | EXPECT_TRUE(main_list.GetDictionary(5, NULL)); |
| 1507 | EXPECT_FALSE(main_list.GetDictionary(6, NULL)); |
| 1508 | EXPECT_FALSE(main_list.GetDictionary(7, NULL)); |
| 1509 | |
| 1510 | EXPECT_FALSE(main_list.GetList(0, NULL)); |
| 1511 | EXPECT_FALSE(main_list.GetList(1, NULL)); |
| 1512 | EXPECT_FALSE(main_list.GetList(2, NULL)); |
| 1513 | EXPECT_FALSE(main_list.GetList(3, NULL)); |
| 1514 | EXPECT_FALSE(main_list.GetList(4, NULL)); |
| 1515 | EXPECT_FALSE(main_list.GetList(5, NULL)); |
| 1516 | EXPECT_TRUE(main_list.GetList(6, NULL)); |
| 1517 | EXPECT_FALSE(main_list.GetList(7, NULL)); |
| 1518 | } |
| 1519 | |
dyaroshev | 2765c7b | 2017-04-06 21:19:04 +0900 | [diff] [blame] | 1520 | TEST(ValuesTest, SelfSwap) { |
| 1521 | base::Value test(1); |
mkwst | 62e159c | 2017-04-11 15:52:21 +0900 | [diff] [blame] | 1522 | std::swap(test, test); |
dyaroshev | 2765c7b | 2017-04-06 21:19:04 +0900 | [diff] [blame] | 1523 | EXPECT_TRUE(test.GetInt() == 1); |
| 1524 | } |
| 1525 | |
tfarina@chromium.org | 4cdd38e | 2011-06-29 07:56:33 +0900 | [diff] [blame] | 1526 | } // namespace base |